java三大特性
封装、继承、多态
封装
关键词：private
该露的露，该藏的藏。
高内聚，低耦合
高内聚：类内部的数据操作细节自己完成，不允许外部干预；
低耦合: 仅暴露少量方法给外部使用。
封装(数据的隐藏)：应该禁止直接访问一个对象中数据的实际表示，通过操作接口来访问
重点！！！ 属性私有，get/set。
private。
package charpter5.Demo05;
public class Application {
public static void main(String[] args) {
Student student = new Student();
//不能用student.name直接操作了，因为属性私有。
//需要用一些public的get()/set()方法。
System.out.println(student.getName());
student.setName("ssl");
System.out.println(student.getName());
}
}
package charpter5.Demo05;
//类
public class Student {
//封装 属性私有，数据隐藏
//名字
private String name;
//学号
private int id;
//性别
private char sex;
public String getName(){
return this.name;
}
public void setName(String name){
this.name=name;
}
//alt+insert快捷键，可以直接添加get()/set()方法
//初始化的时候可以加相关的约束。
public int getId() {
return id;
}
}
继承
关键词：extends super public protected default private
子类、派生类：是父类(基类)的拓展。
-
object类：所有类的父类。
package charpter5.Demo06;
//在java中，所有的类，都默认直接或者间接继承Object类。
//java中只有单继承，没有多继承。
//父类
public class Person {
/**四个修饰符
* //public 公有变量：类内部、同一个包、子类、任何地方
* //protected 保护变量：类内部、同一个包、子类
* //default 默认变量：类内部、同一个包
* //private 私有变量：类内部 用来封装，一般用在属性上，会开放一些get/set方法来操作属性
*/
//快捷键 ctrl+H 打开继承树
//公有实例变量
public int money =10_000_00;
public void say(){
System.out.println("hello,I am a person");
}
}
package charpter5.Demo06;
//子类 继承父类 就会拥有父类的全部方法。
public class Student extends Person{
}
package charpter5.Demo06;
//子类
public class Teacher extends Person{
}
package charpter5.Demo06;
public class Application {
public static void main(String[] args) {
Student student = new Student();
student.say(); //输出：hello,I am a person
}
}
-
super关键词: 访问父类的属性和方法 super. 私有的不能访问。
创建对象的时候，先调用父类的构造器，再调用子类的构造器。 子类的构造器内默认第一行有super()（父类的无参构造器）。
注意点：
-
super调用父类的构造方法，必须在构造方法的第一个。
-
super必须只能出现在子类的方法或者构造方法中。
-
super和this 不能同时调用构造方法！因为都要求在第一行。
super VS this：
代表的对象不同：
this：本身调用者这个对象
super：父类对象的应用
前提：
this：没有继承也可以使用
super：只能在继承条件才可以使用
构造方法：
this：本类的构造
super：父类的构造
package charpter5.Demo06;
//父类
public class Person {
protected String name = "ssl_Person";
public void print(){
System.out.println("Person");
}
public Person(){
System.out.println("Person构造");
}
}
package charpter5.Demo06;
//子类 继承父类 就会拥有父类的全部方法。
public class Student extends Person{
private String name = "ssl_Student";
//super 用来访问父类的属性和方法
public void test(String name){
System.out.println(name);
System.out.println(this.name);
System.out.println(super.name);
/**
* ssl_Application
* ssl_Student
* ssl_Person
*/
}
public void print(){
System.out.println("Student");
}
public void test(){
print(); //相当于用this.
this.print();
super.print();
/**
* Student
* Student
* Person
*/
}
public Student(){
System.out.println("Student构造");
}
}
package charpter5.Demo06;
public class Application {
public static void main(String[] args) {
Student student = new Student();
/**
* Person构造
* Student构造
*/
student.test("ssl_Application");
student.test();
}
}
-
方法重写 -----重写的都是非静态方法，与属性无关。关键词不能为private 需要有继承关系
-
方法名必须相同
-
参数列表必须相同
-
修饰符：范围可以扩大；但不能缩小。
-
抛出的异常：范围可以缩小，但不能扩大。
package charpter5.Demo07;
//父类
public class B {
public static void test(){
System.out.println("B_static");
}
public void test2(){
System.out.println("B");
}
}
package charpter5.Demo07;
//子类
public class A extends B{
public static void test(){
System.out.println("A_static");
}
public void test2(){
System.out.println("A");
}
}
package charpter5.Demo07;
//重写都是非静态方法 与属性无关
public class App {
public static void main(String[] args) {
A a = new A();
a.test(); //输出：A_static
//方法的调用只和左边的类型有关。
//父类的引用指向了A
B b = new A();
b.test(); //输出：B_static
B c = new B();
a.test2(); //输出：A
b.test2(); //输出：A 方法重写
c.test2(); //输出：B
/**
* 静态方法和非静态方法有区别。
*/
}
}
多态
动态编译：类型，可扩展性
同一方法可以根据发送对象的不同而采取多种不同的行为方式。
一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多。
多态存在的条件：
-
有继承关系。
-
子类重写父类方法。
-
父类指向子类对象。
注意：多态是方法的多态，属性没有多态。
package charpter5.Demo08;
public class Person {
public void run(){
System.out.println("Person_run");
}
}
package charpter5.Demo08;
public class Student extends Person{
public void run(){
System.out.println("Student_run");
}
public void eat(){
System.out.println("eat");
}
}
package charpter5.Demo08;
public class App {
public static void main(String[] args) {
//一个对象的实际类型是确定的
//new Student();
//new Person();
Student s1 = new Student();
//父类的引用指向子类的类型
Person s2 = new Student();
//只能调用父类有的方法，子类重写，调用子类，未重写，调用父类。
Object s3 = new Student();
s2.run();
//s2.eat(); 报错，父类没有该方法
//强制类型转换，可以访问。
((Student)s2).eat(); //输出：eat
/**
* 多态是方法的多态，属性没有多态
* 父类和子类才行，类型转换异常ClassCastException
* 存在条件：继承关系、有方法重写、父类引用指向子类对象。
*
* 1.final不能重写
* 2.private不能重写
* 3.static不能重写
*/
}
}
instanceof与类型转换
关键词：instanceof 引用类型转换
package charpter5.Demo08;标签：java,子类,void,特性,Student,println,父类,public,三大 From： https://www.cnblogs.com/ssl-study/p/16734126.html
public class App {
public static void main(String[] args) {
Student s1 = new Student();
Person s2 = new Student();
Object s3 = new Student();
System.out.println(s3 instanceof Person);
System.out.println(s3 instanceof Student);
/**
* true
* true
* 判断类型是否相关，父子关系在一条线上为true 否则为false
* 同级编译报错。
*/
//类型转换
/**
* 父类为高，子类为低
* 高转低用强制转换 向下转型 丢失部分方法
* 低转高可以默认 向上转型
* 方便方法的调用。
*/
((Student)s2).eat();
}
}