this的本质是创建好的对象地址，就是存在堆里的那一个。
    this()可以用于调用该类中的其他构造器，且必须用于第一行。不懂
    this不能位于static方法里，因为static不是对象，是类。

    static声明的变量为静态成员变量（属性？），static修饰的都是类。
    没搞懂啊妈了个逼的草泥马

    继承就是扩展，子类是父类的扩展。
    继承是类于类之间的关系，除此以外，类于类之间的关系还有以来、组合、聚合等。
    子类继承了父类，就会拥有父类全部的方法（public、protect）。（public`protected\defult\private `共四个）
    在java中，所有的类都默认继承object类。
    一个子类只能有一个父类，一个父类可以有多个子类。

    superk可以调用父类的属性。如下三块代码：

    1. package com.codeday13;
    3. //Person 人：父类
    4. public class Person {
    6.     protected String name = "Dreamboo";
    8. }
    1. package com.codeday13;
    3. public class Teacher extends Person{
    5.     protected String name = "Fanrui";
    7.     public void test(String name){
    8.         System.out.println(name);
    9.         System.out.println(this.name);
    10.         System.out.println(super.name);
    11.     }
    12. }
    1. package com.codeday13;
    3. public class Application {
    4.     public static void main(String[] args) {
    5.         Teacher t = new Teacher();
    6.         t.test("樊睿");
    7.     }
    8. }

    image.png
    Teacher类中的super调用了父类的name，this调用了这个类的name,name调用了输入的局部变量name。

    同样方法也可以使用this和super，分别调用该类和父类的方法，但同样不能调用private的方法，私有的方法于属性不能被继承。

    子类的无参构造会默认调用父类的无参构造。如果显式调用父类的构造器（super()），必须在子类构造器的第一行。super和this不能在构造器中同时出现。
    构造器的作用就是构造对象，并且给对象和的属性赋值。

    重写：
    重写都是方法的重写，于属性无关。
    父类的引用可以指向子类：
    例如下面的代码：

    1. package com.codeday13;
    3. public class Application {
    4.     public static void main(String[] args) {
    6.         //方法的调用只和左边，定义的数据类型有关
    7.         A a  = new A();
    8.         a.test();
    10.         //父类的引用指向了子类
    11.         B b = new A();
    12.         b.test();
    13.     }
    14. }

    其中，B是父类，A是子类，b.test()调用的照样是父类的test()方法。

    非static方法可以Alt+Ins→Override，重写父类的方法，可以在子类中实现不同的功能.
    静态方法的调用只和new左边的数据类型有关，比如上方代码的B b = new A()，执行的依然是B中的test()，如果是非静态方法，那么就可以在指向的子类中重写test()方法。（大概是这样）
    重写不能重写private方法。

    重写需要注意：

    • 方法名必须相同；
    • 参数列表必须相同；
    • 修饰符：范围可以扩大但不能缩小；
    • 抛出的异常：范围可以被缩小但不能被扩大：ClassNotFoundException —>Exception（大）。

    为啥要重写？因为父类的功能，子类不一定需要，重写可以实现多态。
    不能重写的有：

    • static方法，属于类，不属于实例；
    • final常量；
    • private方法。

    如果对象是父类，那么无法调用子类的方法，采用括号可以强制转换成子类，如：
    ((Student) s2).eat()这里将s2这种父类强制转换成了子类，这样就可以调用子类的eat()方法。

    ended at No.72
    to be continued…