JAVASE（继承中的super和this-多态）

一、super代表父类的引用，用于访问父类的属性、方法、构造器

1.基本语法

(1)super()可以访问父类的属性，但不能访问private，语法super.属性名

(2)可以访问父类的方法，不能访问私有方法，语法super.方法名(参数列表)

(3)可以访问父类构造器，语法super(参数列表)，只能放在构造器第一行，只能出现一行，与this不能同时出现

2.super的便捷之处

(1)分工明确，父类属性由父类初始化，子类属性在子类初始化

(2)子类有和父类重名的属性或方法时，为了访问父类，必须通过super()；不重名时，super、this、直接访问效果相同

3.报错分类

(1)子类、父类均查找不到

(2)无法访问

4.super的访问不限于直接父类，如果父类的父类中有同名的属性或方法，用super访问时遵循就近原则

5.方法重写：

条件：(1)子类方法的形参列表和方法名称要和父类完全一致

(2)子类方法的返回类型要和父类相同，或是父类返回类型的子类

(3)子类方法不能缩小父类方法的访问权限

访问权限：public protected 默认 private

6.多态：方法或对象具有多种形态，建立在封装和继承之上

(1)一个对象的编译类型和运行类型可以不一致

(2)编译类型在定义对象时，就确定了，不可改变

(3)运行类型是可以转化的

(4)编译类型看定义时=左边，运行类型看=的右边

ps.广义多态也称为运行时多态，狭义多态也称为编译时多态

==================================================================

多态

1. ==的作用：

• 判断基本数据类型的值是否相等

• 判断两个引用是否指向同一个对象/判断两个对象是否为同一对象

   Student s1 = new Student();
   //s1:存的是首地址
   Student s2 = new Student();
   sout(s1 == s2);//false
   s1 = s2;
   sout(s1 == s2);//true

2.toString

• 是一个方法

• 返回对象的字符串表示形式(不能print)

• 打印一个对象，会默认调用这个对象的toString()方法

  sout(对象名.toString());

• toString()是object中的方法，所有类中都有toString()

  如果自定义类中没有定义toString(),那么使用的就是object类的toString();如果object的不能满足要求，则需要重写

• 该方法不能打印，如果希望在控制台打印，需手动调用sout

1. 继承

1）什么时候需要继承：

• 多个类存在代码冗余，可以抽取到一个父类中，并且多个类和父类是is-a的关系

• extends：当前已经定义的类不能满足要求，并且代码无法修改的情况下，需要使用子类进行扩展

2） 如何实现继承：public class 子类名 extends 父类名{}

• 一个类只能有一个直接父类，可以有多个间接父类

• 如果一个类没有定义父类，则object类就是此类的父类

  object类是所有类的父类

• 子类可以使用父类的属性和方法

1. 访问控制修饰符

1）private：本垒

2)default：同包的类

3)protected：本类，同包的类，非同包子类

4)public

1. 方法重写：

   1）父类和子类中

   2）和父类方法的返回值类型/方法名/参数列表相同

   3） 重写的方法控制访问级别要和父类相同或比父类宽松

   4）Override:让编译器检查使用了该注解的方法是不是重写的方法

2. super关键字

   1）表示父类的对象，用来调用父类的属性和方法

   super.父类的属性名 - 父类和子类有同名属性时使用

   super.父类的方法名

   2） 表示调用父类的构造方法

• 子类构造方法中没有显示调用父类的构造方法，那么子类构造方法首行调用super();

• 子类的构造方法调用了子类中重载的其他构造方法，就不能再同时调用父类的构造方法/super()/super(...);

• super()/super(...)要写在子类构造方法的首行，原因：要先对父类进行初始化

1. 单个对象初始化的顺序

• 没有继承：

1）属性初始化

2）调用构造方法

• 存在继承关系：

  1）父类属性初始化

  2）运行父类构造方法

  3）子类属性初始化

  4）运行子类构造方法

1. 多态

 Test(){
     public static void test(Student s){
         
     }
     public static void test(Teacher t){
         
     }
     
     public static Student test11(){
         
     }
     public static Teacher test22(){
         
     }
 }

1)父类引用指向子类对象/子类对象赋值给父类引用，产生多态(向上转型)

 Person p = new Student();
 Person p = new Teacher();

2)多态细节：

• 编译时看左边，左边有的方法才能调用(Person)

• 运行时看右边，右边实际是什么类型就调用该类型的方法(Student Teacher)

• 编译和运行时呈现不同的状态 ==>多态

• 应用：

  • 使用父类作为方法形参实现多态，使方法参数的类型更为宽泛；

  • 使用父类作为方法返回值实现多态，使方法可以返回不同的子类对象。

  a.equalsIgnoreCase(" ?") 忽略大小写

   public static void test(Person p ){
       //也可以传入Student和Teacher
   }
   ​
   Person p1 = new Student();
   Person p2 = new Teacher();
   p1.eat();
   p2.sleep();//父类引用指向子类对象/子类对象赋值给父类引用

4）转型

• 向上转型：父类引用指向子类对象/子类对象赋值给父类引用

• 向下转型：（子类类型）父类引用 Student s = (Student) p;

   test(Person p){
       if(p instanceof Teacher){
           Teacher t = (Teacher) p;
       }
   }