Day08 --代码块 继承 重写 this和super final关键字

 a.
    代码块
        在java中，用{}扩起来的叫做代码块。
    
    分类
        根据位置和声明的不同，可分为局部（方法中的），构造，静态，同步代码块（多线程再讲）
    
    代码块的应用
        局部代码块 [方法中]
            * 在方法中出现的。随着实例化对象的创建而存在，用来限制变量生命周期，及早释放，可提高代码利用率。
                * 跟for循环类似，int i的访问范围一样。
    
        构造代码块 [类中方法外]（又叫初始化块）
            * 在类中方法外出现。每创建一次对象，都要执行一次构造代码块，并且优先于构造方法前先被执行。
                * 且多个构造方法中相同的代码放在一起，每次调用都有执行，每次创造对象后，先执行构造代码块，再构造方法，再普通方法。
                
        静态代码块 [优先于主方法前先被执行]
            * 在类中方法外出现，加上static来做修饰，用于给类进行初始化的，在类加载的时候执行，有且只执行一次。
                * 作用：
                    * 给类做初始化用的，一般用于加载驱动(驱动也加载一次)。
                
                * 因为被static修饰的，所以静态代码块是随着类的加载而加载的，当在类加载时，static静态代码块就会被执行，因为类只加载一次，所以static一只加载一次。
                * 无论创建多少个对象，static静态代码块都执行一次。
                * 一般用于加载驱动的。

作业题一：
1、代码块是什么，分为哪几类，各自有什么特点？
含义:
    * 在java中用{}扩起来的就称为代码块。
代码块分类：
    * 静态代码块
    * 局部代码块
    * 构造代码块
    * 同步代码块
各自特点:
    * 静态代码块，在类中方法外，用 static 来做修饰，用于给类进行初始化用的，是随着.class 字节码文件的加载而加载的，优先于主方法先存在，随着类的消失而消失，一般用于加载驱动，且只能执行一次。
    * 局部代码块，在方法中出现，用于限定变量的生命周期，可用于提高内存的利用率。
    * 构造代码块，在类中方法外，多个构造方法相同的代码存放在一起，每次再调用构造方法前执行。
    * 同步代码块，多线程再讲。




        注意事项：
            局部/构造/静态/代码块的执行顺序：
            静态 > 局部 > 构造


例子：
    参考：G:\CSDN_Android_\Code\day08 代码块 继承 重写 this和super final关键字\Demo1_代码块_局部代码块.java 



    静态代码块,构造代码块,构造方法的执行流程?
            静态代码块
                * 当jvm加载.class字节码文件时，给类进行初始化的，且只执行一次。
            构造代码块
                * 在构造方法之前被执行。
            构造方法
                * 随着实例化对象的创建而执行，且每次创建对象，都执行一次构造方法，随着对象的释放而消失。 


作业题二：
2、子父类都有静态代码块、构造代码块、构造方法，那么他们六者之间的执行流程是什么？
分析：    
    1) 因为子继承父，所以先执行父类的字节码文件，因为静态代码块是随着类的加载而加载的，所以第一步先执行：父类的静态代码块。
    2）父类的静态代码块执行完成后，子类的字节码文件也同样加载到内存，所以第二步是：子类的静态代码块。
    3）因为new的是子类的对象，又因为构造代码块是在构造方法之前执行的，且二者存在继承关系，所以第三步执行的是：父类的构造代码块。
    4）执行完第三步：父类构造代码块后，紧接着执行第四步：父类的构造方法。
    5）当父类的构造方法执行完后，开始执行子类的构造方法，因为构造代码块是在构造方法前执行的，所以第五步执行：子类的构造代码块。
    6）当子类的构造代码块执行完后，开始执行子类的构造方法。
所以顺序是：
    1）父类静态代码块
    2）子类静态代码块
    3）父类构造代码块
    4）父类构造方法
    5）子类构造代码块
    6）子类构造方法


    代码块面试题
        分析程序中的代码的执行顺序？

例子：
    根据 静态 > 局部 > 构造这个顺序来分析：
    参考：G:\CSDN_Android_\Code\day08 代码块 继承 重写 this和super final关键字\Demo2_Student_构造代码块面试题.java




b.    
    继承
        概念
            * extends 表示关键字，用于让类与类之间产生关系，只存在于子父类当中。（子继承父，不可父继承子）
            * 他们是一种满足 is a的一种关系，如猫是动物的一种。
            * java中只支持单继承，不支持多继承，但支持多实现和多层继承。
                * 多层继承：子 继承 父， 父 继承 爷 ，子 继承 爷（子继承爷就是多层继承）


        好处
            * 提高代码复用性    （父类有了，子类就不需要再写了，继承即可）
            * 提高代码维护性    （新添加属性，只要在父类中添加了，其他子类也就都有了）
            * 让类与类之间产生关系，这是多态的前提    （多态：即多种形态） 因为要：父类有用指向子类对象。        
        弊端
            * 增强了代码的耦合性，因为优秀的代码都是围绕着 “高内聚，低耦合”的原则去开发的。
           （耦合性：两个类过分紧密，父类有什么，子类就必须有什么。）



    开发原则
        * 高内聚，低耦合（使用装饰者模式，就能降低耦合性）
        
        * 内聚：自己完成某件事情的能力，耦合性低，之间能完成是事情不求他人。【公司离开你，还能活】
        * 耦合：类与类之间的关系。【你离开公司，就不能活】
        
        高内聚：自己能完成的事情，自己做。
        低耦合：合作式开发，但是要主次分明。
    
    p.s.
        子类只能访问父类中非私有的成员（属性和方法）。    
        子类无法继承父类中私有的内容。
        父类怎么来的？ 共性内容不断向上抽象来的。
    
    p.s.贝贝2017/8/19 1:07:35 


作业题三：    
3、继承的好处、弊端分别是什么？
好处：
    * 提高代码复用性。
    * 提高代码维护性。
    * 让类与类之间产生关系，是多态的前提。
弊端：
    增强了代码之间的耦合性，优秀的代码开发一直遵循的是一种 “高内聚，低耦合” 的一种开发规则。
        高内聚：自己完成的事情，一般不求他人（在开发的意思是，本类能完成的功能尽量在本类完成，即本类完成功能的能力度。）
        低耦合：合作式开发，但是要分清主次关系（一般开发规则有：分模块开发 和 分功能开发。）


​    
装饰者模式
    好处：降低耦合性，被装饰的类与装饰的类无关。
    代码实现：
        1. 获取被装饰类的引用
        2. 在装饰类的构造方法中传入被装饰类的对象
        3. 对原有功能进行升级

例        
        class Demo2_装饰者模式 {
            public static void main(String[] args) {
                    
                    HmStudent hm = new HmStudent(new Student());
                    hm.name="哈哈";
                    hm.age=22;
                    hm.study();
                    System.out.println(hm.name+"..."+hm.age);
                }
            }


            //黑马学生 继承 学生类  且 实现 方法Coder类的接口。 
            //在实现接口类中，完成具体的方法实现。
            class HmStudent  extends Student implements Coder{
                //1. 获取被装饰类的引用
                private Student s;
            
                //2、在装饰类的构造方法中传入被装饰类的对象
                public HmStudent(Student s){
                    this.s = s;
                }
                
                public void code(){
                    //3. 对原有功能进行升级        
                }
                
                //在实现接口类中，完成具体的方法实现
                public void study(){
                    System.out.println("程序员敲代码.");
                }
                
            }
                
            //接口        接口中定义的都是方法，且都是没有方法体的方法。
            interface Coder{
                public void study();
            }
            
            class Student {
                String name;
                int age;
            }


    继承特点    
        * java中只支持单继承，不支持多继承，但支持多实现（即实现接口）。
            * 但有些语言可支持多继承，如： a类 extends c类,d类,e类...
        原因？
            * 因为多继承容易出问题，如果两个父类中有相同的方法，子类就不知道该具体调用哪一个方法了。
            * 这种机制就换来了另一种安全的方式来体现，即多态。            
    
        * java中存在多层继承的关系（即继承体系）
            * 子 extends 父 
            * 父 extends 爷
            * 子 extends 爷
            
        * 由继承的特点可看出：
            * 如果想用这个体系的【所有功能】， 看【最底层（儿子类）的类去创建对象】【即子类是用于扩展的功能】
            * 如果想用这个体系的【共性功能】， 看【最顶层（爷爷类）的类，即最先继承的类】
    
    Java中继承的特点
        * java中只支持单继承，不支持多继承，但支持多实现和多层继承。
        * 当创建对象时：
            如果是想要其共性部分，就去找顶层（即父类）
            如果想要知道功能性最全的，就去找底层（即子类）
    
    p.s.
        子类中所有的构造函数默认都会访问父类中的空参构造函数，因为每一个构造函数的第一行都有一个默认的super语句，去访问父类的空参构造，即使一个普通类第一行也有一个super语句，因为他会去访问Object类。
        
        为什么子类实例化的时候要去访问父类中的构造函数？
        因为子类继承父类，获取到父类中的内容，所以在使用父类内容之前，要先看看父类是如何自己的内容进行初始化的。
    
        1. 当父类中没有空参构造时，子类的构造函数必须通过this或super语句指定要访问的构造函数。
        2. 子类构造函数中如果使用this调用本类的构造函数，那么默认的super就没有了，因为super和this不同同时定义在的第一行，所以只能存在一个，但是可以保证的是，子类中肯定有其他的构造繁琐去访问父类的构造函数
        3. super必须存在子类的构造函数的第一行，因为父类的初始化动作要先完成。


​        


作业题四：    
4、Java中继承的特点是什么？
特点：
    * Java只支持单继承，不支持多继承，但支持多实现和多层继承。
        多实现：一个类可以实现多个接口。接口：后面说。
        多层继承：子继承父，父继承爷，子继承爷，存在这种关系后，子继承爷就是多层继承了。
当创建对象时，
    如果想要其共性部分功能，就找顶层（父类，即创建父类对象）。
    如果想要其全部功能，就找底层（子类，即创建子类对象）。


例子
class Demo3_Extends继承的特点 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in); //in表示键盘录入的意思。
    
        DemoC c = new DemoC();
        c.show(); //结果是：DemoB 
    }
}

//最顶层的类 即爷爷类 有最完善的【共性功能】
//爷爷类
class DemoA {
    public void show(){
        System.out.println("DemoA ");
    }
}

//父亲类
class DemoB extends DemoA {
    public void show(){
        System.out.println("DemoB ");
    }
}


//最底层的类  即儿子类 有最完善的【全部功能】
//儿子类
class DemoC extends DemoB {
​    
}
//不能让C类即去继承A类，也继承B类，这不符合Java对于继承的规定，
//只能【多层继承】，即通过 B extends A, 再让C extends B 来完成对A类和B类所有功能的继承。

//不能多继承的原因？有安全隐患，如果让C类同时继承A，B类，当创建C类对象时，就不知道该具体调用AB中哪个同样的show方法了。
//当C类去 extends B类（B 已经extends A了）时，创建C类对象后，c调用show()方法， 输出的结果是 ：DemoB，因为 B extends A时，b中有同样有show方法，就将A中的show方法给覆盖了，所以打印c.show()，结果自然是DemoB。

    继承的注意事项和什么时候去使用继承
        注意事项：
            * 子类只能继承父类所有（非）私有的成员[即成员方法和成员变量]，因为私有成员只能在本类使用。 【但想继承也可以，通过暴力反射完成 最后一天课程说】            
            * 子类不能去继承父类中构造方法，但是可以通过super来访问父类的构造方法。
                * 子类不能继承父类的构造方法？因为两个类的类名不同，且构造方法是在创建对象的时候使用的，如果继承了，系统在创建对象后，就不知道具体该调用哪个构造方法了。
    
            * 不能为了部分功能去继承。
                *   * 项目经理 姓名 工号 工资 奖金
                    * 程序员    姓名 工号 工资    
                    * 【只能向上抽取出来一个员工类，放共性功能，让项目经理类和程序员类都去继承该员工类即可】
                     
        什么时候使用继承：
            不能为了单独继承而继承，他们之间是一种 is a的关系，只有满足了这种情况才考虑去使用继承。
    
        即：
            动物
                猫
                狗
                    (猫是动物的一种  狗是动物的一种) 即 is a 的关系。
            水果
                苹果
                香蕉
                桃子
                    (苹果是水果的一种  香蕉是水果的一种)即 is a 的关系。
    
    采用假设法：
            如果有两个类A,B 只有满足A是B的一种，或B是A的一种的时候，才考虑使用继承。



    继承中局部变量的关系
        情况一：
            * 不同名的变量
                * 在子父类中出现不同名变量，结果都输出。
                 
        情况二：
            * 同名变量
                * 在子父类中出现了同名变量，就采用就近原则，即子类当中有，就使用子类的。
【子父类中出现同名变量，只在讲课中有，开发中是不会出现的。因为子类继承父类，就是为了让子类去使用父
类中的成员，如果子类中都有了父类中同名的成员变量，就没有任何意义了。】




作业题五：
5、Java中继承的注意事项是什么？我们什么时候使用继承? 继承中局部变量的关系?
注意事项：
    * 子类只能继承父类非私有的成员，如果子类或其他想要访问私有成员，必须使用get()方法进行访问。

什么时候使用继承：
    * 不能为了部分功能去实现继承，只有他们满足一种 “is a” 的关系（苹果是水果的一种）时，才考虑使用继承，一般两个类或以上的类都满足 “is a” 的关系时，就向上抽取出父类，即公共类。
    注意；子类不能继承父类的构造方法，只能通过super关键字去调用父类的构造方法，不然jvm无法识别使用是子类的构造方法还是父类的构造方法。
        如：
            子类：
                名字：苹果，颜色：红，功能（方法）：补充营养。
                名字：香蕉，颜色：黄，功能（方法）：利肠道。
        因为存在多个重名属性，即向上抽取父类：
            父类：
                * 相同属性：名字 和 颜色。
                * 方法：功能（食用保持身体健康）。
    
        且在子类中重写方法，完成其特有的功能即：
                                    * 子类苹果：补充营养。
                                    * 子类香蕉：利肠道。

继承中局部变量的关系:
    同名变量名称：
            采用就近原则，谁离子类进，就使用哪个，即就近原则。
    异同变量名称：
            如果是异同变量名称，结果都输出。

c.
    this和super的区别和使用
        this
            * 代表当前对象的引用，即谁来使用我，我就代表谁。
        super
            * 代表当前对象父类的引用，即子类继承父类后，想要去使用父类的成员时，可
            * 使用super。
        p.s.
        子父类中，成员的特点体现：
            1）成员变量：
                * 在本类中成员变量和局部变量可以用this来区分， this表示成员变量。因为局部变量一般在方法里或方法声明上。
                * 当子父类中出现同名成员变量时，可以用super来区分父类。
                
            2）成员方法：
                * 当子父类中出现成员方法一模一样的情况的时候，会运行子类中的方
                  法，这种现象被称为：覆盖操作（重写）。这是方法在子父类中的特性。
                * 在子类覆盖（重写）父类方法后，还想继续使用被覆盖的父类方法时，可以通过super.方法名()来获取。
            
            方法的两个特性：
                1） 重载，只出现在本类中，即overload。
                2)  重写，出现在子父类当中，即override。 有道词典翻译： vt. 推翻；不顾；践踏

​            



        this和super的使用区别 (3种区别)
            * 调用成员变量
                    * this.成员变量   即可调用本类的成员变量，也可调用父类的成员变量。
                            * 前提是本类当中没有，才能去使用父类的，因为他们存在继承关系。
                            
                    * super.成员变量  只能调用父类中的成员变量。
            * 调用构造方法
                    * this(语句)  只能调用本类的构造方法
                    * super(语句) 只能调用父类的构造方法
    
            * 调用成员方法
                    * this.成员方法()  即可调用本类的成员方法，也可调用父类的成员方法
                    * super.成员方法() 只能调用父类的成员方法


    继承中构造方法的关系（继承中构造方法的执行流程）
        * 子类中所有的构造方法默认都会去访问父类中的空参构造。【前提：必须是继承关系】
        * 为什么？
            * 因为子类继承父类中的数据，还可能会去使用到父类中的数据，所以子类在完成初始化之前，一定会
              去完成对父类数据的初始化。    
    
        其实
            每个构造方法的第一句默认都是调用：super()。 Object类是最顶层的父类，所有的类都继承他，自定义的类也一样继承他。


            子类中的构造方法都有一个默认的super()，去访问父类的空参构造。
        原因？
            因为子类继承父类的属性，很可能会去访问父类中属性的数据，所以要必须先对这些属性进行初始化，才能去访问父类的构造方法。


    继承中构造方法的注意事项
        父类没有无参构造，子类该怎么办？
            * super解决  可在在子类中，调用父类中的无参构造。（也能调用父类的有参构造）
            * this解决   可在在子类中，调用本类的有参构造。 
            
        【注意】
            super()或this必须出现在构造方法的第一条语句上，不能同时出现。
            但是在普通方法中this.父类方法()和 super.父类方法() 可以不用放在第一行。
            具体可参考：G:\CSDN_Android_\Code\day08 代码块 继承 重写 this和super final关键字\day08_最新作业代码\Work3_存在继承关系的猫咪_狗狗类.java 中的Dog lookHome()方法里的写法。

作业题六
6、this关键字和super关键字分别代表什么，以及他们各自的作用分别是什么？
分别代表：
    this  代表当前对象的引用，谁使用我，我就代表谁，即哪个对象使用this，this就代表哪个对象。
    super 代表当前对象父类的引用，用于在子类中去访问父类的成员及构造。

this 和 super 的区别：（3种）
    * 调用成员变量
            this  既能调用父类的成员变量，也能调用子类的成员变量。
            super 只能调用父类的成员变量。
    * 调用成员方法
            this.成员方法   既能调用父类成员方法，也能调用子类成员方法。
            super.成员方法  只能调用父类的成员方法
    * 调用构造方法
            this  只能调用子类的构造方法
            super 只能调用父类的构造方法

作业题八                
(没有7)8、继承中构造方法的执行流程是什么？
    执行顺序：
        先执行父类中的构造方法，再执行子类中的构造方法。
作业题九
9、为什么子类中所有的构造方法默认都会访问父类的空参构造？
   假如父类没有无参构造方法，子类应该怎么办?
    答：
        问题一：因为在子类对象在访问父类数据前，用于对父类数据进行初始化的。
        问题二：如果父类中没有无参构造，可在子类中使用super();来访问父类的有参构造，或使用this();来调用本类的其他构造。

作业题十
10、super关键字和this关键字可以在构造方法中共存吗？
        额可以，只能放在第一行，如果是其他普遍方法，super或this可以不用放在第一行。
        子类{
            super(); //调用的是父类的构造。
            this.setName(name); //因为存在继承关系，所以也就相当于调用子类的set方法
        }



继承中的面试题
​        
看程序写结果1
        class Fu{
            public int num = 10;
            public Fu(){
                System.out.println("fu");
            }
        }
        class Zi extends Fu{
            public int num = 20;
            public Zi(){
                super();    //有个隐藏的super()；每个构造方法中都有一个默认的super，去调用父类的完成构造方法
                System.out.println("zi"); // num=20;
    
            }
            public void show(){
                int num = 30;
                System.out.println(num);  //采用就近原则    即30    
                System.out.println(this.num); //this是用于区分重名的成员变量和局部变量，这里的this表示成员变量，即20     
                System.out.println(super.num);  //super调用是的父类的成员变量，即10
            }
        }
        class Test1_Extends {
            public static void main(String[] args) {
                Zi z = new Zi();
                z.show();
            }
        }
    
        执行顺序：
            fu  1）首先Zi(),会去调用zi的无参构造，因为zi的无参构造中有super()，所以先去调用父类的无参构造，即fu。
            zi  2）输出fu后，zi()中的无参构造里还有一个语句，即：zi。
            30  3）接着调用z的show()方法， 第一个输出语句num,即采用就近原则，所以num=30。
            20  4）this.num 是访问重名的成员变量和局部变量时，用来访问成员变量用的，即：this.num=20。
            10  5）super.num 中的super是访问父类的，所以super.num = 10;


​            

看程序写结果2
    class Fu {
        static {
            System.out.println("静态代码块Fu");
        }
    
        {
            System.out.println("构造代码块Fu");
        }
    
        public Fu() {
            System.out.println("构造方法Fu");
        }
    }
    
    class Zi extends Fu {
        static {
            System.out.println("静态代码块Zi");
        }
    
        {
            System.out.println("构造代码块Zi");
        }
    
        public Zi() {
            System.out.println("构造方法Zi");
        }
    }
    
    Zi z = new Zi(); 
    
    结果：    静态代码块Fu           1）因为创建的是zi()的无参对象，又因为zi继承fu，所以fu类先加载到内存，即 先输出：静态代码块Fu。
            静态代码块Zi        2）又因为创建时zi类的对象，所以zi类也要加载到内存，即输出：静态代码块Zi    
            构造代码块Fu        3）访问zi的无参构造对象时，必须要先访问父类的无参构造，又因为无参构造是在构造代码块后面出现的，所以先输出：构造代码块Fu
            构造方法Fu        4）随着构造代码块的输出后，再输出无参构造。
            构造代码块Zi        5）只有先访问完父类的无参构造时，再能访问子类的无参构造，因为构造代码块时先于构造方法前先执行的，所以先输出：构造代码块Zi
            构造方法Zi        6）构造代码块输出后，才能输出构造方法，所以是：构造方法Zi

老师说法：
        1） jvm调用main方法， 方法都进栈，所以main方法进栈。
        2） 首先遇到Zi z = new Zi()，因为zi类继承父类，所以会先将fu.class和zi.class分别加载到内存，当fu.class加载进内存时，静态代码块也会随着fu.class一起加载， 当zi.class加载进内存时，静态代码块也会随着zi.class一起加载。所以第一个输出：静态代码块Fu  第二个输出：静态代码块Zi
        3） 加载完后，走zi类的构造方法，因为java是分层初始化的（在子类的构造方法中，每个子类中都有一个super），所以先去走父类的构造方法， 但是在执行父类构造时，发现父类有构造代码块，构造代码块是优先于构造方法前先执行的，所以第三个输出的是：构造代码块Fu 第四个输出的是：构造方法Fu。
        4） fu类初始化后，就该子类初始化，所以第五个输出是：构造代码块Zi    第六个输出的是：构造方法Zi


    原则： 
        * 静态代码块是，随着类的加载而加载的。
        * 构造代码块先于构造方法前先被执行。
        
    顺序：
        静态代码块 > 构造代码块 > 构造方法


​    


    继承中成员方法的关系
        --出现的情况：            
            * 不同名方法时：
                * 都能够调用，即可调用父类中的方法， 也能调用子类中的方法
            * 同名方法时：
                * 如果子类定义了父类中重名的方法， 就使用子类中的方法，这种叫【方法的重写或覆盖】
                * 如果还想使用父类中重名的方法的话，可以在子类中重名方法里的
                  第一行使用：super.父类重名成员方法()； 即可完成对父类重名方法的调用。






d.
    方法的重写
        概述
            在子父类中出现了一模一样的方法（返回值类型可以是子父类，面向对象再说）【方法名，返回值相同，参数列表一样理解为方法的重写】
        应用
            当子类需要父类中的功能，而功能的主题子类自己特有的内容时，可以重写父类中的方法，这样既延续了父类功能，也完成了子类的特殊性。如果在子类重名方法中还想使用父类中的重名方法，可以通过super.父类方法()；来调用即可，该方法可以不用放在第一行，只有在构造方法中super才只能放在第一行。
    
        为什么使用继承和重写
            主要是为了系统的升级和功能的扩展。

【注意：只有在构造方法中super只能放在第一行，其他方法中使用super可以不再第一行】

【Java采用的是Unicode的编码，Unicode的编码容纳了世界上的所有语言，所以支持中文编写程序，但一般建议不使用中文。】


例子：
    G:\CSDN_Android_\Code\day08 代码块 继承 重写 this和super final关键字\02_继承\Demo6_方法的重写.java

​    

    重写注意事项 （4个）
        1. 子类不能继承父类私有的方法
            * 因为父类中的私有方法，无法被其他类所继承。
        2. 子类重写父类时，访问权限不能低于父类（即子类>=父类的访问权限） (public最大)
            * 因为定义子类是希望子类比父类更加强大。如果子类权限比父类越来越小，最终会导致子类无法被使用（即子类无法被当成父类被其他类所继承）。
            * 最好权限修饰符一致，如果父类没有权限修饰符，子类也可不写
        3. 父类中的静态方法，子类也必须通过静态方法来实现重写
            * 静态只能覆盖静态，非静态不能覆盖静态，且静态也不能覆盖非静态，因为jvm无法识别去调用具体哪个方法 其实这种形式不属于方法的重写，多态中再具体解释。
        4. 子类重写父类方法，最好声明一模一样


方法重写面试题
over:之前，理解为再此之前。
ride:推翻
load:装填 
override: 再此之前推翻原先的，即重写。 只能出现子父类中
overload: 再此之前装填更多的，即重载。 只能出现本类中

    重载(overload[装填])和重写（override[推翻]）的区别 (2个)
        * overload(重载): 只能在本类中，出现了方法名相同，与返回值类型无关，只看参数列表的形式。
        * override(重写): 只能出现子父类中，出现了方法名相同，且与返回值类型有关的。
        
        重载：本类中出现方法名相同，且与返回类型无关，只看参数列表的方法。
        重写：子类中出现了父类中一模一样的方法，且与返回值类型有关，返回值类型一致的或是父类。


        * overload(重载) 能改变返回值类型，方法名相同，与返回值类型无关，只看参数列表。     
        * override(重写)不能改变返回值类型（方法名和参数列表必须相同，多态再具体说明) 返回值类型可以是父类。
        
    p.s.
    方法的两个特性：
            1） 重载，只出现在本类中，  即overload。
            2)  重写，出现在子父类当中，即override。


​    
子类调用方法的顺序：
    先找本类，再找父类。（就近原则）

    p.s.
    什么时候使用重写重载？
        当子类需要父类功能，当功能主体是子类特有的内容是，就可以覆盖父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容。
    
    * 父类中私有成员不能被重写。
    * 父类中static的方法不能被重写。
    * 重写时，子类方法权限必须大于或等于父类方法权限。


作业题十一
11、Overload和Override的区别是什么？方法重载能改变返回值类型吗？
        overload 是重载，只能出现在本类当中，规则：方法名相同，与返回值类型无关，只看参数类别的一种形式，且能改变返回值类型。
        override 是重写，只能出现在子父类当中，在继承关系中，出现了子父类规一模一样的方法就是重写，规则：必须方法名相同，返回值类型相同，参数列表也相同的一种形式，且无法改变返回值类型。
    
        overload 重载 可以改变返回值类型。
        orveride 重写 无法改变返回值类型。




    继承中的细节问题
案例1：    

* A:案例演示 
  * 使用继承后的学生和老师案例
     * 使用继承后，增强了代码复用性，减少了代码的冗余。

       * 分析：
         * a.首先将两者的共性抽取出来，创建一个共性父类Person，封装其共性属性，完成共性内容。
         * b.然后创建子类学生和老师，让他们去继承Person父类。
         * c.然后在学生和老师中完成特有的功能。
         * d.两种赋值方式：setXXX() 和 new对象实际传参。

         this.getName()  是子类继承了父类，相当于本类中也有了this.name = name;
         super.getName() 是子类去直接调用了父类中的方法。
         getName() 是隐藏了this，其实还是this.getName();


该例子必须去看看。
地址：
G:\CSDN_Android_\Code\day08 代码块 继承 重写 this和super final关键字\02_继承\Test2_使用继承后的学生和老师案例.java

案例2：

    * A:猫狗案例分析
    * B:案例演示
        * 猫狗案例继承版
        * 属性:毛的颜色,腿的个数
        * 行为:吃饭
        * 猫特有行为:抓老鼠catchMouse
        * 狗特有行为:看家lookHome
    
    分析：
        1. 将两者共性内容，抽取出来放入父类Animal中，完成共性属性和内容。
        2. 再创建子类猫，狗分别去继承父类Animal
        3. 再在子类中完成其特性部分。


        子类中有参构造方法的写法：
            *可通过super(name, age); 去调用父类中的有参构造。super是本类对象父类的引用。


        子类中属性的访问可使用3种形式：
            * getName();    该方法隐藏了this, 因为存在继承关系，所以访问的相当于也是本类的 this.name = name;
            * this.name();  因为存在继承关系，所以访问的相当于也是本类的 this.name = name;
            * super.name(); super是本类对象父类的引用，所以直接就是调用父类中的getName()的方法。

地址：
G:\CSDN_Android_\Code\day08 代码块 继承 重写 this和super final关键字\02_继承\Test3_猫狗案例分析和实现及测试.java


​    
​        

e.
    final关键字
        概述
            final是关键字，翻译为 "最终"，只要被final修饰的，都不能修改和继承。
        应用
            * 修饰类时，类不能被继承，但能继承其他类。
                *  如： public final class Animal{}
                
            * 修饰方法时，方法不能被重写。
                * public final void method(){}
            
            * 修饰成员变量时，变量变常量，要求所有字母大写，多个单词用下滑线隔开，【且只能被赋值一次，且必须赋初始化值，不能为空。】
                *  final int AGE = 4; (不能被修改的常量)
                *  public static final int LEG =3; (静态且不能改变的常量)
                *  final修饰的变量叫常量，所有字母都大写，一般和public static 一起被使
                   用，即：public static final String NAME="张三";
例子：G:\CSDN_Android_\Code\day08 代码块 继承 重写 this和super final关键字\04_final\Demo1_final_关键字概述.java


作业题十二
12、final关键字可以做什么,有什么特点?
        含义：
            final 是关键字，被翻译为 最终，可用于修饰类，变量，方法。
        特点：
            修饰类时，该类不能被继承，但可以继承其他类。
            修饰变量时，变量变常量，必须初始化，不能为空和只能被赋值一次，即所有字母大写，如果存在多个单词，用下滑写将每个单词隔开，一般和 public static 一起使用，即 public static int AGE =7;。
            修饰方法时，该方法不能被其他类重写。

作业题十三
13、final修饰局部变量时，有什么特点？
        有两种情况：
            当局部变量是 基本数据类型：其值不能被改变。
                         引用数据类型：地址值不能被改变，但对象中的属性值能被改变。




        注意事项    
A:案例演示
* 方法内部或者方法声明上都演示一下(了解)
* 修饰局部变量
  * 基本数据类型： 值不能被修改。
  * 引用数据类型： 只是地址值不能被改变，但对象的属性值是可以改变。

  //方法内部
      基本数据类型：
          final int a = 3;
          a=10;
          sop(a)；//3  因为final修饰基本数据类型，其值不变。


        引用数据类型：
            final Person p = new Person("呵呵",7);
            p = new Person("哈哈", 13); //直接报错，因为被final修饰的对象，即就是地址值，不能被重新赋予一个新的地址值。
            
            但可以：
            p.setName("楚乔");
            p.setAge(6);
            sop(name, age); //结果：楚乔 6 ，因为被final修饰的引用数据类型，其对象的属性值是可以改变的，但地址值是不能改变的。
            
    //方法声明上
            method(5); //5
            method(6); //6 最终值改变，因为每个方法都是调用完后，都弹栈，下一个方法进来是新的方法即新的属性值，所以值是改变的。


例子：
G:\CSDN_Android_\Code\day08 代码块 继承 重写 this和super final关键字\04_final\Demo2_final_局部变量的注意事项.java    


    final修饰变量的初始化时机
        * 必须显示初始化。
        * 在对象的构造方法完毕前完成初始化即可。

例子：
G:\CSDN_Android_\Code\day08 代码块 继承 重写 this和super final关键字\04_final\Demo3_final_修饰变量的初始化时机.java

    p.s.
        为什么要用final来修饰变量，其实在程序中如果有一个数据是固定的，那么直接使用这个数据就可以了，但是这样的阅读性差，所以要给这个数据起个名字，而且这个变量名称的值不能任意改变，所以要加上final来固定。
        写法： 常量所有字母大写，多个单词，中间用_来隔开。