JAVA复习，重点来封装，继承，多态（上接Day8) 多态（个人理解）：向下转型编译类型就是定义，运行类型就是new的；属性看编译类型

本文链接：https://blog.csdn.net/m0_46511996/article/details/128846446

JAVA复习Day9 继承多态重点

8.4.8继承的本质

如果在主方法中只创建了一个子类，则只开辟一个堆
在这里插入图片描述
堆中的叫son对象，层级的往上找数据

8.5.1super关键字基本介绍和语法

基本介绍
super代表父类的引用，用于访问父类的属性，方法，构造器
语法
访问父类的属性，但是不能访问父类的私有属性
可以访问父类的方法，但是不能访问父类的私有方法
访问父类的构造器，只能出现在第一句

8.5.2super带来的便利

1、调用父类构造器的好处，分工明确
2、当子类中有父类中的成员重名时，为了访问父类的成员，必须通过super,如果没有重名super和this是一样的
super.方法直接找父类的方法
this.方法从本类开始找，如果没有就继续向上寻找父类，直到Object（在查找属性的过程中，找到了但是不能访问，则报错，cannot access，若在查找方法中，找到了但是不能访问，则报错）
3、super类的访问不限于直接父类，如果对爷爷类和本类中有同名的成员，也可以使用super去访问爷爷类的成员，如果有多个基类（上级类）中都有同名的成员，使用super访问遵顼就近原则（不停的往上找）

8.5.3super和this关键字的比较

在这里插入图片描述

8.6.1方法重写/方法覆盖

方法覆盖就是子类有一个方法和父类的某个方法的名称，返回类型，参数一样，就说子类覆盖了父类的方法

package com.various;
public class Animal {//父类
    public void cry(){
        System.out.println("动物叫");
    }
}
package com.various;

public class Dog extends Animal {//子类继承父类
    public void cry() {
        System.out.println("小狗汪汪汪");//重写
    }
}

package com.various;

public class yext {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.cry();
    }
}

8.6.2方法重写细节

1、子类的方法的参数，方法名称要和父类方法的参数，方法名称完全一样
2、子类方法的返回类型和父类方法的返回类型一样，或者是父类返回类型的子类
3、子类方法不能缩小父类方法的访问权限

8.6.3比较重载和重写

在这里插入图片描述

8.7.1多态基本介绍

多态可以提高代码复用性，有利于维护
方法或对象具有多种状态，是面向对象的第三大特征，多态是建立在封装和继承基础之上的

具体体现
1、方法的多态重写和重载就体现多态
2、对象的多态
A:一个对象的编译类型和运行类型可以不一致，也可以一致
例：上接上面代码

Animal animal = new Dog();  
//animal编译类型时Animal，运行类时Dog
animal = new Cat();
//animal的运行类型变成了Cat，编译类型仍然是Animal

B:编译类型在定义对象时，就确定了，不能改变
C:运行类型是可以变化的
D:编译类型看定义时**=号的左边**，运行类型看=号的右边

8.7.2多态的注意事项/细节

多态的前提：两个对象（类）存在继承关系
多态的向上转型

父类的引用指向了子类的对象
语法：父类类型引用名 = new 子类类型（）
特点:
A: 编译类型看左边，运行类型看右边
B:可以调用父类中的所有成员（遵守访问权限）
C:不能调用子类中特有的成员(在编译阶段能调用哪些成员，是由编译类型决定的，javac进行编译)
D:最终运行效果看子类的具体实现（运行的时候看的是运行类型，java
运行，，，调用方法时，按照从子类开始查找方法，然后调用，一直向上去找）

多态向下转型 为了解决不能调用子类中的特有成员
语法：子类类型引用名 = （子类类型）父类引用
A:只能强转父类的引用，不能强转父类的对象

Cat  cat  = (Cat)  animal;//编译类型为Cat,运行类型为Cat
cat.catMouse();//这里的catMouse是cat的一个方法
//cat是animal的子类
System.out.println("ok");

B:要求父类的引用必须指向的是当前目标类型的对象

Animal animal = new Cat();//向上转型
Cat  cat  = (Cat)  animal;//编译类型为Cat,运行类型为Cat，向下转型
//要求animal的引用必须是指向cat的对象
//这里可以理解要先有向上转型才能有向下转型
cat.catMouse();//这里的catMouse是cat的一个方法
//cat是animal的子类
System.out.println("ok");

这里是向上转型的示意图
向下转型的时候，编译类型未Cat
只能把指向猫的animal指向猫而不能转化成狗

在这里插入图片描述
C:可以调用子类类型中所有的成员
细节
属性没有重写之说，属性的值看编译类型
############################################
instanceof比较操作符，用于判断对象的运行类型是否为XX类型或XX类型的子类型
############################################
属性看编译；方法分两类；
上转调父亲；运行看儿子（找不到一直往上找）
下转调儿子特

8.7.3多态的动态绑定机制

############################################
调用方法时，方法和该对象的运行类型绑定
调用属性时，没有动态绑定，哪里声明哪里绑定
###########################################

8.7.4多态的应用多态数组

数组的定义类型为父类类型，里面保存的实际元素类型为子类类型
父类【】名称 = new 父类【】;
当第二次出现的父类用子类替换的时候，就是存在向上转型

8.7.4多态的应用多态参数

8.8Object类

8.8.1 Object的方法

==和equals的对比

==是一个比较运算符；既可以判断基本类型，又可以判断引用类型（判断是否指向一个对象）

equals是Object类中的方法，只能判断引用类型
默认判断的是地址是否相等，子类往往重写该方法，用于判断内容是否相等

8.8.2如何重写equals方法

首先判断两个对象是否指向一个对象，如果是则直接返回

package com.equalss;

 class Person {
    private String name;
    private  int age;
    private char gender;

     public Person(String name, int age, char gender) {
         this.name = name;
         this.age = age;
         this.gender = gender;
     }
     public boolean equals(Object obj) {//方法重写
        if (this == obj){//判断是否是指向一个对象
            return  true;//如果是则直接返回
        }
        if (obj instanceof Person){
            //判断是否是同一个类
            //如果是同一个类则进行向下转型，得到obj的属性
            Person p = (Person) obj;
            return  this.name.equals(p.name)&&this.age==p.age&&this.gender==p.gender;
        }
        return  false;
    }
}

package com.equalss;

public class equalss {
    public static void main(String[] args) {

        Person person = new Person("jack",10,'男');
        Person person1 = new Person("jack",10,'男');
        System.out.println(person.equals(person1));
    }
}