Java面向对象03 三大特征：封装 继承 多态

目录

一、封装

1.属性私有

2.get/set

(1)get

(2)set

 3.总结

二、继承

1.继承定义

2.Object类

3.super

4.方法重写

三、多态

1.举例说明

2.多态注意事项

3. instanceof

4.类型转换 

---

一、封装

“高内聚，低耦合”

牢记     属性私有，get/set

1.属性私有

private：私有           加上private这些属性就变为了私有属性，不能在main方法中直接用

private String name;//名字
private int id;//学号
private char sex;//性别
private int age;

2.get/set

提供一些可以操作这个属性的方法
提供一些public的 get ，set 方法

(1)get

get  获得这个数据（属性）      在main方法中写   s1.getName（）；

public String getName(){
    return this.name;
}

(2)set

set   给这个数据设置值              在main方法中写   s1.setName（“小仪”）；

public void setName(String name){
   this.name=name;
}

 3.总结

 1.提高程序安全性，保护数据
2.隐藏代码的实现细节
3.统一接口
4.系统可维护提高了

快捷键生成get/set    Art+insert

二、继承

1.继承定义

继承的本质是对某一批类的抽象。

extends :扩展。子类是父类的扩展

Java中类只有单继承，没有多继承！

子类和父类之间，从意义上讲应该具有“is  a” 的关系

子类继承了父类，就会拥有父类的全部方法！

私有的东西无法被继承（可以通过get/set来）

2.Object类

在Java中所有的类，都默认直接或间接继承object

3.super

super注意点：
    1.super调用父类的构造方法，必须在构造方法的第一个
    2.super必须只能在子类的方法或者构造方法中！
    3.super和this不能同时调用构造方法
对比  this
代表的对象不同：
    this：本身调用着这个对象
    super：代表父类对象的引用

前提
    this：没有继承也可以使用
    super：只能在继承条件才可以使用

构造方法
    this（）;本类的构造
    super（）；父类的构造

public Student() {
    //隐藏代码；调用了父类的无参构造
    super();//调用父类的构造器，必须要在子类构造器的第一行
    System.out.println("Student无参执行了");

}

4.方法重写

重写都是方法的重写，和属性无关

重写：

需要有继承关系，子类重写父类的方法！
    1.方法名必须相同
    2.参数列表列表必须相同
    3.修饰符:范围可仪扩大：  public > Protected > Default > private
    4.抛出的异常：范围可以被缩小 但不能被扩大；

重写，子类的方法和父类必须要一致；方法体不同

为什么需要重写：
    1.父类的功能，子类不一定需要，或者不一定满足！
    快捷键    alt+insert  ；  override

静态的方法和非静态的方法区别很大！
   //静态方法     //方法的调用只和左面，定义的数据类型有关
   //非静态：  重写

三、多态

1.举例说明

1.

  //一个对象的实际类型是确定的
    //new Student();
    //new Person();

    //可以指向的引用类型就不确定了  父类的引用指向了子类

    //Student能调用的方法都是自己的或者继承父类的！
    Student s1 = new Student();
    //Person父类型，可以指向子类，但是不能调用子类独有的方法
    Person s2 = new Student();
    Object s3 = new Student();

    //对象能执行哪些方法，主要看对象左边类型，和右边关系不大
    s2.run();//子类重写了父类的方法，执行子类的方法
    s1.run();

    s1.eat();
    ((Student) s2).eat();//强制转换

}

2.多态注意事项

多态注意事项：
    1.多态是方法的多态，属性没有多态
    2.父类和子类，有联系  类型转换异常 ClassCastException
    3.存在条件：  继承关系，方法需要重写，父类的引用指向子类对象！

4.多态在操作成员变量的时候，编译看左边，运行看右边。

father f1 = new Son（）； 

不能重写   没办法实现多态
1.static 方法，属于类，不属于实例
2.final 常量
3.private方法：

3. instanceof

判断一个对象什么类型；判断两个类之间是否存在父子关系

//Object>String
//Object > Person > Student
//Object > Person > Teacher
Object object = new Student();
//看在哪一级中，就在那一级比较
//Student和Teacher是同级就不能比较，报编译报错
//System.out.println(X instanceof Y);//能不能编译通过！（看X与Y有没有父子关系）

System.out.println(object instanceof Student);//true
System.out.println(object instanceof Person);//true
System.out.println(object instanceof Object);//true
System.out.println(object instanceof Teacher);//false
System.out.println(object instanceof String);//false

System.out.println("========================");
Person person = new Student();
System.out.println(person instanceof Student);//true
System.out.println(person instanceof Person);//true
System.out.println(person instanceof Object);//true
System.out.println(person instanceof Teacher);//false
//ystem.out.println(person instanceof String);//编译报错

System.out.println("=========================");
Student student = new Student();
System.out.println(student instanceof Student);//true
System.out.println(student instanceof Person);//true
System.out.println(student instanceof Object);//true
//System.out.println(student instanceof Teacher);//编译报错
//System.out.println(student instanceof String);//编译报错
}

4.类型转换 

//类型之间的转换：父   子

//子类转换为父类，可能丢失自己本来的一些方法！
//高                   低        (高到低强行转换，低到高自动转换)
Person obj = new Student();

//student将这个对象转换为Student类型，我们就可以使用Student类型的方法了

Student student = (Student) obj;(强行转换)
student.go();
//((Student) obj).go();

Student student1 = new Student();
student1.go();
Person person=student1;（自动转换）

总结： 

1.父类引用指向子类的对象
2.把子类转换为父类，向上转型；
3.把父类转换为子类，向下转型，强制转换
4.方便方法调用，减少重复的代码！