继承中构造方法的注意事项

继承中构造方法的注意事项

    A：案例演示
        父类没有无参构造方法,子类怎么办？
        super解决
        this解决
    B：注意事项
        super(…)或者this(….)必须出现在构造方法的第一条语句上

代码1：

class Demo06_Extends{
    public static void main(String[] args){
        Son s1 = new Son();
        System.out.println("----------");
        Son s2 = new Son("张三", 23);
    }
}

class Father{
    private String name;        //姓名
    private int age;            //年龄

    public Father(){            //空参构造
        System.out.println("Father 空参构造");  
    }

    public Father(String name, int age){    //有参构造
        this.name = name;
        this.age = age;
        System.out.println("Father 有参构造");
    }

    public void setName(String name){       //设置姓名
        this.name = name;
    }

    public String getName(){                //获取姓名
        return name;
    }

    public void setAge(int age){            //设置年龄
        this.age = age;
    }

    public int getAge(){                    //获取年龄
        return age;
    }
}

class Son extends Father{
    public Son(){
        super();                            //隐藏一个super(),系统默认自带
        System.out.println("Son 空参构造");
    }

    public Son(String name, int age){
        //隐藏一个super(),系统默认自带。
        //不会隐藏一个super(name, age);因为系统不知道他的属性是什么
        super();
        System.out.println("Son 有参构造");
    }
}

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52

输出结果

代码2：

class Demo06_Extends{
    public static void main(String[] args){
        Son s1 = new Son();
        System.out.println("----------");
        Son s2 = new Son("张三", 23);
    }
}

class Father{
    private String name;        //姓名
    private int age;            //年龄

    //如果不写任何的构造，系统默认给一个无参构造
    //如果写了任何一个构造，系统就不会给构造方法
    /*public Father(){          //空参构造
        System.out.println("Father 空参构造");  
    }*/

    public Father(String name, int age){    //有参构造
        this.name = name;
        this.age = age;
        System.out.println("Father 有参构造");
    }

    private void setName(String name){      //设置姓名
        this.name = name;
    }

    private String getName(){               //获取姓名
        return name;
    }

    private void setAge(int age){           //设置年龄
        this.age = age;
    }

    private int getAge(){                   //获取年龄
        return age;
    }
}

class Son extends Father{
    public Son(){
        super();                            //隐藏一个super(),系统默认自带
        System.out.println("Son 空参构造");
    }

    public Son(String name, int age){
        //隐藏一个super(),系统默认自带。
        //不会隐藏一个super(name, age);因为系统不知道他的属性是什么
        super();
        System.out.println("Son 有参构造");
    }
}

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54

输出结果
注意事项

父类中没有无参构造，只有有参构造如何处理？把父类的有参构造也注释？
注意事项
解决办法：用super(name, age);来解决

代码3：

class Demo06_Extends{
    public static void main(String[] args){
        Son s1 = new Son();
        System.out.println(s1.getName() + "---" + s1.getAge());
        System.out.println("----------");
        Son s2 = new Son("张三", 23);
        System.out.println(s2.getName() + "---" + s2.getAge());
    }
}

class Father{
    private String name;        //姓名
    private int age;            //年龄

    //这样做不好，别人的类都写完了，没有加无参构造，只有一个有参构造
    //如果别人不是提供的源码，而是字节码文件，那样就不能修改了，只能修改自己的类

    /*public Father(){          //空参构造
        System.out.println("Father 空参构造");  
    }*/

    public Father(String name, int age){    //有参构造
        this.name = name;
        this.age = age;
        System.out.println("Father 有参构造");
    }

    public void setName(String name){       //设置姓名
        this.name = name;
    }

    public String getName(){                //获取姓名
        return name;
    }

    public void setAge(int age){            //设置年龄
        this.age = age;
    }

    public int getAge(){                    //获取年龄
        return age;
    }
}

class Son extends Father{
    public Son(){
        super("李四", 24);                    //隐藏一个super(),系统默认自带
        System.out.println("Son 空参构造");
    }

    public Son(String name, int age){
        //隐藏一个super(),系统默认自带。
        //不会隐藏一个super(name, age);因为系统不知道他的属性是什么
        super(name, age);
        System.out.println("Son 有参构造");
    }
}

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57

输出结果

代码4：

class Son extends Father{
    public Son(){
        //隐藏一个super(),系统默认自带
        //super("李四", 24);              //调用父类中的构造方法
        //this与super为平行关系，只能存在一个
        this("李四", 24);             //调用本类中的构造方法
        System.out.println("Son 空参构造");
    }

    public Son(String name, int age){
        //隐藏一个super(),系统默认自带。
        //不会隐藏一个super(name, age);因为系统不知道他的属性是什么
        super(name, age);
        System.out.println("Son 有参构造");
    }
}

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16

输出结果

注意事项：子类无论如何都会访问父类中的一个构造方法

class Son extends Father{
    public Son(){
        this("李四", 24);
        System.out.println("Son 空参构造");
    }
    public Son(String name, int age){
        this();
        System.out.println("Son 有参构造");
    }
}

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10

输出结果
注意事项：
1.父类无无参构造，子类可以用super(xxx)来解决。
2.this与super为平行关系，只能存在一个。
3.子类无论如何都会访问父类中的一个构造方法，因为要看父类如何去初始化的。
---------------------
作者：左绍骏
来源：CSDN
原文：https://blog.csdn.net/LeoZuosj/article/details/80504046
版权声明：本文为博主原创文章，转载请附上博文链接！