A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© 盛光富 中级黑马   /  2012-4-27 00:11  /  2375 人查看  /  5 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

今天在空参数这里再次迷糊了,在继承里面的构造方法这里
class Father
  {
        Father(){}
         Fahter(int age)
   {
    System.out.println("father age:"+age);
   }
  }
  class Son extends Father
  {
   Son()
   {
      System.out.println("son");
   }
   Son(int age)
   {
    super(age);
    System.out.println("son age:"+age);
   }
  }
  Son s = new Son();  
  Son s = new Son(2);
那个大哥帮忙解决下空参数函数的理解,最后好能有应用的列子

5 个回复

倒序浏览
class Father
  {
        Father(){}
         Fahter(int age)
   {
    System.out.println("father age:"+age);
   }
  }
  class Son extends Father
  {
   Son()
   {
      System.out.println("son");
   }
   Son(int age)
   {
    super(age);
    System.out.println("son age:"+age);
   }
  }
  Son s = new Son();  // new一个无参数的Son对象,java虚拟机会先调用Son父类的无参数构造函数,调用完父类的构造函数在调用自身的构造函数
  Son s = new Son(2);  // new一个有参数的Son对象,java虚拟机会先调用Son父类的有参数构造函数,调用完父类的构造函数在调用自身的构造函数
当new一个对象时,不管new出的是有参数或无参数构造函数,都会先调用父类的有参数或无参数构造函数,调用完父类的构造函数在调用自身的构造函数

回复 使用道具 举报
子类每一个构造函数内的第一行都有一句隐式super();
class Father
  {
        Father(){}
         Fahter(int age)
   {
    System.out.println("father age:"+age);
   }
  }
  class Son extends Father
  {
   Son()
   {
      //这里隐含会有一句代码 super(),来访问Father的空参数构造方法也就是Father(){}
      System.out.println("son");
   }
   Son(int age)
   {
     //这里你手动的加了一个super(age),来 访问Father的有参的构造方法,也就是Father(int age){......}
    super(age);
    System.out.println("son age:"+age);
   }
  }
  Son s = new Son();  
  Son s = new Son(2);
回复 使用道具 举报
子类每一个构造函数内的第一行都有一句隐式super();
class Father
  {
        Father(){}
         Fahter(int age)
   {
    System.out.println("father age:"+age);
   }
  }
  class Son extends Father
  {
   Son()
   {
      //这里隐含会有一句代码 super(),来访问Father的空参数构造方法也就是Father(){}
      System.out.println("son");
   }
   Son(int age)
   {
     //这里你手动的加了一个super(age),来 访问Father的有参的构造方法,也就是Father(int age){......},这时这里就不会又默认的super()了
    super(age);
    System.out.println("son age:"+age);
   }
  }
  Son s = new Son();  
  Son s = new Son(2);
回复 使用道具 举报
class Person {

                  Person(){}
          Person(int age)
                        {
                                System.out.println("Person age:"+age);
                        }
  
                        }
   //子类 会继承父类的构造函数,属性和方法等等
   class Son extends Person
   {
                Son()
                {
                   System.out.println("son");
                }
                Son(int age)
                {
                 super(age);   //super关键字是代表父类的意思,可以看成Person(2),这样肯定就不难看出是调用父类的那个有参构造方法了。因为参数是主函数中的那个s1对象传进来的参数,即:2
                 System.out.println("son age:"+age);
                }
   }
  

                       
class Test {
         public static void main(String[] args) {
                Son s = new Son();       //创建了子类的对象s,因为是创建了一个无参的构造方法,这时,它会重写父类的构造方法。  
                                                                       
                                        /*
                                        打印结果为:  son.   
                                        因为重写了父类无参构造的方法
                                        */

                                 Son s1 = new Son(2);      //这个方法和上面的类同,只不过是创建了有参的构造方法,并重写了父类的构造方法。
                                 /*
                                 打印结果为:
                                 Person age: 2                    //因为子类里引用了super关键字,就会调用父类的相应方法。
                                 son age: 2                       //因为重写了父类的有参构造方法。
                                 */
                 }

}
回复 使用道具 举报
/*
昨天晚上,夜深人静~.
*/

//定义父类
class FatherClass{
        String name = "Mary";
        String color = "red";
        
        FatherClass(){
                System.out.println("调用父类不含参数的构造方法~~!");               
        }
        FatherClass(String name, String color){
                this.name = name;
                this.color = color;
                System.out.println("调用父类含有参数的构造方法*-*!父父父有有有");        
        }
}

// 毫无疑问的是:构造方法是无法继承的,因为他们的类名不同。
// 一:若子类中没有构造方法,java编译器为子类添加空的构造方法,构造方法第一行为super();
/*class SonClass extends FatherClass{
}

public class Extension {
        public static void main(String[] args){
                SonClass s = new SonClass();     //为子类添加无参数的构造方法。
                System.out.println(s.name +"---***---"+ s.color);
        }
}*/

/*Console:
调用父类不含参数的构造方法~~!
Mary---***---red */        

// 二:若子类添加了任意类型的构造方法,java编译器不会为子类无参数的构造方法。
/*class SonClass extends FatherClass{
        SonClass(String name, String color){
                super(name, color);
        }
}

public class Extension {
        public static void main(String[] args){
                SonClass s = new SonClass();     //没有为子类添加无参数的构造方法。
                System.out.println(s.name +"---***---"+ s.color);
        }
}*/

/*Error:
        Exception in thread "main" java.lang.Error: Unresolved compilation problem:
                The constructor SonClass() is undefined

                at Extension.main(Extension.java:43)*/
//错误提示:子类无参数的构造方法没有被定义。

// 三 、若子类的构造方法没有加super语句,java编译器会为该构造方法加一个无参数的super语句,即super();
class SonClass extends FatherClass{
        SonClass(String name, String color){
                System.out.println("调用子含有参数的构造方法*-*!子子子有有有");
        }
}

public class Extension {
        public static void main(String[] args){
                SonClass s = new SonClass("John", "Golden");   //实际上调用了父类无参数的构造方法,参数没有得到传递。
                System.out.println(s.name +"---***---"+ s.color);
        }
}

/*Console:
调用父类不含参数的构造方法~~!
调用子含有参数的构造方法*-*!子子子有有有
Mary---***---red*/

回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马