当一个子类，继承父类的时候，如果父类没有手写 无参构造，只有有参构造，那么子类还要声明无参构造吗？还是直接写有参构造就可以了。

1. public class Demo {
   
2.      public static void main(String[] args) {
   
3.              B b1 = new B("Lily");
   
4.              B b2 = new B("Lucy",23);
   
5.              b1.speak();
   
6.              b2.speak();
   
7.      }
   
8. }
   
9. 
   
10. class A{
    
11.         String name;
    
12.         A(String name){
    
13.                 this.name=name;
    
14.         }
    
15.         public void speak(){
    
16.                 System.out.println("I'm "+name);
    
17.         }
    
18. }
    
19. class B extends A{
    
20.         int age;
    
21. 
    
22.         B(String name){
    
23.                 super(name);
    
24.         }
    
25.         B(String name,int age){
    
26.                 super(name);
    
27.                 this.age=age;
    
28.         }
    
29.         public void speak(){
    
30.            System.out.println("I'm "+name+", "+age+" years old,I'm eating now!");
    
31.         }
    
32. }
    

复制代码

子类不能再声明无参构造了，因为他找不到父类中对应的无参构造方法。

在继承中，子类的构造函数都会默认访问父类的构造函数的，如果父类的构造函数被手动指定了，就必须在子类的构造函数的第一行中声明，去找你设置父类的构造函数，否则编译无法通过。
代码示例：

1. class Fu
   
2. {
   
3.         int x;
   
4.         //构造函数有参的父类
   
5.         Fu(int x)
   
6.         {
   
7.                 this.x= x;
   
8.         }
   
9. }
   
10. class Zi extends Fu
    
11. {
    
12.        
    
13.         Zi(int x)
    
14.         {//子类构造函数的第一行会默认的执行super();这个隐式语句，由于你给父类空参的构造函数覆盖了，所以必须手动指定父类的构造函数，初始化父类的对象，否则父类中有什么子类不知道
    
15.                 super(x);
    
16.         }
    
17. }

复制代码

你可以理解为，子类继承了父类，在子类建立对象之前怎么也得看看认得的爹张啥样啊，要是连爹啥样都不知道，这儿子父类也不能要啊，直接罢工了！！！

波涛 发表于 2014-5-18 17:45
子类不能再声明无参构造了，因为他找不到父类中对应的无餐构造方法。

...

那 假如父类中有无参构造，子类如果不写的话，他会自动调用吗？还是说 只要父类有无参构造，子类也必须要写出来呢？

在子类的每一个构造函数中的第一行，都有一个隐士的语句super()，来调用父类与之参数相同的构造函数。

当一个子类，继承父类的时候，如果父类没有手写 无参构造，只有有参构造，子类不需要写无参构造，直接写有参构造就可以了。即就是只有子类存在怎样的构造函数，父类中必须有与之参数相对应的构造函数，不然就会报错

学习了、。。。。。。。。。。。。。。。。

ID1003 发表于 2014-5-18 18:19
那 假如父类中有无参构造，子类如果不写的话，他会自动调用吗？还是说 只要父类有无参构造，子类也必须要 ...

1父类中有无参构造,子类如已经写有带参构造，则不会自动调用父类无参构造，除非显式声明；
2：父类有无参构造，子类根据需要可不写其无参构造方法，但调用时不能实例化一个子类无参对象。
这些可以自己写代码来演算测试。

子类再声明有参构造是错误的的，要super一下父类的这个有参构造函数

学习了！

学习了，还是有点晕晕的

子类所有构造函数第一行都会有一个super访问父类，如果父类没有无参构造函数，那么子类就不能建立无参构造函数，否则子类无参构造函数没有可以访问的函数。子类有参构造函数访问父类时，要通过super带参去访问。

父类中的无参构造是系统默认给出的,当父类中手动给出有参构造时,系统便不会给出空参构造,这个时候子类及时声明了无参构造也无法访问父类中的无参构造,所以还是直接写有参构造就OK啦

                                            class Person{                                                                      String name;         
                                                                   private        int age;         
                                                                  public  Person(String name){              
                                                                    this.name = name;          }         
                                                                 /*public Person(){               
                                                                  System.out.println("Person类的构造方法被调用了....");        
                                                 }          */         
                                           public void eat(){     
                                                     System.out.println(name+"在吃饭...");   
                                                                }
                                         class Student extends Person {
                                            // Student 就称作为Person类的子类， Person类就称作为Student的父类(超类、基类)         
                                                     int num; //学号         
                                                public Student(){     System.out.println("Student类的构造方法被调用了....");          }         
                                               public void study(){  System.out.println(name+"good good study , day day up");        }        
                                               class Demo2  {          public static void main(String[] args)         
                                             {   Student s = new Student();//注意：只要这个对象一创立，马上调用子类和父类的构造函数，默认先调用父类！子类如果没有无参的构造函数，JVM会创建，父类没有就报错          }  }