一、总结

① 创建类时指定了有参构造方法后，系统默认不会创建无参数构造方法，需要手动创建。

② 一个类中的多个构造方法，创建对象只能有一个被调用（除非在构造方法使用this()来调用类中其他的构造方法）

③ 创建子类时，若子类构造方法没有使用Super来调用父类的有参（无参就运行父类无参）构成方法，则会默认运行父类的无参数构造方法，若父类没有无参数构造方法，则运行失败。

④ 创建子类时，总是先运行父类的构造方法（Super()和this()必须位于子类构造方法的第一行,如下面例子中所示）

二、例子

class Predessor {
    int id;
    String city;

    public Predessor() {
        System.out.println("调用了父类Predessor 无参的构造函数");
    }

    public Predessor(int id, String city) {
        System.out.println("调用了父类Predessor 有参的构造函数");
        this.id = id;
        this.city = city;
    }

    @Override
    public String toString() {
        return "Predessor [id=" + id + ", city=" + city + "]";
    }
}

class Successor extends Predessor {
    private String name;
    private String sex;

    public Successor() {
        System.out.println("调用了子类Successor 无参的构造函数");
    }

    public Successor(String name, String sex) {
        this();
        System.out.println("调用了子类Successor 有参的构造函数");
        this.name = name;
        this.sex = sex;
    }
    public Successor(int id, String city,String name, String sex) {

        super(id, city);
        //this();编译出错 must be first statement in constructor body
        System.out.println("调用了子类Successor 有参的构造函数");
        //super(id, city);编译出错 must be first statement in constructor body
        this.name = name;
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "Successor{" +
                "id=" + id +
                ", city='" + city + '\'' +
                ", name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                '}';
    }
}

public class Demo006GouZaoHanShu {

    public static void main(String[] args) {
        Successor s = new Successor();
        System.out.println(s);
        System.out.println("--------------");
        Successor s2 = new Successor("A", "male");
        System.out.println(s2);
        System.out.println("--------------");
        Successor s3 = new Successor(22,"man","A", "male");
        System.out.println(s3);
    }

}

运行结果如下：

调用了父类Predessor 无参的构造函数
调用了子类Successor 无参的构造函数
Successor{id=0, city='null', name='null', sex='null'}
--------------
调用了父类Predessor 无参的构造函数
调用了子类Successor 无参的构造函数
调用了子类Successor 有参的构造函数
Successor{id=0, city='null', name='A', sex='male'}
--------------
调用了父类Predessor 有参的构造函数
调用了子类Successor 有参的构造函数
Successor{id=22, city='man', name='A', sex='male'}