朱小白之回顾继承（2）

继承中的构造方法

Java中子类不能继承父类的构造方法，那如果父类和子类都写了构造方法，那该如何执行呢？

public class Person
 {
  private int id;
  private String name;
  public Person()
    {
   System.out.println("父类的");
     }
  public Person(int id ,String name)
    {
   this.id=id;
   this.name=name;
   System.out.println("爱吃肉");
    }
   public void setId(int id)
   {
    this.id=id;
   }
   public int getId()
   {
    return id;
   }
   public void setName(String name)
  {
    this.name=name;
  }
   public String getName()
  {
   return this.name;
  }
   public String toString() {
       return "{" + id + ", " + name + "}"; 
	}
 } 
 
 public class Chinese extends Person
  {
    public Chinese()
   {
    System.out.println("子类的构造");
   }
  }
  
  public class Test
   {
     public static void main(String[] args)
    {
     new Chinese();
    }
   }   

编译器如下：

E:\zpy\继承>java Test
父类的
子类的构造

我们可以推断，在Chinese的无参构造中，有一个隐含的父类Person的无参构造。它一定是Chinese无参构造中的第一条语句。

public class Person
 {
  private int id;
  private String name;
  public Person()
    {
   System.out.println("父类的");
     }
  public Person(int id ,String name)
    {
   this.id=id;
   this.name=name;
   System.out.println("爱吃肉");
    }
   public void setId(int id)
   {
    this.id=id;
   }
   public int getId()
   {
    return id;
   }
   public void setName(String name)
  {
    this.name=name;
  }
   public String getName()
  {
   return this.name;
  }
   public String toString() {
       return "{" + id + ", " + name + "}"; 
	}
 } 
 
 public class Chinese extends Person
  {
    public Chinese()
   {
    System.out.println("子类的无参构造");
   }
   public Chinese(int id,String name)
   {
    System.out.println("子类的有参构造");
   }
  }
  
     public class Test
   {
     public static void main(String[] args)
    {
     new Chinese(100,"朱培宇");
    }
   }

编译结果如下：

   父类的
子类的有参构造

上述代码中我们父类和子类中都定义有参构造，通过main方法进行测试，得出结果：
1.先执行了父类的无参构造。
2.在执行了子类的无参构造。
因此我们得出结论：在调用子类有参构造的时候，父类的无参构造在子类的有参构造中，且是最先被执行的。

public class Person
 {
  private int id;
  private String name;
  public Person(int id ,String name)
    {
   this.id=id;
   this.name=name;
   System.out.println("爱吃肉");
    }
   public void setId(int id)
   {
    this.id=id;
   }
   public int getId()
   {
    return id;
   }
   public void setName(String name)
  {
    this.name=name;
  }
   public String getName()
  {
   return this.name;
  }
   public String toString() {
       return "{" + id + ", " + name + "}"; 
	}
 } 
 
 public class Chinese extends Person
  {
    public Chinese()
   {
    System.out.println("子类的无参构造");
   }
   public Chinese(int id,String name)
   {
    System.out.println("子类的有参构造");
   }
  }
  
     public class Test
   {
     public static void main(String[] args)
    {
     new Chinese();
    }
   }

以上代码解释：父类没有定义无参构造，只定义了有参构造，那么父类中是不存在无参构造的。
子类中定义了有参无参两个构造方法。
我们在测试程序中调用子类的无参构造。
编译器报以下错误：无法将类 Person中的构造器 Person应用到给定类型;

结论：父类中必须要有无参构造。子类构造中一定有一个隐含的父类的构造。 经过试验证明，这个父类的构造方法是无参的，隐式的存在。

记住：在继承中，父类的无参构造一定要存在(默认的存在，或者是显式的存在，最好是显式的定义)，否则子类编译都通不过。