封装、继承、多态的详细说明_封装继承多态的理解-CSDN博客

本文详细介绍了Java中的封装、继承和多态。封装是面向对象的第一步，通过类来封装数据和函数。继承允许子类继承父类的属性和方法，子类必须调用父类构造器完成初始化。多态则是同一个方法根据对象不同有不同的行为，它需要继承和方法重写作为前提。

封装

1、封装的含义：封装是实现面向对象程序设计的第一步，封装就是将数据或函数等集合在一个个的单元中（我们称之为类）。被封装的对象通常被称为抽象数据类型。

2、封装的作用：封装的作用在于保护或者防止代码（数据）被我们无意中破坏。在面向对象程序设计中数据被看作是一个中心的元素并且和使用它的函数结合的很密切，从而保护它不被其它的函数意外的修改

继承

子类继承了所有的属性和方法，非私有的属性和方法可以在子类中直接访问，但是私有的属性和方法不能在子类直接访问，要通过公共的方法去访问（get set）
子类必须调用父类的构造器，完成父类的初始化
当创建子类对象时，不管使用子类的那个构造器，默认情况下总会去调用父类的无参构造器，如果父类没有提供无参构造器，则必须在子类的构造器中用 super 去指定使用父类的哪个构造器，完成对父类的初始化工作，否则，编译不会通过
如果希望指定去调用父类的某个构造器，则显示的调用一下：super(参数列表)
super在使用时，需要放在构造器的第一行（super只能在构造器中使用）
super() 和 this() 都只能放在构造器的第一行，因此这两个方法不能共存在于一个构造器中
java所有类都是Object类的子类，Object是所有类的基类（父类）
父类构造器的调用不限于直接父类！将一直往上追溯直到Object类（顶级父类）
子类最多只能继承一个父类（指直接继承），即 java中是单继承机制
不能滥用继承，子类和父类之间必须满足 is-a 的逻辑关系

就近原则：

首先看创建的子类是否有该属性
如果子类有这个属性，并且可以访问，则返回信息
如果子类没有这个属性，就看他的上一级的父类有没有这个属性（如果父类有该属性，并且可以访问，就返回信息
如果父类没有就按照3 的规则，继续找它的上级父类，直到Object…

注意点：：

如果子类去调用某个属性，这个属性子类本身没有 但父类有，却是private   则会报错

如果父类的父类也有该属性并且是public的，但是依旧会报错，因为你最初找到的那个属性是 private 的

如下面的 age：

public static void main(String[] args){
    Son son = new Son();
    
    System.out.println(son.age) // 会报错
}
class GrandPa{
    int age = 70;
}
class Father extengds GrandPa{
    private int age  = 40;   
}
class Son extends Father{   
}

重写：需要有继承关系，子类重写父类的方法！

方法名必须相同
参数列表也必须相同
修饰符：范围只能扩大不能缩小： public>Protected(保护的) > Default(默认的) > private(私有的)
重写会抛出异常：范围，可以被缩小，但不能被扩大（重写异常抛出范围不能大于父类）

多态

即同一个方法可以根据发送对象的不同而采用多种不同的行为方式

一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多

多态的存在条件：

有继承关系
子类重写父类方法
父类引用指向子类对象

注意：多态是方法的多态，属性没有多态性

多态的前提是：两个对象（类）存在继承关系

多态的向上转型

本质：父类的引用指向了子类的对象
语法：父类类型引用名 = new 子类类型（）；
特点：编译类型看等号左边，运行类型看等号右边

可以调用父类中的所有成员（需要遵守访问权限）但不能调用子类中特有成员

最终运行效果看子类的具体实现！

多态的向下转型：

语法：子类类型引用名 = （子类类型）父类引用；
只能强转父类的引用，不能强转父类的对象
要求父类的引用必须指向的是当前目标类型的对象
当向下转型后，就可以调用子类类型中所有的成员

编译类型看等号的左边运行类型看等号的右边

public static void main(String args[]){
    // 向上转型： 父类的引用指向了子类的对象
    // 语法： 父类类型 引用名 = new 子类类型();
    Animal animal = new Cat();
    // 可以调用父类中的所有成员（需要遵守访问权限）
    // 但是不能调用子类的特有的成员
    // 因为在编译阶段，能调用哪些成员，是由编译类型来决定的
    // animal.cry();  所以是错误的
    // 最终运行效果看子类（运行类型）的具体实现， 即调用方法时，按照子类（运行类型）
    // 开始查找方法，然后调用，规则跟前面的方法调用规则一致。
    
    animal.eat(); // 先看子类Cat类里面有没有eat()方法；  因为有  所以输出 猫吃鱼
 // animal.cry(); // 为什么不能调用 cry()方法， 因为父类Animal里面没有该方法  编译器 认为你调用的
 // 方法在Animal中 但Animal里面没有   所以就会报错
    animal.run(); // 因为子类中没有run()方法， 所以就调用父类的run()方法  输出  run
    
    
    // 我现在想，可以调用Cat的 catchMouse()方法
        // 多态的向下转型
        // 语法： 子类类型 引用名 = （子类类型） 父类引用；

        // 问一个问题？ cat 的编译类型 Cat， 运行类型是 Cat （= 号左右）
        Cat cat = (Cat) animal;
        cat.cry(); // cry
}

class Animal{
    public void run (){
        System.out.println("run");
    }
    public void eat(){
        System.out.println("eat")
    }
}

class Cat extends Animal{
    public void cry(){
        System.out.println("cry");
    }
    public void eat(){
        System.out.println("猫吃鱼")
    }
}

注意：：

属性没有重写之说！！！属性没有重写之说！！！属性没有重写之说！！！

public class PolymorphicDetail {
    public static void main(String[] args) {
        // 属性没有重写之说！  属性的值看 编译类型
        Base base = new Sub();// 向上转型
        System.out.println(base.count); //因为属性的值看编译类型 所以输出10
    }
}

class Base { // 父类
    int count = 10; //属性
}

class Sub extends Base { //子类
    int count = 20; //属性
}

比较操作符： instanceof

//instanceof 比较操作符，用于判断对象的运行类型是否为xx类型或xx类型的子类型

public class PolymorphicDetail {
    public static void main(String[] args) {
        BB bb = new BB();
        System.out.println(bb instanceof BB); // true
        System.out.println(bb instanceof AA); // true
        System.out.println(bb instanceof Object);// true

        // aa 的编译类型 AA， 运行类型是 BB
        // instanceof 对象看的是运行类型
        AA aa = new BB();
        System.out.println(aa instanceof AA); // true
        System.out.println(aa instanceof BB);// true


    }
}

class AA {}
class BB extends  AA{}