Java 面向对象三大特征之继承

补充内容：代码块

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

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

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

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

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);不能访问局部代码块中声明的变量
    }
}

局部代码块

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

　　构造代码块的执行说明：

  　　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);
    }
}

构造代码块

 

五、静态代码块：定义在类中方法外有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
    }
}

各个代码块的执行状况

继承

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

二、关键字 extends

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

四、继承优势：提升了代码的复用性、提升了代码的可维护性、是多态的前提

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

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

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

　　　　构造方法不能继承 由于子类父类的类名不一样，子类的成员数量可能大于父类的成员数量，

　　　在构造方法中赋值时不同

　　　　建立子类时先执行父类构造方法，而后执行子类构造方法

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

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

　　在子父类中定义了不一样的成员变量，则既能够访问子类的成员变量也能够访问父类的成员变量

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

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

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

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

　　　一直到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);
    }
    
}

成员变量的继承特色

七、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);//编译报错
    }
}

this和supper的使用

　4.总结

　　一、含义：

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

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

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

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

　　二、super和this均可以访问成员变量

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

  　　　super.成员变量名

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

   　  　 his.成员变量名

　　三、super和this均可以访问成员方法

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

  　   　 super.成员方法名()

 　　     this不只能够访问子类中定义的成员方法，也能够访问父类中定义的成员方法

   　       this.成员方法名()

　　四、super和this均可以访问构造方法：this语句和super语句

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

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

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

　　一、在初始化子类数据以前，必须先完成对父类数据的初始化（由于在初始化子类数据的时候，

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

　　二、若是在子类的构造方法中，没有显式的调用任何其余构造方法（本类、父类），在构造方法的第一句，

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

　　三、若是在子类的构造方法中，手动增长了访问父类的构造方法，那么系统将不给你增长任何构造方法的访问

　　四、若是在子类的构造方法中，手动增长了访问本类的其余构造方法，那么系统将不给你增长任何构造方法的访问

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

  　　　　构造方法不能本身直接访问本身，也不能本身间接的访问本身

　　六、总结：

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

  　　　　二、特色：

    　　　　【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的有参构造被调用了");
    }

}

构造方法和this supper的使用