第1节 继承

继承的概述

面向对象的三大特征：封装性、继承性、多态性。继承是多态的前提，如果没有继承，就没有多态。

师傅会多少武功，大徒弟也会，小徒弟也会

继承主要解决的问题就是：共性抽取

继承关系当中的特点：

1、子类可以拥有父类的“内容”

2、子类还可以拥有自己专有的内容

继承的格式

在继承的关系中，“子类就是一个父类”。也就是说，子类可以被当作父类看待。例如父类是员工，子类是讲师，那么“讲师就是一个员工”。关系：is-a。

定义父类的格式：（一个普通的类定义）

public class 父类名称 {

    ...

}

定义子类的格式：

public class 子类名称 extends 父类名称 {

    ...

}

继承中成员变量的访问特点

在父类的继承关系当中，如果成员变量重名，则创建子类对象是，访问有两种方式：

    直接通过子类对象访问成员变量：

        等号左边是谁，就优先是谁，没有则向上找。

    间接通过成员方法访问成员变量：

        该方法属于谁，就优先用谁，没有则向上找。

区分子类方法中重名的三种方法

局部变量：              直接写成员变量名

本类的成员变量：  this.成员变量名

父类的成员变量：  super.成员变量名

继承中成员方法的访问特点

在父类的继承关系当中，创建子类对象，访问成员变量的规则：

    创建的对象是谁，就优先用谁，如果没有则就向上找

注意事项：

    无论是成员方法还是成员变量，如果没有都是向上找父类，绝对不会向下找子类

继承中方法的覆盖重写_概念

重写（Override）：在继承关系当中，方法名称一样，参数列表【也一样】。也叫：覆盖、覆写。

重载（Overload）：方法名称一样，参数列表【不一样】

方法的覆盖重写特点：创建的是子类对象，则优先使用子类方法

继承中方法的覆盖重写_注意事项

1、必须保证父子类之间方法的名称相同，参数列表也相同。

@Override：写在方法前面，用来检测是不是有效的正确覆盖重写，这个注解就算不写，只要满足要求，也是正确的方法覆盖重写

2、子类方法的返回值必须【小于等于】父类方法的返回值范围。

例：java.long.Object类是所有类的公共最高父类（祖宗类），java.long.String就是Object的子类

3、子类方法的限权必须【大于等于】父类方法的权限修饰符。

例：public > protected > (default) > private

备注：(default)不是关键字default，而是什么都不写，留空

继承中方法的覆盖重写_应用

继承中构造方法的访问特点

1、子类构造方法当中有一个默认隐含的“super()”调用，所以一定是先调用的父类构造，后执行的子类构造。

2、子类构造可以通过super关键字来调用父类重载构造。

3、super的父类构造调用，必须是子类构造方法的第一个语句。不能一个子类构造调用多次super构造。

总结：子类必须调用父类构造方法，不写则赠送super()；写了则用写的指定的super只能有一个，还必须是第一个。

super关键字的三种用法

super关键字的用法有三种：

    1、在子类的成员方法中，访问父类的成员变量。

    2、在子类的成员方法中，访问父类的成员方法。

    3、在子类的构造方法中，访问父类的构造方法。

this关键字的三种用法

super关键字用来访问父类内容，而this关键字用来访问本来内容。用法也有三种：

    1、在本类的成员方法中，访问本类的成员变量。

    2、在本类的成员方法中，访问本类的另一个成员方法。

    3、在本类的构造方法中，访问本类的另一个构造方法。

在第三种用法当中要注意：

    A：this(...)调用也必须是构造方法的第一个语句，唯一一个。

    B：super和this两种构造方法，不能同时调用

super与this关键字图解

Java继承的三个特点

第2节 抽象类

抽象的概念

抽象方法和抽象类的格式

抽象方法：就是加上abstract关键字，然后去掉大括号，直接分号结束

抽象类：抽象方法所在的类，必须是抽象类才行。在class之前写上abstract即可

抽象方法和抽象类的使用

    1、不能直接创建（new）抽象类对象。

    2、必须用一个字累来继承抽象父类。

    3、子类必须覆盖重写抽象父类当中所有的抽象方法。

    覆盖重写（实现）：子类去掉抽象方法的abstract关键字，然后补上方法体大括号。

    4、创建子类对象进行使用

抽象方法和抽象类的注意事项

关于抽象类的使用，以下为语法上要注意的细节，虽然条目较多，但若理解了抽象的本质，无需死记硬背。

    1.抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。

        理解:假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。

    ⒉抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。

        理解:子类的构造方法中，有默认的super()，需要访问父类构造方法。

    3.抽象类中，不一定包含抽象方法,但是有抽象方法的类必定是抽象类。

        理解:未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设计。

    4.抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象类。

        理解:假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有意义。

发红包案例_分析

发红包案例_实现

第3节 接口

接口的定义基本格式

接口就是多个类的公共规范。

接口是一种引用数据类型，最重要的内容就是其中的：抽象方法。

如何定义一个接口的格式：

    public interface 接口名称{

         // 接口内容

    }

备注：换成了关键字interface之后，编译生成的字节码文件仍然是：.java --> .class。

如果是Java7，那么接口中可以包含的内容有：

    1、常量

    2、抽象方法

如果是Java8，还可以额外包含有：

    3、默认方法

    4、静态方法

如果是Java9，还可以额外包含有：

    5、私有方法

接口的抽象方法定义

在任何版本的Java中，接口都能定义抽象方法

完整格式：public abstract 返回值类型 方法名称(参数列表);

注意事项：

    1、接口当中的抽象方法，修饰符必须是两个固定的关键字：public、abstract

    2、这两个关键字修饰符，可以选择性地省略

    3、方法的三要素（返回值、方法名称、参数），可以随意定义

接口的抽象方法使用

接口使用步骤：

    1、接口不能直接使用，必须有一个“实现类”来“实现”该接口。

        格式：public class 类名 implements 接口名称{ ... }

    2、接口的实现必须覆盖重写（实现）接口中所有的抽象方法。

        实现：去掉abstract关键字，加上大括号方法体。

    3、创建实现类的对象，进行使用

接口 实现类

接口的默认方法定义

从Java8开始，接口里允许定义默认方法。

格式：public default 返回值类型 方法名称(参数列表);

备注：接口当中的默认方法，可以解决接口升级的问题

接口的默认方法使用

main方法 接口 实现类A 实现类B

接口的静态方法定义

从Java8开始，接口当中允许定义静态方法。

格式：public static 返回值类型 方法名称(参数列表) { 方法体 }

接口的静态方法使用

注意事项：不能通过接口实现类的对象来调用接口当中的静态方法

正确用法：通过接口名称，直接调用其中的静态方法

格式：接口名称.静态方法名(参数);

main方法 接口 实现类

由此可见：静态方法跟对象没关，实现类点不出来，跟类有关，直接用接口名点就行

接口的私有方法定义

接口

问题描述：

    我们需要抽取一个共有的方法，用来解决两个默认方法之间重复代码的问题

    但是这个共有方法不应该让实现类使用，应该是私有化的

解决方案：

    从Java9开始，接口当中允许定义私有方法。

    1、普通私有方法，解决多个默认方法之间重复代码的问题

    格式：private 返回值类型 方法名称(参数列表) {方法体}

    2、静态私有方法，解决多个静态方法之间重复代码的问题

    格式：private static 返回值类型 方法名称(参数列表) {方法体}

接口

没有jdk9，就不演示了

接口的常量定义和使用

接口当中也可以定义“成员变量”，但是必须使用public static final三个关键字进行修饰。从效果上看，这其实就是接口的【常量】。

格式：public static final 数据类型 常量名称 = 数据值;

备注：一旦使用final关键字进行修饰，说明不可改变。

注意事项：

    1、接口当中的常量，可以省略public static final，注意：不写也照样是这样。

    2、接口当中的常量，必须进行赋值；不能不赋值。

接口 main方法

接口的内容小结

再Java9+版本中，接口的内容可以有：

    1、成员变量其实就是常量

        格式：[public] [static] [final] 数据类型 常量名称 = 数据值;

        注意：

            常量必须进行赋值，而且一旦赋值不能改变。

            常量名称完全大写，用下划线进行分割。

    2、接口中最重要的就是抽象方法

        格式：[public] [abstract] 返回值类型 方法名称(参数列表);

        注意：实现类必须覆盖重写接口中所有抽象方法，除非实现类是抽象类。

    3、从Java8开始，接口中允许定义默认方法

        格式：[public] default 返回值类型 方法名称(参数列表) { 方法体 }

        注意事项：默认方法也可以被覆盖重写

    4、从Java8开始，接口里允许定义静态方法

        格式：[public] static 返回值类型 方法名称(参数列表) { 方法体 }

        注意：应该通过接口名称进行调用，不能通过实现类对象调用接口静态方法

    5、从Java9开始，接口里允许定义私有方法

        普通私有方法：private 返回值类型 方法名称(参数列表) { 方法体 }

        静态私有方法：private static 返回值类型 方法名称(参数列表) { 方法体 }

        注意：private的方法只有接口自己才能调用，不能被实现类或别人使用。

继承父类并实现多个接口

使用接口的时候，需要注意：

    1、接口是没有静态代码块的和构造方法的。

    2、一个类的直接父类是唯一的，但是一个类可以实现多个接口。

        格式：pubcli class 实现类名称 implements 接口A, 接口B { // 覆盖重写所有抽象方法 }

    3、如果实现类所实现的多个接口中，存在重复的抽象方法，那么只需要覆盖重写一次即可。

    4、如果实现类当中没有覆盖重写所有接口中的所有抽象方法，那么实现类就必须是一个抽象类。

    5、如果实现类所实现的所有接口当中，存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写

    6、一个类如果直接父类当中的方法和接口当中的默认方法产生了冲突，优先用父类当中的方法。

接口之间的多继承

类与类之间是单继承，直接父类只有一个

接口与类之间是多实现的，一个类可以实现多个接口

接口与接口之间是多继承

注意事项：

    1、多个父类接口当中的抽象方法如果重复，没关系

    2、多个父类接口当中的默认方法如果重复，那么子接口必修进行默认方法的覆盖重写，而且带着default关键字