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

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

• 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 有参构造");
    }
}

代码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 有参构造");
    }
}

注意事项

父类中没有无参构造，只有有参构造如何处理？把父类的有参构造也注释？

解决办法：用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 有参构造");
    }
}

代码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 有参构造");
    }
}

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

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

注意事项：

1.父类无无参构造，子类可以用super(xxx)来解决。

2.this与super为平行关系，只能存在一个。

3.子类无论如何都会访问父类中的一个构造方法，因为要看父类如何去初始化的。