继承 多态 抽象类 接口

一、继承：

• 达到代码复用；
• 继承会继承除父类的构造方法外的所有方法
• 父类的private修饰的子类无法访问

final修饰的不能被继承

1. 子类继承父类后,子类的构造方法会默认调用父类的无参构造方法
2. 如果父类只拥有有参构造方法,而没有写无参构造方法,此时父类就只有有参的构造方法,所以在子类的构造方法中,必须显示的调用父类的有参构造方法,并且是在子类构造方法的第一行调用,否则会报错.
3. 因为在新建子类对象时,要先执行父类的构造方法,再执行子类的构造方法
4. 父类的方法为 private 的时候, 子类方法不能进行重写.

访问权限：

• private：同一包中同一类
• default：（默认，包访问权限）同一包中同一类，同一包中不同类
• protected：同一包中同一类，同一包中不同类，不同包中的子类（类的编写者可以调用，类的调用者不能掉用）
• public：同一包中同一类，同一包中不同类，不同包中的子类，不同包中的非子类

二、什么是多态：
多态的核心就是让调用者不必关注对象的具体类型，这是降低用户使用成本的一种重要方式

• 1、父类引用 引用子类对象
• 2、父类和子类有同名的覆盖方法
• 3、通过父类引用代用这个重写的方法的时候。 多态。

父类引用 引用子类对象 向上转型

public static void func(Animal animal) {
        animal.eat();
    }
public static void main(String[] args) {
        Cat cat = new Cat("咪咪");
        Bird bird = new Bird("咕咕");
        func(cat);
        func(bird);
    }

理解多态：
向上转型，动态绑定，方法重写
我们可以写一些只关注父类的代码，同时能够兼容各种子类的情况

1.向上转型：

• 父类引用指向子类的实例

2.运行时绑定（动态绑定）：

• 父类引用 引用子类对象。同时 通过父类引用调用同名的覆盖方法
• 此时就会发生运行时绑定。

//父类引用  引用子类对象  向上转型
Animal animal = new Cat("初一","胡子");

3.方法重写

• 重写与重载
  - 重写：方法名称、返回值类型、参数的类型及个数完全相同
  - 重载：方法名称相同，参数类型及个数不同，返回值不做要求
• 普通方法可以重写，static修饰的静态方法不能重写
• 重写中子类的 方法访问权限不能低于父类的访问权限
• 重写的方法返回值类型不一定和父类的方法相同（最好相同，特殊情况除外）

事实上：方法重写是Java语法层次的规则，而动态绑定是方法重写这个语法规则的底层实现，两者本质描述的是一个事情，只是侧重点不同

使用多态的好处：
1.类调用者对类的使用成本进一步降低

• 封装是让类的调用者不需要知道类的实现细节
• 多态能让类的调用者连这个类的类型是什么都不必知道，只需要知道这个对象有某个方法即可

2.能够降低代码的“圈复杂度”，避免使用大量的if- else

3.可扩展能力更强

• 对于类的调用者来说，只需要创建一个新类的实例就可以了，改动成本很低

this 当前对象的引用
super 父类对象的引用

三、抽象类：

• 1、抽象方法：一个方法如果被abstract修饰，那么这个方法就是抽象方法。抽象方法
• 可以没有具体的实现。
• 2、包含抽象方法的类，抽象类。
• 注意：
• 1、抽象类不可以被实例化。不能Shape shape = new Shape();
• 2、类内的数据成员，和普通类没有区别。
• 3、抽象类主要就是用来被继承的.
• 4、如果一个类继承了这个抽象类，那么这个类必须重写抽象类当中的抽象方法。
• 5、当抽象类A 继承 抽象类B 那么A可以不重写B中的方法，但是一旦A要是再被继承，
• 那么一定还要重写这个抽象方法。
• 6、抽象类或者抽象方法 一定是不能被final修饰的。

四、接口(interface)：

• 1、接口当中的方法，都是抽象方法。
• 2、其实可以有具体实现的方法。这个方法是被default修饰的（JDK1.8加入的）
• 3、接口当中定义的成员变量，默认是常量。
• 4、接口当中的成员变量默认是：public static final 成员方法是：public abstract
• 5、接口是不可以被实例化的。 Shape shape = new Shape();
• 6、接口和类之间的关系 : implements
• 7、为了解决Java单继承的问题.可以实现多个接口。后面会讲。
• 8、只要这个类 实现了该接口，那么你就可以进行向上转型了。

一个类可以继承一个普通类/抽象类，并且可以同时实现多个接口
extends implements

class Frog extends Animal implements IRunning,ISwimming {}

用接口类型的引用来接受实现接口的对象

不用关注具体类型，只关注类是否具有某种能力。

接口的使用实例：

• 一般情况下：自定义类型进行比较 需要是 可比较的。
• Comparable Comparator 有区别的！！！