Java 面向对象三大特征之继承 代码块相关内容补充

补充内容：代码块

1、什么叫做代码块：大括号括起来的一段代码

2、分类：局部代码块、构造代码块、静态代码块、同步代码块

3、局部代码块：定义在方法中的代码块，在局部代码块中声明的变量，只在代码块中使用，一旦出了代码块，

　　　　　　　　变量就不能继续使用了。如果在局部代码块中修改了代码块之外定义的变量，出了代码块后不会消除修改。

class Test {
    public static void main(String[] args) {
        int i = 10;
        {
            System.out.println(i);
            i = 20;
            int j = 100;
            System.out.println(j);
        }

        System.out.println(i);//20，局部代码块只对其中声明的变量有效果，对于变量的使用还是和以前一样
        //System.out.println(j);不能访问局部代码块中声明的变量
    }
}

4、构造代码块：定义在类中方法外的代码块，用于给成员变量初始化赋值

　　构造代码块的执行说明：

  　　1、在创建对象的时候执行，由jvm默认调用

  　　2、在构造方法执行之前，执行

  　　3、任意一个构造方法执行之前，都会执行一次构造代码块的内容

  　　4、如果每个构造方法都会执行的内容，提取到构造代码块中

 

public class Test3 {

    public static void main(String[] args) {
        Person1 p = new Person1();
        p.show();

    }

}
class Person1{
    private String name;
    {
        name = "qq";
    }
    public void show() {
        System.out.println(name);
    }
}

 

5、静态代码块：定义在类中方法外有static修饰符的代码块，用于给静态的成员变量赋初始值，

　　　　用于执行一些只执行一次的代码，随着类的加载而执行，且只执行一次

public class Test3 {
    static {
        System.out.println("测试类的静态代码块执行了");//1
    }
    public static void main(String[] args) {
        Person1 p = new Person1();
        Person1 p1 = new Person1(1);

    }

}
class Person1{
    static {
        System.out.println("Person1的静态代码块执行了");//3
    }

    {
        System.out.println("Person1的构造代码块执行了");//4,6
    }

    public Person1() {
        System.out.println("Person1的空参构造执行了");//5
    }

    public Person1(int i) {
        System.out.println("Person1的有参构造执行了");//7
    }
}

继承

1、类与类之间的关系，子父类关系，子类一定比父类强

2、关键字 extends

3、父类：被继承的类 基类，超类   子类：继承的类 派生类

4、继承优点：提高了代码的复用性、提高了代码的可维护性、是多态的前提

　　　　缺点：提高了代码的耦合性（相互依赖的程度）

　　开发原则：高内聚、低耦合

5、注意：父类的私有成员不能直接在子类中使用，子类继承了但不能直接访问

　　　　构造方法不能继承 因为子类父类的类名不同，子类的成员数量可能大于父类的成员数量，

　　　在构造方法中赋值时不一样

　　　　创建子类时先执行父类构造方法，然后执行子类构造方法

　　　**不要为了部分功能而设计继承

6、继承中成员变量的关系

　　在子父类中定义了不同的成员变量，则既可以访问子类的成员变量也可以访问父类的成员变量

　　在子父类中定义的同名的成员变量，则根据就近原则来访问：

　　　　在子类的方法中，如果访问了某个变量名称，优先在当前方法中，寻找该变量的定义，如果找到了

　　　就使用方法中的局部变量；如果没有找到，就到子类的成员位置寻找该变量的定义，如果找到了就使用

　　　子类的成员变量；如果没有找到，就到父类的成员位置寻找该变量的定义....一直往上找，

　　　一直到Object类中，如果还没有找到，就编译报错。

public class Test4 {

    public static void main(String[] args) {
        A_1 a = new A_1();
        a.show();
        a.show1();
        a.show2();
    }

}
class A{
    int age=10;
    int date = 11;
}
class A_1 extends A{
    int age=5;
    public void show() {
        int age =2;
        System.out.println(age);
    }
    public void show1() {
        System.out.println(age);
    }
    public void show2() {
        System.out.println(date);
    }
    
}

7、this 和supper关键字

　　this:当前对象的引用
　　super:表示本类当前对象的父类的引用。
　1.this.成员变量 super.成员变量
　2.super和this访问成员方法
　　　super只能访问父类的成员方法，不能访问private修饰的成员方法
　　　super.方法名()
　　　this不仅可以访问父类的成员方法，同时也可以访问子类中定义的方法
　　　this.方法名（）
　3.super和this都可以访问构造方法：this语句和super语句
　　　this():访问本类的其它的构造方法
　　　super():访问父类的构造方法

class Test4 {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.test(1000);
    }
}

class Fu {
    int i = 10;
    int j = 20;
}

class Zi extends Fu {
    int i = 100;
    int k = 200;

    public void test(int i) {
        System.out.println(i);//1000
        System.out.println(this.i);//100
        System.out.println(super.i);//10

        System.out.println(j);//20
        System.out.println(this.j);//20
        System.out.println(super.j);//20

        System.out.println(k);//200
        System.out.println(this.k);//200
        //System.out.println(super.k);//编译报错
    }
}

　4.总结

　　1、含义：

 　　   this关键字表示本类当前对象的引用

   　　 哪个对象在调用this所在的方法，this就表示哪个对象

 　　   super关键字表示本类当前对象的父类的引用

  　　  哪个对象在调用super所在的方法，super就表示哪个对象中的父类部分的数据

　　2、super和this都可以访问成员变量

  　　　super只能访问父类中定义的成员变量

  　　　super.成员变量名

 　　 　this既可以访问子类中定义的成员变量，也可以访问父类中定义的成员变量

   　  　this.成员变量名

　　3、super和this都可以访问成员方法

  　　　super只能访问父类中定义的成员方法

  　   　 super.成员方法名()

 　　     this不仅可以访问子类中定义的成员方法，也可以访问父类中定义的成员方法

   　       this.成员方法名()

　　4、super和this都可以访问构造方法：this语句和super语句

  　　    this()：访问本类的其他构造方法

  　　　super()：访问父类的构造方法

8、继承中构造方法的关系

　　1、在初始化子类数据之前，必须先完成对父类数据的初始化（因为在初始化子类数据的时候，

　　　　可能会使用到父类中的数据，所以必须先把父类数据准备好）

　　2、如果在子类的构造方法中，没有显式的调用任何其他构造方法（本类、父类），在构造方法的第一句，

　　　　系统默认给你加上super()，默认要访问父类的空参构造

　　3、如果在子类的构造方法中，手动增加了访问父类的构造方法，那么系统将不给你增加任何构造方法的访问

　　4、如果在子类的构造方法中，手动增加了访问本类的其他构造方法，那么系统将不给你增加任何构造方法的访问

　　5、构造方法不能递归调用

  　　　　构造方法不能自己直接访问自己，也不能自己间接的访问自己

　　6、总结：

  　　　　1、【目标】子类的构造方法，一定要先访问父类的构造方法

  　　　　2、特点：

    　　　　【this语句】和【super语句】必须在构造方法的第一行

     　　　　 super语句在第一句是为了保证父类的构造方法必须先执行

     　　　　 this语句在第一句是因为间接的访问了super，super必须先执行

    　　　　 在构造方法中，【this语句】和【super语句】不能共存

     　　　　 this语句和super语句都要在构造方法的第一行

    　　　　【this语句】和【super语句】不能出现在其他非构造方法的非静态成员方法中

      　　其他方法都是在对象创建之后，才能调用的方法，如果能调用this语句，就相当于间接的使用对象，调用构造方法

 

public class Test5 {

    public static void main(String[] args) {
        Cat c = new Cat("black");
        c.show();
        System.out.println("====================");
        Cat c1 = new Cat("white",10);
        c1.show();
    }

}

class Animal {
    private String color;

    public Animal() {
        System.out.println("Animal的空参构造被调用了");
    }

    public Animal(String color) {
        this.color = color;
    }

    public void show() {
        System.out.println(color);
    }
}

class Cat extends Animal {
    public Cat() {
        //此处默认增加了一个super()
        System.out.println("Cat的空参构造被调用了");
    }

    public Cat(String color) {
        super(color);
        System.out.println("Cat的有参构造被调用了");
    }

    public Cat(String color,int age) {
        this();
        System.out.println("Cat的有参构造被调用了");
    }

}