01-面向对象(继承-概述)

        接下来讲面向对象的另一个特征：继承。

学生类和工人类

        我们发现，学生和工人都有姓名和年龄属性。

        思考之后，将学生和工人的共性描述提取出来，单独进行描述，只要让学生和工人与单独描述的这个类有关系，就可以了。

继承关系

        引入一个新的关键词：extends（继承）。

        Person是基类，学生和工人是Person的子类。

        继承的作用：

        1，提高了代码的复用性。

        2，让类与类之间产生了关系。有了这个关系，才有了多态的特性。

        注意：

        千万不要为了获取其他类的功能，简化代码而继承。

        必须是类与类之间有所属关系才可以继承。所属关系：* is a *

        有个例子，哈哈哈哈，比如别人有个iphoneXS，你想玩，但不能为了玩它管别人叫爸爸，哈哈哈。这个时候就不需要继承。

    02-面向对象(继承-概述2)

        怎么判断是否有所属关系呢？

        如果父类中的内容，子类都有，则有所属关系。如果父类中有的内容子类没有，则没有所属关系。

        比如：

        在这个例子中，B继承A之后，B拿到demo1的同时，也拿到demo2，而它不需要demo2，所以它们没有所属关系。

        虽然A和B之间没有直接继承关系，但是它们之间有共性。

        将共性抽取出来，封装进类C中：

        A和B继承C即可。

        在Java语言中：java只支持单继承，不支持多继承。

        因为多继承容易带来隐患。

        假设，C继承了A和B：

        这时c.show()该打印a还是b？

        多继承带来的安全隐患：

        当多个父类中定义了相同功能，当功能内容不同时，子类对象不确定要运行哪一个。

        而C++支持多继承，所以Java语言在这一方面相对比C++做了优化。

        但是java保留了这种机制。并用另一种体现形式来完成表示，叫做多实现，也就是对多继承的一个改良，这个知识点后面会说。

        java支持多层继承。

        C继承B，B继承A这样。

多继承

        那么，如果创建c对象，能不能使用a中内容呢？

        可以。

        A，B，C就相当于爷爷、父亲、孙子的关系，父亲继承了爷爷的东西，孙子当然可以用爷爷的东西。

        java支持多层继承。也就是一个继承体系。

        如何使用一个继承体系中的功能呢？

        想要使用体系，先查阅体系父类的描述，因为父类中定义的是该体系中的共性功能。

        通过了解共性功能，就可以知道该体系的基本功能。

        那么这个体系已经可以基本使用了。

        那么在具体调用时，要创建最子类的对象，为什么呢？一是因为有可能父类不能创建对象，二是创建子类对象可以使用更多的功能，包括基本的也包括特有的。

        简单一句话：查阅父类功能，创建子类对象使用功能。

        实际开发的时候就按这个规律来找，否则一个一个查是查不完的。

    03-面向对象(聚集关系)   

       Java中类与类之间的关系不只继承这一种，还有其他关系。

        聚集关系（has a），分成两种，组合和聚合，它们俩的紧密联系程度会稍有不同。

        组合：手是人身体的一部分。

        聚合：球员是球队中的一部分。

        手是人身体不可或缺的一部分，人没有手是不行的，但球队离开某一个球员就没有这么严重的后果。

    04-面向对象(子父类中变量的特点)

         类中成员：

        1，变量。

        2，函数。

        3，构造函数。

        子父类出现后，类成员的特点：

        1.变量

        当父类与子类中出现同名变量时，打印的是子类：

       但是又想在子类中访问父类的num，为了区分这里引入一个新的关键词：super。

        如果子类中出现非私有的同名成员变量时，子类要访问本类中的变量，用this；子类要访问父类中的同名变量，用super。

        super的使用和this的使用几乎一致。

        this代表的是本类对象的引用，super代表的是父类对象的引用。

        一个例子：

        这种情况下，super.num和this.num打印出来的都是4。

        可以有两种理解方式：

        第一种，子类继承了父类，那么子类中相当于有自己的num，那么this就是用自己的，没有问题。

        第二种，super是引用没有错，this是引用没有错，这个时候this和super指向的都是同一个对象：new zi();

        而super代表的是父类引用，现在没有父类对象，只有子类对象，那么super和this指向的是同一个对象。

        其实挺不好理解的，this指向子类的对象可以理解，因为是本类的，super为什么也指向子类的对象呢？

        这个就是面向对象的第三个特征：多态，父类引用指向子类对象。

        比如过来一只猫，我们说，诶~这动物好可爱，这种说法也没错~

        再比如我想要一只动物，你给我一只猫，也没毛病~

        这个后面还会仔细讲。

    05-面向对象(子父类中函数的特点-覆盖)

        刚刚所说的子父类中出现同名变量的例子其实很少见，因为父类已经有这个变量了，子类可以直接获取这个变量，就没有自己再定义的必要了。

        接下来说另一部分，函数。

        2.函数

        当子类出现和父类一模一样的函数时，子类对象调用该函数，会运行子类函数的内容，如同父类的函数被覆盖一样。

        这种情况是函数的另一个特性：重写（覆盖）。

        父类函数其实还在内存当中，只是没有运行而已，不要真的以为它被覆盖掉了~

        一个例子，框出的两个函数功能是相同的：

        当子类沿袭了父类的功能到子类中，但是子类已经具备该功能，只是功能的内容和父类稍有区别。这时，没有必要定义新功能，而是使用覆盖特性，保留父类的功能定义，并重写功能内容。

        注意：修改源码绝对是灾难。

        因此，不用重新定义speak2函数，只需要重写父类speak函数即可：

        手机的例子，出了新款手机，加了新的功能，我们不需要在源码中修改，只需要继承、复写它里面的功能，就可以啦：

        复写还可以用于扩展。

        这个升级我们发现如上那种方式写也可以，但还会有点麻烦，比如来电号码，父类已经完成这个了，子类只需要在原有功能上加个姓名和照片就完事了。

        注意一定不要写成this.show()；，否则会变成递归，自己调用自己，陷入死循环。

        覆盖的注意事项：

        1，子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败。

        2，静态只能覆盖静态。（如果覆盖非静态，想想先加载后加载的问题，就知道不可以）

        我们之前用的权限修饰符有private，public，但是也有时候没有用修饰符，这个时候是什么权限呢？默认权限。默认权限介于私有和公有之间。

        像这种就不能叫覆盖，子类都不知道父类有这个方法。

       这样也不行哦，子类权限并不比父类权限大：

        记住：

        重载：只看同名函数的参数列表。

        重写：子父类方法要一模一样，包括返回值类型。（当然，在多态中，父子类的返回值类型是可以有不同的）

        比如，像下面这种情况，调show()谁运行呢？

        这样会报错的，因为虚拟机也不知道该运行哪个。

    06-面向对象(子父类中构造函数的特点-子类实例化过程)

        3.子父类中的构造函数。

         我们new一个Zi，运行结果是这样滴：

        这是为什么捏？

        这个原因是因为，子类的构造函数前面其实有一条隐式的语句，这句话你不写，系统会自动默默加在前面：

        在对子类对象进行初始化时，父类的构造函数也会运行，那是因为子类的构造函数默认第一行有一条隐式的语句 super()；

        super():会访问父类中空参数的构造函数。而且子类中所有的构造函数默认第一行都是super();

        再写一个带参数的构造函数试试：

        这个构造函数也会运行父类构造函数哦：

        即使我们再写一个父类的构造函数，也不会影响最后的结果，因为和新写的构造函数并没有关系，只和父类空参数的构造函数有关哦。

       试着改一下父类的空参数的构造函数，改成有参的，这个时候程序挂掉了：

        这个时候我们的解决方案是，在子类构造函数中手动指定父类的构造函数，像酱紫：

        程序就没有问题啦。

        那么， 为什么子类一定要访问父类中的构造函数？

        因为父类中的数据子类可以直接获取。所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的。

        所以子类在对象初始化时，要先访问一下父类中的构造函数。

        如果要访问父类中指定的构造函数，可以通过手动定义super语句的方式来指定。

        注意：

        super语句一定定义在子类构造函数的第一行。

        这里有个例子：

        第二个构造函数第一行是this()，调用了本类的空参数构造函数，这个时候就不调用父类的空参数构造函数super()啦。

        可是不是说子类在对象初始化时，要先访问一下父类中的构造函数吗？

        没关系，第二个构造函数不是调用了本类的空参数的构造函数嘛，本类的空参数的构造函数的第一行就是super()呀，逃不过哒。

        结论：

        子类的所有的构造函数，默认都会访问父类中空参数的构造函数。

        因为子类每一个构造函数内的第一行都有一句隐式super()；

        当父类中没有空参数的构造函数时，子类必须手动通过super()；语句形式来指定要访问的父类中的构造函数。

        当然，子类的构造函数第一行也可以手动指定this();语句来访问本类中的构造函数。子类中至少会有一个构造函数会访问父类中的构造函数。

        其实，这个过程就叫做子类的实例化过程。

        那父类中有木有super()；语句呢？

        有的。

        它找的是谁呢？

        它找的是父类的父类。

        而Java当中有一个类特别牛，叫做所有类的父类。就是Object。

        还有个问题，为什么this();和super();不能在同一行？

        因为它们都只能写第一行。

        为什么必须要写第一行？

        因为初始化动作要先做。

    07-面向对象(final关键字)

        final关键字：       

        final关键字是什么意思呢？

        最终。

        final关键字有什么特点呢？

        1，final可以修饰类，方法，变量。

        2，final修饰的类不可以被继承。

        继承的出现很有好处呀，复用性提高了，而且也有多态了。

        但是继承有一个弊端，就是它打破了封装性。

        什么意思呢？

        本来写一个类写的好好的，定义了一些功能，子类不好好用这些功能，还要把它复写，输出一个哈哈！哼！好过分！

        所以集成有利有弊，它的出现对封装性是一个挑战，里面一些东西反倒不是隐藏了，还能复写。

        比如说，搞了一个类，里面有几个功能，有些功能调用的直接是虚拟机底层的内容。换句话说，调用了系统内容了。而你把它一复写，把功能改掉了，这个功能还能遇到底层吗？

        为了进一步保证封装性，还能有继承的特性，叫做：有些类我不让你继承，这里面的功能你不允许复写，它是固定的，要么用要么不用。

        所以，为了避免被继承，被子类复写，定义类的时候加上修饰符final，这个类就叫最终类，不能被子类所继承。

        如下例，再继承就会出错：

        3，final修饰的方法不可以被覆盖。

        比如现在有个类，里面有十个功能，里面4个是调用系统功能不能被复写，另外6个是可以被复写的，这个时候就不能把这个类都定义为final，否则都不能复写了。

        这个时候，只对不允许被复写的方法修饰final就好了。

        如下例，覆盖了final修饰的方法会报错：

        4，final修饰的变量是一个常量，只能被赋值一次。既可以修饰成员变量，又可以修饰局部变量。

         加了final修饰符后，x就终身为3，y就终身为4了：

        把y重新赋值会怎样呢？

        程序会挂掉的：   

        当在描述事物时，一些数据的出现值是固定的，那么这时为了增强阅读性，都给这些值起个名字，方便于阅读。

        而这个值不需要改变，所以加上final修饰。作为常量：常量的书写规范是所有字母都大写，如果由多个单词组成，单词通过_连接。

        比如圆周率π：

        像这样的数据以后还会碰到很多，都是把一些特定的数据用一些名称来标识。

        注意：

        以后写程序的过程中，但凡出现了一些固定数据，即使只出现一次，也建议把这个数据起个名字，人们阅读这个名字，绝对要比阅读数字来得快来得方便。当然前提是这个数据不能变。

        其实final的作用已经体现出来了，就相当于一个锁变量罐，对于一个变量，把final一加，这个变量空间就锁住了，值就固定在里面了，再往里面进值就进不去了。

        而成员变量在不变化的情况下，往往还会跟上一个修饰符：static。如果再加上public，就变成全局常量了，类名就可以直接访问。 

        5，内部类定义在类中的局部位置上时，只能访问该局部被final修饰的局部变量。

    08-面向对象(抽象类)

        当多个类中出现相同功能，但是功能主体不同，这时可以进行向上抽取。

        这时，只抽取功能定义，而不抽取功能主体。

        引入修饰符：abstract（抽象），被它修饰的方法意思就是看不懂的方法。

        抽象方法必须定义在抽象类中。

        这样有个好处，别人都知道它是抽象类，就不会创建它的对象。否则创建了它的对象，调用其中的抽象方法，并没有意义。

        例：

        抽象类的特点：

        1，抽象方法一定在抽象类中。

        2，抽象方法和抽象类都必须被abstract关键字修饰。

        3，抽象类不可以用new创建对象，因为调用抽象方法没意义。    

        我们试着new一下，会报错：

        （就算我们把类和方法前面的abstract修饰符撤掉，再建立该类的对象并调用那个空方法，而且运行也不会报错，可是它又有什么意义呢？并没有。）

        4，抽象类中的方法要被使用，必须由子类复写其所有的抽象方法后，建立子类对象调用。

            如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。

    09-面向对象(抽象类2)

        抽象方法有一个好处，就是必须被复写，强迫子类去完成复写这件事情。

        如果没有抽象，那子类可以偷懒直接拿去用。但抽象了，子类就必须复写，完成自己的特定功能。也算是功能分工的明确。

        抽象类中可以有非抽象方法。

        抽象类和一般类没有太大的不同。

        该如何描述事物，就如何描述事物，只不过，该事物出现了一些看不懂的东西。

        这些不确定的部分，也是该事物的功能，需要明确出现，但是无法定义主体。这些通过抽象方法来表示。凡是功能不确定的，就沿袭到子类去做，但是它也属于父类的一部分。

        抽象类和一般类的一丢丢小小不同：

        1，抽象类比一般类多了抽象函数。就是在类中可以定义抽象方法。

        抽象类中可以不定义抽象方法吗？

        这是可以的。

        那它岂不是没用嘛？

        有用的。

        有一个特殊作用，但不多见：抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。

        2，抽象类不可以实例化。

        PS：abstract可以修饰类、方法，但不可以修饰变量哦，没有抽象变量这一说。

    10-面向对象(抽象类练习)

        接下来做一个练习：

        分析：

        定义员工类：

        工作内容是这个方法是抽象的，因为每个人干的活都不一样。

        经理类继承员工类：

        经理干经理的活，复写工作内容的抽象方法。

        再来一个普通员工，普通员工也复写工作内容这个抽象方法，普通员工干普通员工的活：

    11-面向对象(模版方法模式)

        一个例子：

        需求：获取一段程序运行的时间。

        原理：获取程序开始和结束的时间并相减即可。    

        获取时间用到的方法：System.currentTimeMillis();

        定义一个类，在其中写一个获取时间方法，建立对象并运行获取时间方法：

        
        成功获取到时间啦。

        接下来有一个小问题，如果想把中间那段代码换成其他代码该怎么办呢？

        一次一次在代码中间手动改很麻烦。

        可不可以把这部分可以修改的代码单独封装一下呢？

        这样可以吗：

        想用到这个方法的时候，只需继承这个类，复写runcode()方法就好啦。

        虽然调用的依然是父类的getTime()方法，但由于子类已经将runcode()覆盖掉了，所以父类的getTime()方法运行的是子类的runcode()方法。

        这样就很方便程序扩展。

        那么再思考一下，我们定义了一个获取时间的功能，功能中获取的是哪段代码的时间，这段代码不明确，不确定则必然是抽象的。

        此时这个类也变成了抽象类：

        因为我们这个类就是提供了获取时间的功能，getTime()方法提供的功能就是获取时间，所以不允许复写，用final修饰： 

        到目前为止，这个类就是能够获得某段代码运行时间的一个类了：

       当代码完成优化后，就可以解决这类问题。

        这种方式，我们取名为模板方法设计模式。

        什么是模板方法呢？

        在定义功能时，功能的一部分是确定的，但是有一部分是不确定的，而确定的部分在使用不确定的部分，那么这时就将不确定的部分暴露出去，由该类的子类去完成。

        啥叫模板呢？

        就跟做月饼那个模子一样，做出来的形状是确定的，但是馅儿是不确定的，我们可以豆沙、放蛋黄、放芝士~流口水ing~~~

        但是注意一点，不确定的那段代码不一定是抽象的哦，有可能这个方法里面有默认的内容，你不爽你可以复写~确定的那段代码也不一定是固定的要用final修饰，这里我们不愿意让它被复写所以用final修饰了，如果不是很介意的话也可以不用final修饰。

    12-面向对象(接口)

        我们发现，抽象类中可以定义抽象方法，也可以定义非抽象方法，那么如果抽象类中的方法全都是抽象的，这个时候我们可以把它转换成另外一种体现形式，叫做接口。

        当然接口产生的原因并不是上段所说的，哈哈，只是正好说到这里很形象的带到这里了。

        接口：初期理解，可以认为是一个特殊的抽象类。

                当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。

        class用于定义类。

        interface用于定义接口。

        接口定义时，格式特点：

        1，接口中常见定义：常量，抽象方法。

        2，接口中的成员都有固定修饰符。

                常量：public static final

                方法：public abstract

         记住：接口中的成员都是public的。

         比如：

        当然，在写的过程中我们也可以将常量和方法前面的固定修饰符省略掉，也不影响，因为只要前面使用interface修饰的，里面的成员都是默认有固定修饰符的。

        但是这样省略写法的话阅读性就会很差，我们就不知道它是公有的，也不知道它是可以被名称访问的。所以写的时候还是写全最好。

        而且直接写void show();会引起误解。

        比如正常写void() show();编译的时候会出现错误提示： 

        这个时候要么补一个方法主体，要么声明抽象。

        接口能创建对象吗？

        肯定不能。

        这个时候就搞一个类去实现它。

        类与类之间是继承关系，而类与接口之间就变成了实现关系：implements。

        类为什么不是实现类呢？这个不一定哦。不过叫继承是因为类里面一般会有一些非抽象方法可以直接拿来用，这个子类不用太清楚。而接口里面全都是抽象方法，子类拿过来全部要复写。所以这个时候就需要更确切的表达方式，子类要将接口中的方法全都实现后才能实例。否则，子类就是一个抽象类。

        还用刚才那个例子：

        其中NUM的调用方式有三种：

        分别是：对象调用、类名调用、接口调用。

    13-面向对象(接口2)

        Java不支持多继承，但它有另一个方式：多实现。

        接口可以被类多实现。

        比如这就是多实现：

        不支持多继承的原因是担心方法会有重复，担心子类调用的问题。

        那么为什么接口就没这个问题呢？

        其实关键就是一点：多继承里的方法有方法体，多实现里的方法没有方法体，你爱怎么弄怎么弄~

        假如真的有两个接口的方法都叫show()：

        接口中的show()方法都没有主体，可以由子类来任意定义。

        搞定~

        一个类在继承一个类的同时，还可以实现多个接口。

        先继承，再实现，可以扩展这个类的功能。

        接口与接口之间其实也有关系：继承。

        例：

        还有更厉害的呢。接口之间可以多继承，像酱紫：

        注意：别这么写哦，这么设计是有问题的：

        编译器会报错的。

    14-面向对象(接口的特点)

        定义接口可以有什么好处捏？

        举个例子。

        以前想换CPU了直接换一个主板，但是我们在主板上弄一个槽来插CPU，下次想换CPU直接把CPU拔出来，换一个新的就好了。CPU更新换代快，这样做可以在更新CPU的前提下提高主板的复用性、功能的扩展性。

        这个槽就相当于接口。

        接口的特点：

        1，接口是对外暴露的规则。

        2，接口是程序的功能扩展。

        3，接口可以用来多实现。

        卡槽的出现降低了CPU和主板的耦合性，接口的出现也降低了这两个设备的耦合性。

        Intel的CPU既可以插在华硕的板子上，也可以插在别的板子上。只要它们定义的是同一个插槽就都能用。

        什么开发最难受？

        就是依赖性太强。你没做，我也不能做。你做不出来，我也动不了。

        降低了耦合性，你做你的，我做我的，就很好了，模块化的开发。

        再举个例子。

        笔记本的USB接口。想要升级硬盘，这个时候只要能对得上这个口，不用拆电脑也可以实现升级。买个移动硬盘咔一插，就扩展了。

        4，类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口。

        5，接口与接口之间可以有继承关系。

    15-面向对象(接口举例体现)

        接下来通过一个实例来说明接口这个事情。

        这个实例可能稍微有点不恰当，但能说清楚问题。

        定义了一个学生类，其中有学习和睡觉的行为。

        张三继承了学生类，具有所有学生具有的行为。张三还是一个烟民，有抽烟的行为。这时定义了一个抽烟的接口，张三继承学生类的同时实现了抽烟接口。

        而李四不抽烟，所以他继承学生类就好了，不用实现抽烟的接口。

        因此，接口可以用于类功能的扩展。

        再来一个运动员的例子。

        运动员都有运动的行为，有的运动员还学Java。基本功能定义在（父）类中，扩展功能定义在接口中。

        大概酱紫：