day10代码块&继承&super关键字&方法重写

        代码块：
            在Java中，使用{}括起来的代码被称为代码块，根据其位置和声明的不同，
            可以分为局部代码块，构造代码块，静态代码块，同步代码块(多线程讲解)。

        局部代码块：
            在方法中出现，限定变量的生命周期，及早释放，提高内存的利用
            在同一个类中的同一个方法中，如果存在多个局部代码块，执行顺序是自上而下的。
        构造代码块：（在创建对象的时候调用）
            定义在类中方法外。当一个类中既存在构造代码块也存在构造方法的时候，在创建对象时，会先执行构造代码块，后执行构造方法。
            无论类中有多少个构造代码块，构造代码块之间会先进行自上而下的顺序执行，然后再执行构造方法。
        静态代码块：
            在类中方法外定义，并加上static修饰。
            静态代码块是优先于其他代码块之前执行，
            静态代码块 -- 局部代码块 -- 构造代码块 -- 构造方法
            在加载的时候执行，并且只执行一次

package com.shujia.wyh.day10;

class Student2{
    static {
        System.out.println("这是在Student2类中静态代码块");  // 1
    }
    {
        System.out.println("这是在Student2类中的构造代码块"); // 2
    }
    Student2(){
        System.out.println("这是Student2类中的无参构造方法");// 3
    }
}

// 执行顺序4 5 6 1 2 3
public class CodeTest {
    static {
        System.out.println("这是在CodeTest类中的静态代码块"); // 4
    }

    public static void main(String[] args) {
        System.out.println("开始执行main方法"); // 5
        {
            System.out.println("这是在CodeTest中的局部代码块"); // 6
        }
        Student2 student2 = new Student2();
    }
}

        继承：
            把多个类相同的内容提取到另外一个类中，然后使用关键字extends来实现继承

        如何实现：
            利用java提供的关键字：extends来实现继承

        语句格式：
            class 子类名 extends 父类名{}

        继承的好处：
            1、提高了代码的复用性  看一看父类
            2、提高了代码的维护性  只需要修改父类的内容
            3、让类与类之间产生了继承关系，为了后面多态做铺垫（要有继承才能有多态）

        继承的坏处：
            1、类的耦合性增强了。（内聚）

            开发的原则：
                低耦合，高内聚

                耦合：类与类之间的关系
                内聚：类自己本身可以完成的事情

         Java中继承的特点：
            1、Java中的类class只支持单个继承，不允许多个继承
            2、Java中的类支持多层继承（形成了一个继承体系）

package com.shujia.wyh.day10;

import com.shujia.wyh.day08.Teacher;
import com.sun.corba.se.impl.legacy.connection.USLPort;

class Person{
    String name;
    int age;
    Person(){}


    public void eat(){
        System.out.println("吃饭");
    }
    public void study(){
        System.out.println("学习");
    }
}

//学生类继承人类之后，拥有了人类中的成员变量，成员方法，也可以自己定义自己类特有的成员变量和成员方法
class Student3 extends Person{
    String Id;
    public void playGame(){
        System.out.println("打游戏");
    }
}

class Teacher3 extends Person{

}

public class ExtendsDemo2 {
    public static void main(String[] args) {
        //创建一个学生对象并使用
        Student3 s1 = new Student3();
        s1.eat();
        s1.study();
        s1.playGame();

        //创建一个老师对象
        Teacher3 t1 = new Teacher3();
        t1.eat();
        t1.study();
    }
}

        使用继承时所需要的注意事项：
            1、要想初始化子类，必须先初始化父类 ******
                举例：现有父亲，才能有儿子
            2、子类只能继承父类的非私有的成员（成员变量和成员方法）
            3、子类不能继承父类的构造方法，但是可以通过super关键字去访问父类的构造方法
                因为要想初始化子类，必须先初始化父类，是通过构造方法进行初始化的。
            4、不要为了部分的功能而去使用继承

package com.shujia.wyh.day10;
class Father5{
    int num = 20;
    private int num2 = 30;


    Father5(){
        System.out.println("这是父亲的无参构造方法");
    }

    private void fun1(){
        System.out.println(num);
    }
}

class Son5 extends Father5{
    public void fun2(){
        System.out.println(num);
//        System.out.println(num2); // 子类不能继承父类的私有成员变量
    }
}

public class ExtendsDemo4 {
    public static void main(String[] args) {
        Son5 son5 = new Son5();
        son5.fun2();
//        son5.fun1(); // 子类不能继承父类的私有成员方法

    }
}

继承与成员变量之间（成员方法）的关系：
1、当子类中的成员变量（成员方法）与父类中的成员变量（成员方法）名字一样的时候
        查找：（就近原则）
                 1）先在方法的局部范围内进行查找，如果找到就返回
                 2）如果在方法局部范围找不到，去本类中成员位置上查找，如果找到就返回
                 3）如果在中成员位置上找不到，去父类中成员位置上查找，如果找到就返回
2、当子类中的成员变量（成员方法）与父类中的成员变量（成员方法）名字不一样的时候，使用什么变量名，就访问谁
 

super

this关键字与super关键字的使用区别？
            this代表的是调用该类的当前对象
            super代表的是父类存储空间的标识（父类的引用，可以操作父类的成员）

       使用格式
            1、访问成员变量
                this.成员变量 访问的是本类中的成员变量
                super.成员变量 访问的是父类中的成员变量
            2、访问构造方法
                this(...)
                super(...)
            3、访问成员方法
                this.成员方法()
                super.成员方法()

package com.shujia.wyh.day10;
class Father7{
    int num = 10;
    public void show2(){
        System.out.println("这是父类中的show2方法");
    }
}

class Son7 extends Father7{
    int num = 20;
    public void show(){
        int num = 30;
        System.out.println(num);
        System.out.println(this.num); // 访问的是本类中的成员变量
        System.out.println(super.num);// 访问的是父类中的成员变量
        show2();
        super.show2();// 访问的是父类中的成员方法

        show3();
        this.show3();// 访问的是本类中的成员方法

    }

    public void show3(){
        System.out.println("这是Son7类中的show3方法");
    }
}

public class ExtendsDemo6 {
    public static void main(String[] args) {
        Son7 son7 = new Son7();
        son7.show();
    }
}

        继承与构造方法的关系：
            1、要想初始化子类，必选先初始化父类
            2、因为子类会继承父类的数据，甚至可能会使用父类的数据
                所以在子类初始化之前，一定会先完成父类的初始化

                注意：
                    每个子类的构造方法的第一句话默认是super().

package com.shujia.wyh.day10;
class Father8 {
    int age;

    Father8() {
        System.out.println("父类中的无参构造方法");//1
    }

    Father8(String s) {
        System.out.println("这是父类带参数的构造方法" + s);//2
    }
}

class Son8 extends Father8 {
    Son8() {
        System.out.println("子类的无参构造方法");//3
    }

    Son8(String s) {
        System.out.println("子类带参数的构造方法" + s);//4
    }
}
//执行顺序1 4

public class ExtendsDemo7 {
    public static void main(String[] args) {
        Son8 s1 = new Son8("小王");
    }
}

        当父类中没有无参构造方法的时候，怎么办呢？
        1、使用super关键字带参数的形式访问父类的带参数构造方法
        2、子类通过this关键字调用本类的其他构造方法
            注意，本类其他构造方法也必须可以访问父类拥有的构造方法
            使用this关键字间接的调用父类的构造方法
            无论在哪里调用父类的构造方法，只要最后保证在子类构造方法内容执行之前完成了父类的初始化就可以了

        3、super(..)或者this(..)必须出现在第一条语句上
        2、否则就会出现父类的数据进行了多次初始化
            （重点）每个类只能初始化一次

package com.shujia.wyh.day10;
class Father9 {
    int age;


    Father9(String s) {
        System.out.println("这是父类带参数的构造方法" + s);
    }
}

class Son9 extends Father9 {
    Son9() {
        super("你好");//有参可以访问父类拥有的构造方法
        System.out.println("子类的无参构造方法");
    }

    Son9(String s) {
        this();//该类无参构造函数可以访问父类拥有的构造方法
        System.out.println("子类带参数的构造方法" + s);
    }
}


public class ExtendsDemo8 {
    public static void main(String[] args) {
        Son9 s1 = new Son9("小王");
    }
}

        方法的重写：如果子类的方法声明与父类的方法声明一样，这样的现象叫做方法的重写。
        重写现象是发生在继承的关系中。

            重写与重载的区别：
                重写是发生在继承的关系的关系中，重载是发生在本类中。
                重载是方法名一致，参数列表不一致就是重载。
                重写是方法名，参数列表，返回值都一样，实现不一样，叫方法的重写。
                重载的英文单词：overload
                重写的英文单词：override

package com.shujia.wyh.day10;
class OldPhone{
    public void call(String name){
        System.out.println("给"+name+"打电话");
    }
}

class newPhone extends OldPhone{
    public void call(String name) {
        super.call(name);//调用父类同名方法的内容
        System.out.println("看抖音");//新定义的内容
    }
}

public class ExtendsDemo10 {
    public static void main(String[] args) {
        newPhone newPhone = new newPhone();
        newPhone.call("小王");
    }
}

注意：先成员变量显式赋值(new)
           后构造方法赋值

package com.shujia.wyh.day10;
class X {//先成员变量显式赋值后构造方法赋值
    Y b = new Y(); // 1
    X() {
        System.out.print("X"); // 3
    }
}
class Y {
    Y() {
        System.out.print("Y"); //2
    }
}

class Z extends X{//要想初始化子类，必选先初始化父类,找父类X类执行
    Y y = new Y();

    Z(){
//        super();  //这里的super()存在的意义不大 因为已经初始化过了。
        System.out.println("Z");//4
    }
}

public class ExtendsTest2{
    public static void main(String[] args) {//先执行main函数
        new Z();//创建Z类对象，找Z类执行
    }
}
//YXYZ

        方法重写的注意事项：
            1、父类中私有的方法不能被重写
            2、子类重写父类的方法时候，访问权限不能更低
                要么子类重写的方法访问权限比父类的访问权限要高或者一样
                建议：以后子类重写父类的方法的时候，权限修饰符写一样就不会发生这样的问题。
            3、父类中静态的方法不能被重写，也就是说不能被Override修饰，因为静态的是属于类本身的东西。