深究继承示例（多态，继承，构造函数）

关于继承，为什么一直说在含有构造函数的继承中，父类中一定要有不含参数的构造函数才可以。

首先说明默认值的一个知识点：在定义全局变量的时候，即使不给变量赋值，变量也是有值的，比如整形变量的默认值是0

package day07;

public class Trys {
    private static int  p ;
    public static void main(String[] args) {

        System.out.println(p);
    }

}0

*但是局部变量就必须赋值，不赋值是没法输出的。

其次说明一个多态的知识点：

像Father father = new Son(); 这样的吧，这有一种专业说法，叫“父类引用指向子类对象”。首先 new Son();是肯定动态创建了一个子类对象的。 Father father 则是一个创建了一个父类引用对象。 Father father = new Son(); 就是将父类引用指向子类对象，这是java里很常用的用法。这时候如果用father调用方法father.method() ;如果method()方法只有父类有，子类里没有写。那么就调用父类里那个方法体。如果在子类里有对method()进行了重写(注意是重写不是重载)，那么就调用子类里的那个方法体。

当创建的子类对象需要访问到父类构造函数的时候，如果父类中没有显写的构造函数，那么会访问父类中默认的空构造，如果有构造函数，那么空构造失效，如果显写的构造函数不含参数，那么当子类需要访问到父类构造函数的时候不需要用到super关键字，但是如果父类中的构造函数含有参数的话，子类中需要访问到父类的构造函数的话需要在函数的首行写super(参数)举个例子（注意私有变量只能在本类中有效）

package day07;

class SuperClass {
    private int number;

    public SuperClass() {
        this.number = 0;
        System.out.println(this.number+" "+number+" "+"1111111111111111111");
    }

    public SuperClass(int number) {
        this.number = number;
        System.out.println(this.number+" "+number+" "+"22222222222222222222");

    }

    public int getNumber() {
        System.out.println(this.number+" "+number+" "+"0000000000000000000");
        number++;
        System.out.println(this.number+" "+number+" "+"0000000000000000000");
        return number;
    }
}

class SubClass1 extends SuperClass {
    public SubClass1(int number) {
//        super(number);
    }

}

class SubClass2 extends SuperClass {
    private int number;

    public SubClass2(int number) {
//        super(number);
        System.out.println("77777777777777777"+"  "+number);
    }
    }

public class Extends1 extends SuperClass {

    private int number;//有默认值，默认值为0

    public Extends1(int number) {
//        super(number);
        System.out.println("44444444444444"+"  "+number);
    }

    public int getNumber() {
        System.out.println(this.number+" "+number+" "+"55555555555555555555");
        number++;
        System.out.println(this.number+" "+number+" "+"55555555555555555555");
        return number;
    }

    public static void main(String[] args) {
        SuperClass ss = new SuperClass(20);
        System.out.println(ss.getNumber());
        System.out.println("\n\n");

        SuperClass s = new Extends1(20);
        System.out.println(s.getNumber());
        System.out.println("\n\n");

        SuperClass s1 = new SubClass1(20);
        System.out.println(s1.getNumber());
        System.out.println("\n\n");

        SuperClass s2 = new SubClass2(20);
        System.out.println(s2.getNumber());
        //结论一：多态时，当子类覆盖了父类的方法，使用子类覆盖的方法
        //结论二：当子类覆盖父类的成员变量时，父类方法使用的是父类的成员变量，子类方法使用的是子类的成员变量
    }

}

20 20 22222222222222222222
20 20 0000000000000000000
21 21 0000000000000000000
21

0 0 1111111111111111111
44444444444444 20
0 0 55555555555555555555
1 1 55555555555555555555
1

0 0 1111111111111111111
0 0 0000000000000000000
1 1 0000000000000000000
1

0 0 1111111111111111111
77777777777777777 20
0 0 0000000000000000000
1 1 0000000000000000000
1

再比如：

package day07;

class SuperClass {
    private int number;

//    public SuperClass() {
//        this.number = 0;
//        System.out.println(this.number+" "+number+" "+"1111111111111111111");
//    }

    public SuperClass(int number) {
        this.number = number;
        System.out.println(this.number+" "+number+" "+"22222222222222222222");

    }

    public int getNumber() {
        System.out.println(this.number+" "+number+" "+"0000000000000000000");
        number++;
        System.out.println(this.number+" "+number+" "+"0000000000000000000");
        return number;
    }
}

class SubClass1 extends SuperClass {
    public SubClass1(int number) {
        super(number);
    }

}

class SubClass2 extends SuperClass {
    private int number;

    public SubClass2(int number) {
        super(number);
        System.out.println("77777777777777777"+"  "+number);
    }
    }

public class Extends1 extends SuperClass {

    private int number;//有默认值，默认值为0

    public Extends1(int number) {
        super(number);
        System.out.println("44444444444444"+"  "+number);
    }

    public int getNumber() {
        System.out.println(this.number+" "+number+" "+"55555555555555555555");
        number++;
        System.out.println(this.number+" "+number+" "+"55555555555555555555");
        return number;
    }

    public static void main(String[] args) {
        SuperClass ss = new SuperClass(20);
        System.out.println(ss.getNumber());
        System.out.println("\n\n");

        SuperClass s = new Extends1(20);
        System.out.println(s.getNumber());
        System.out.println("\n\n");

        SuperClass s1 = new SubClass1(20);
        System.out.println(s1.getNumber());
        System.out.println("\n\n");

        SuperClass s2 = new SubClass2(20);
        System.out.println(s2.getNumber());
        //结论一：多态时，当子类覆盖了父类的方法，使用子类覆盖的方法
        //结论二：当子类覆盖父类的成员变量时，父类方法使用的是父类的成员变量，子类方法使用的是子类的成员变量
    }

}

20 20 22222222222222222222
20 20 0000000000000000000
21 21 0000000000000000000
21

20 20 22222222222222222222
44444444444444 20
0 0 55555555555555555555
1 1 55555555555555555555
1

20 20 22222222222222222222
20 20 0000000000000000000
21 21 0000000000000000000
21

20 20 22222222222222222222
77777777777777777 20
20 20 0000000000000000000
21 21 0000000000000000000
21

再比如：

package day07;

class SuperClass {
    private int number;

    public SuperClass() {
        this.number = 0;
        System.out.println(this.number+" "+number+" "+"1111111111111111111");
    }

    public SuperClass(int number) {
        this.number = number;
        System.out.println(this.number+" "+number+" "+"22222222222222222222");

    }

    public int getNumber() {
        System.out.println(this.number+" "+number+" "+"0000000000000000000");
        number++;
        System.out.println(this.number+" "+number+" "+"0000000000000000000");
        return number;
    }
}

class SubClass1 extends SuperClass {
    public SubClass1(int number) {
        super(number);
    }

}

class SubClass2 extends SuperClass {
    private int number;

    public SubClass2(int number) {
        super(number);
        System.out.println("77777777777777777"+"  "+number);
    }
    }

public class Extends1 extends SuperClass {

    private int number;//有默认值，默认值为0

    public Extends1(int number) {
        super(number);
        System.out.println("44444444444444"+"  "+number);
    }

    public int getNumber() {
        System.out.println(this.number+" "+number+" "+"55555555555555555555");
        number++;
        System.out.println(this.number+" "+number+" "+"55555555555555555555");
        return number;
    }

    public static void main(String[] args) {
        SuperClass ss = new SuperClass(20);
        System.out.println(ss.getNumber());
        System.out.println("\n\n");

        SuperClass s = new Extends1(20);
        System.out.println(s.getNumber());
        System.out.println("\n\n");

        SuperClass s1 = new SubClass1(20);
        System.out.println(s1.getNumber());
        System.out.println("\n\n");

        SuperClass s2 = new SubClass2(20);
        System.out.println(s2.getNumber());
        //结论一：多态时，当子类覆盖了父类的方法，使用子类覆盖的方法
        //结论二：当子类覆盖父类的成员变量时，父类方法使用的是父类的成员变量，子类方法使用的是子类的成员变量
    }

}

20 20 22222222222222222222
20 20 0000000000000000000
21 21 0000000000000000000
21

20 20 22222222222222222222
44444444444444 20
0 0 55555555555555555555
1 1 55555555555555555555
1

20 20 22222222222222222222
20 20 0000000000000000000
21 21 0000000000000000000
21

20 20 22222222222222222222
77777777777777777 20
20 20 0000000000000000000
21 21 0000000000000000000
21

时间： 2024-10-23 02:47:27

深究继承示例（多态，继承，构造函数）

深究继承示例（多态，继承，构造函数）的相关文章

课堂笔记--初识继承和多态继承

面向对象的封装、继承、多态以及构造函数

（一）Python入门-6面向对象编程：07面向对象三大特征(封装、继承、多态)-继承

面向对象的三大特性(封装、继承、多态)-----继承

c/c++ 继承与多态继承中的public, protected, private

3. 第一章：C#面向对象编程之继承和多态

面向对象（一）—继承与多态

Python 面向对象的三大特性：封装，继承，多态

c# 中面相对性的三个特点：封装，继承，多态，以及c#中隐藏(new)和方法重写(override)和重载(overload)的区别

Java基础——封装、继承、多态