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

时间：2015-12-25 18:37:42 阅读：224 评论：0 收藏：0 [点我收藏+]

标签：

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

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

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

标签：

原文地址：http://www.cnblogs.com/mmlovejj/p/5076384.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行