精华内容
下载资源
问答
  • 通常java的构造函数被设置为public的(若你不写构造函数,java自动添加的无参空构造函数就是public的),因本文中的类都在同一个包中,因此使用无修饰的友好权限说明问题,对于private构造函数的意义,可参见这里。...

    问题一:java的构造函数能否被继承?

    笔者初学java看的一本书说:“java的子类自然的继承其超类的“非private成员”。

    通常java的构造函数被设置为public的(若你不写构造函数,java自动添加的无参空构造函数就是public的),因本文中的类都在同一个包中,因此使用无修饰的友好权限说明问题,对于private构造函数的意义,可参见这里。

    那么根据该书所述规则,非private的构造函数当然也应该被子类继承。

    但实际上,子类不仅无法继承private成员,也无法继承构造函数。

    下面用代码进行说明。

    示例1.

    系统自动添加的无参空构造函数:(若不写构造函数,java默认添加一个无参的空构造函数)

    class base{

    }

    class derived extends base{

    public static void main(String[] args){

    derived d=new derived();

    }

    }

    示例2.

    把父类中系统自动添加的无参空构造函数显式的写出来(为了有输出,加了println):

    class base{

    base(){

    System.out.println("base constructor");

    }

    }

    class derived extends base{

    public static void main(String[] args){

    derived d=new derived();

    }

    }

    输出结果:base constructor, 代码通过编译。从示例1,2来看,好像子类可以继承超类的构造函数哦。

    但实际情况是:java规则:子类创建对象的同时会先创造父类的对象,因此必须先调用父类的构造方法。示例2中derived没有重写构造方法,根据java规则,系统会默认的添加一个无参的构造方法,且该方法第一句是super()。显式的写出来是:

    derived(){

    super();

    }

    那为什么子类可以不写呢,因为:如果父类"只"有无参构造方法,且不打算重写子类的构造方法,为节省代码量,子类构造方法可以不写,系统默认调用父类无参构造方法super()。

    可能还是有人觉得这些示例的说服力不够强,依然认为构造方法是可以继承的,没关系,看完本文,特别是示例4配合最后带★的文字,即可充分说明问题。

    再来看看有参构造方法:

    示例3.

    如果将超类的构造方法改为有参构造方法,代码见下,则eclipse会报"Implicit super constructor xxx is undefined for default constructor. Must define an explicit constructor"

    说明对于超类的有参构造方法,子类是无法继承的。

    class base{

    base(int x){

    System.out.println("base constructor,i="+x);

    }

    }

    class derived extends base{

    public static void main(String[] args){

    derived d=new derived();

    }

    }

    对于有参的构造函数,子类中必须定义自己的构造方法。

    (需要注意参数匹配,将该参数通过第一句的super(ParamList)传给父类的构造方法,若是多层继承,则需要逐级传递参数至最顶层的有参构造方法)

    class base{

    base(int x){

    System.out.println("base constructor,i="+x);

    }

    }

    class derived extends base{

    derived(int x){

    super(x);  //这里使用了super(param),调用了超类的构造方法。

    System.out.println("derived constructor,i="+x);

    }

    public static void main(String[] args){

    derived d=new derived(8);

    }

    }

    输出结果:

    base constructor,i=8

    derived constructor,i=8

    问题二:子类的构造函数可否不使用super(ParamList)调用超类的构造方法?

    上例中使用了super调用了超类的构造方法。同样是那本书中说:“子类的构造方法中必须使用super调用超类的构造方法,且super必须是子类构造方法的第一句。”

    那我不用super行不行呢?原话给人的感觉好像是java的语法规定一样。

    其实可以不用显式的写出super,但前提是“超类中有多个构造方法,且有一个是显式写出的无参的构造方法”。

    示例4.

    超类拥有多个构造方法,其中一个是显式的无参的构造方法。

    class base {

    base() {                                          //warning_su

    System.out.println("base constructor.");  //warning_su

    }                                                 //warning_su

    base(int x) {

    System.out.println("base constructor,i=" + x);

    }

    }

    class derived extends base {

    derived() {                                        //warning_de

    System.out.println("derived constructor"); //warning_de

    }                                                  //warning_de

    derived(int x) {

    //super(x);                                //super被注释掉了!

    System.out.println("derived constructor,i=" + x);

    }

    public static void main(String[] args) {

    derived d= new derived();                       //warning_cr

    derived t = new derived(8);

    }

    }

    输出结果:

    base constructor.

    derived constructor

    base constructor.    

    derived constructor,i=8

    此时,子类有参构造方法中没有使用super(x)调用超类的构造方法也通过编译了,但是不使用super(ParamList),new derived(8)调用的是超类的无参构造方法base()!

    为什么要强调必须是“显式写出”的无参构造方法,您可以试试把带有warnning字样的代码注释掉(warning_su,warning_de,waring_cr3处),同时也注释掉super(x)。

    因为此时超类和子类有构造方法(有参的那个),系统不会自动给超类添加无参的空构造函数,会造成子类找不到超类的无参构造方法super()来使用,同样会报"Implicit super constructor xxx is undefined for default constructor. Must define an explicit constructor"。

    其实也说明了一个道理,即使我们不写super(),系统会自动的添加一句super(),此例中super()并不存在所以报错了。

    当然,子类不调用超类的有参构造函数super(ParamList)的情况相对较少,所以那本书干脆说必须在第一句写上super(ParamList)。

    ★另外,如果单独注释掉子类中的无参构造函数derived()(不注释warning_su和warning_de),eclipse会说:"The constructor derived() is undefined"。

    也证明了即使是无参构造函数,也是无法继承的。仅仅当超类中只有一个无参构造函数且不打算重写子类构造函数时,为节省工作量,子类构造函数可以不写,java在使用子类的构造函数时,自动添加一句super()来运行。

    展开全文
  • 通常java的构造函数被设置为public的(若你不写构造函数,java自动添加的无参空构造函数就是public的),因本文中的类都在同一个包中,因此使用无修饰的友好权限说明问题,对于private构造函数的意义,可参见这里。...

    转载地址:http://blog.csdn.net/iamluole/article/details/7973174

    问题一:java的构造函数能否被继承?

    笔者初学java看的一本书说:“java的子类自然的继承其超类的“非private成员”。

    通常java的构造函数被设置为public的(若你不写构造函数,java自动添加的无参空构造函数就是public的),因本文中的类都在同一个包中,因此使用无修饰的友好权限说明问题,对于private构造函数的意义,可参见这里

    那么根据该书所述规则,非private的构造函数当然也应该被子类继承。

    但实际上,子类不仅无法继承private成员,也无法继承构造函数。

    下面用代码进行说明。

    示例1.

    系统自动添加的无参空构造函数:(若不写构造函数,java默认添加一个无参的空构造函数)

    class base{
    }
    class derived extends base{
      public static void main(String[] args){
        derived d=new derived();
      }
    }


    示例2.

    把父类中系统自动添加的无参空构造函数显式的写出来(为了有输出,加了println):

    class base{
       base(){
         System.out.println("base constructor");
       }
    }
    class derived extends base{
      public static void main(String[] args){
        derived d=new derived();
      }
    }


    输出结果:base constructor, 代码通过编译。从示例1,2来看,好像子类可以继承超类的构造函数哦。

    但实际情况是:java规则:子类创建对象的同时会先创造父类的对象,因此必须先调用父类的构造方法。示例2中derived没有重写构造方法,根据java规则,系统会默认的添加一个无参的构造方法,且该方法第一句是super()。显式的写出来是:

    derived(){
        super();
    }
    


     那为什么子类可以不写呢,因为:如果父类"只"有无参构造方法,且不打算重写子类的构造方法,为节省代码量,子类构造方法可以不写,系统默认调用父类无参构造方法super()。

    可能还是有人觉得这些示例的说服力不够强,依然认为构造方法是可以继承的,没关系,看完本文,特别是示例4配合最后带★的文字,即可充分说明问题。

    再来看看有参构造方法:

    示例3.

    如果将超类的构造方法改为有参构造方法,代码见下,则eclipse会报"Implicit super constructor xxx is undefined for default constructor. Must define an explicit constructor"

    说明对于超类的有参构造方法,子类是无法继承的。

    class base{
       base(int x){
         System.out.println("base constructor,i="+x);
      }
    }
    class derived extends base{
      public static void main(String[] args){
        derived d=new derived();
      }
    }



    对于有参的构造函数,子类中必须定义自己的构造方法。

    (需要注意参数匹配,将该参数通过第一句的super(ParamList)传给父类的构造方法,若是多层继承,则需要逐级传递参数至最顶层的有参构造方法)

    class base{
       base(int x){
         System.out.println("base constructor,i="+x);
       }
    }
    class derived extends base{
      derived(int x){
        super(x);  //这里使用了super(param),调用了超类的构造方法。
        System.out.println("derived constructor,i="+x);
      }
      public static void main(String[] args){
        derived d=new derived(8);
      }
    }



    输出结果:

    base constructor,i=8

    derived constructor,i=8


    问题二:子类的构造函数可否不使用super(ParamList)调用超类的构造方法?

    上例中使用了super调用了超类的构造方法。同样是那本书中说:“子类的构造方法中必须使用super调用超类的构造方法,且super必须是子类构造方法的第一句。”

    那我不用super行不行呢?原话给人的感觉好像是java的语法规定一样。

    其实可以不用显式的写出super,但前提是“超类中有多个构造方法,且有一个是显式写出的无参的构造方法”。

    示例4.

    超类拥有多个构造方法,其中一个是显式的无参的构造方法。

    class base {
    	base() {                                          //warning_su
    		System.out.println("base constructor.");  //warning_su
    	}                                                 //warning_su
    
    	base(int x) {
    		System.out.println("base constructor,i=" + x);
    	}
    }
    
    class derived extends base {
    	derived() {                                        //warning_de
    		System.out.println("derived constructor"); //warning_de
    	}                                                  //warning_de
    
    	derived(int x) {
    		//super(x);                                //super被注释掉了!
    		System.out.println("derived constructor,i=" + x);
    	}
    
    	public static void main(String[] args) {
              derived d= new derived();                       //warning_cr
              derived t = new derived(8);
    	}
    }

    输出结果:

    base constructor.

    derived constructor

    base constructor.     <---------注意这里没有i=8哦。

    derived constructor,i=8

    此时,子类有参构造方法中没有使用super(x)调用超类的构造方法也通过编译了,但是不使用super(ParamList),new derived(8)调用的是超类的无参构造方法base()!

    为什么要强调必须是“显式写出”的无参构造方法,您可以试试把带有warnning字样的代码注释掉(warning_su,warning_de,waring_cr3处),同时也注释掉super(x)。

    因为此时超类和子类有构造方法(有参的那个),系统不会自动给超类添加无参的空构造函数,会造成子类找不到超类的无参构造方法super()来使用,同样会报"Implicit super constructor xxx is undefined for default constructor. Must define an explicit constructor"。


    其实也说明了一个道理,即使我们不写super(),系统会自动的添加一句super(),此例中super()并不存在所以报错了。

    当然,子类不调用超类的有参构造函数super(ParamList)的情况相对较少,所以那本书干脆说必须在第一句写上super(ParamList)。


    ★另外,如果单独注释掉子类中的无参构造函数derived()(不注释warning_su和warning_de),eclipse会说:"The constructor derived() is undefined"。

    也证明了即使是无参构造函数,也是无法继承的。仅仅当超类中只有一个无参构造函数且不打算重写子类构造函数时,为节省工作量,子类构造函数可以不写,java在使用子类的构造函数时,自动添加一句super()来运行。

    展开全文
  • 通常java的构造函数被设置为public的(若你不写构造函数,java自动添加的无参空构造函数就是public的),因本文中的类都在同一个包中,因此使用无修饰的友好权限说明问题,对于private构造函数的意义,可参见这里。...

    问题一:java的构造函数能否被继承?

    笔者初学java看的一本书说:“java的子类自然的继承其超类的“非private成员”。

    通常java的构造函数被设置为public的(若你不写构造函数,java自动添加的无参空构造函数就是public的),因本文中的类都在同一个包中,因此使用无修饰的友好权限说明问题,对于private构造函数的意义,可参见这里

    那么根据该书所述规则,非private的构造函数当然也应该被子类继承。

    但实际上,子类不仅无法继承private成员,也无法继承构造函数。

    下面用代码进行说明。

    示例1.

    系统自动添加的无参空构造函数:(若不写构造函数,java默认添加一个无参的空构造函数)

     

    [java] view plaincopy
     
    1. class base{  
    2. }  
    3. class derived extends base{  
    4.   public static void main(String[] args){  
    5.     derived d=new derived();  
    6.   }  
    7. }  

    示例2.

    把父类中系统自动添加的无参空构造函数显式的写出来(为了有输出,加了println):

     

    [java] view plaincopy
     
    1. class base{  
    2.    base(){  
    3.      System.out.println("base constructor");  
    4.    }  
    5. }  
    6. class derived extends base{  
    7.   public static void main(String[] args){  
    8.     derived d=new derived();  
    9.   }  
    10. }  
    输出结果:base constructor, 代码通过编译。从示例1,2来看,好像子类可以继承超类的构造函数哦。

    但实际情况是:java规则:子类创建对象的同时会先创造父类的对象,因此必须先调用父类的构造方法。示例2中derived没有重写构造方法,根据java规则,系统会默认的添加一个无参的构造方法,且该方法第一句是super()。显式的写出来是:

    [java] view plaincopy
     
    1. derived(){  
    2.     super();  
    3. }  

     那为什么子类可以不写呢,因为:如果父类"只"有无参构造方法,且不打算重写子类的构造方法,为节省代码量,子类构造方法可以不写,系统默认调用父类无参构造方法super()。

    可能还是有人觉得这些示例的说服力不够强,依然认为构造方法是可以继承的,没关系,看完本文,特别是示例4配合最后带★的文字,即可充分说明问题。

     

     

     

    再来看看有参构造方法:

    示例3.

    如果将超类的构造方法改为有参构造方法,代码见下,则eclipse会报"Implicit super constructor xxx is undefined for default constructor. Must define an explicit constructor"

    说明对于超类的有参构造方法,子类是无法继承的。

     

    [java] view plaincopy
     
    1. class base{  
    2.    base(int x){  
    3.      System.out.println("base constructor,i="+x);  
    4.   }  
    5. }  
    6. class derived extends base{  
    7.   public static void main(String[] args){  
    8.     derived d=new derived();  
    9.   }  
    10. }  

    对于有参的构造函数,子类中必须定义自己的构造方法。

    (需要注意参数匹配,将该参数通过第一句的super(ParamList)传给父类的构造方法,若是多层继承,则需要逐级传递参数至最顶层的有参构造方法)

     

    [java] view plaincopy
     
    1. class base{  
    2.    base(int x){  
    3.      System.out.println("base constructor,i="+x);  
    4.    }  
    5. }  
    6. class derived extends base{  
    7.   derived(int x){  
    8.     super(x);  //这里使用了super(param),调用了超类的构造方法。  
    9.     System.out.println("derived constructor,i="+x);  
    10.   }  
    11.   public static void main(String[] args){  
    12.     derived d=new derived(8);  
    13.   }  
    14. }  
    输出结果:

    base constructor,i=8

    derived constructor,i=8

     

    问题二:子类的构造函数可否不使用super(ParamList)调用超类的构造方法?

    上例中使用了super调用了超类的构造方法。同样是那本书中说:“子类的构造方法中必须使用super调用超类的构造方法,且super必须是子类构造方法的第一句。”

    那我不用super行不行呢?原话给人的感觉好像是java的语法规定一样。

    其实可以不用显式的写出super,但前提是“超类中有多个构造方法,且有一个是显式写出的无参的构造方法”。

    示例4.

    超类拥有多个构造方法,其中一个是显式的无参的构造方法。

     

    [java] view plaincopy
     
    1. class base {  
    2.     base() {                                          //warning_su  
    3.         System.out.println("base constructor.");  //warning_su  
    4.     }                                                 //warning_su  
    5.   
    6.     base(int x) {  
    7.         System.out.println("base constructor,i=" + x);  
    8.     }  
    9. }  
    10.   
    11. class derived extends base {  
    12.     derived() {                                        //warning_de  
    13.         System.out.println("derived constructor"); //warning_de  
    14.     }                                                  //warning_de  
    15.   
    16.     derived(int x) {  
    17.         //super(x);                                //super被注释掉了!  
    18.         System.out.println("derived constructor,i=" + x);  
    19.     }  
    20.   
    21.     public static void main(String[] args) {  
    22.           derived d= new derived();                       //warning_cr  
    23.           derived t = new derived(8);  
    24.     }  
    25. }  
    输出结果:

    base constructor.

    derived constructor

    base constructor.     <---------注意这里没有i=8哦。

    derived constructor,i=8

    此时,子类有参构造方法中没有使用super(x)调用超类的构造方法也通过编译了,但是不使用super(ParamList),new derived(8)调用的是超类的无参构造方法base()!

    为什么要强调必须是“显式写出”的无参构造方法,您可以试试把带有warnning字样的代码注释掉(warning_su,warning_de,waring_cr3处),同时也注释掉super(x)。

    因为此时超类和子类有构造方法(有参的那个),系统不会自动给超类添加无参的空构造函数,会造成子类找不到超类的无参构造方法super()来使用,同样会报"Implicit super constructor xxx is undefined for default constructor. Must define an explicit constructor"。

     

    其实也说明了一个道理,即使我们不写super(),系统会自动的添加一句super(),此例中super()并不存在所以报错了。

    当然,子类不调用超类的有参构造函数super(ParamList)的情况相对较少,所以那本书干脆说必须在第一句写上super(ParamList)。

     

    ★另外,如果单独注释掉子类中的无参构造函数derived()(不注释warning_su和warning_de),eclipse会说:"The constructor derived() is undefined"。

    也证明了即使是无参构造函数,也是无法继承的。仅仅当超类中只有一个无参构造函数且不打算重写子类构造函数时,为节省工作量,子类构造函数可以不写,java在使用子类的构造函数时,自动添加一句super()来运行。

    转载于:https://www.cnblogs.com/lubocsu/p/5117417.html

    展开全文
  • 已经不能从外部调用构造函数了,但是对象必须被构造,应该如何解决,麻烦大家帮忙说明,关于构造,析构函数声明为私有和保护时的用法??? 提出这个问题,说明你已经对c++有所思考了。 从语法上来讲,一个函数被...
  • 构造函数定义为private

    2015-08-12 11:08:07
    已经不能从外部调用构造函数了,但是对象必须被构造,应该如何解决,麻烦大家帮忙说明,关于构造,析构函数声明为私有和保护时的用法???   提出这个问题,说明你已经对c++有所思考了。 从语法上来讲,一个...
    将构造函数,析构函数声明为私有和保护的,那么对象如何创建?
    已经不能从外部调用构造函数了,但是对象必须被构造,应该如何解决,麻烦大家帮忙说明,关于构造,析构函数声明为私有和保护时的用法???
     
    提出这个问题,说明你已经对c++有所思考了。
    
    从语法上来讲,一个函数被声明为protected或者private,那么这个函数就不能从“外部”直接被调用了。
    对于protected的函数,子类的“内部”的其他函数可以调用之。
    而对于private的函数,只能被本类“内部”的其他函数说调用。
    
    语法上就是这么规定的,你肯定也知道的咯。
    那么为什么有时候将构造函数或者析构函数声明为protected的或者private的?
    
    通常使用的场景如下:
    1。如果你不想让外面的用户直接构造一个类(假设这个类的名字为A)的对象,而希望用户只能构造这个类A的子类,那你就可以将类A的构造函数/析构函数声明为protected,而将类A的子类的构造函数/析构函数声明为public。例如:
    class A
    { protected: A(){}
      public: ....
    };
    calss B : public A
    { public: B(){}
      ....
    };
    
    A a; // error
    B b; // ok
    
    2. 如果将构造函数/析构函数声明为private,那只能这个类的“内部”的函数才能构造这个类的对象了。这里所说的“内部”不知道你是否能明白,下面举个例子吧。
    class A
    {
    private:
        A(){  }
        ~A(){ }
    
    public:
        void Instance()//类A的内部的一个函数
        {
            A a;
        }
    };
    上面的代码是能通过编译的。上面代码里的Instance函数就是类A的内部的一个函数。Instance函数体里就构建了一个A的对象。
    但是,这个Instance函数还是不能够被外面调用的。为什么呢?
    如果要调用Instance函数,必须有一个对象被构造出来。但是构造函数被声明为private的了。外部不能直接构造一个对象出来。
    A aObj; // 编译通不过
    aObj.Instance();
    但是,如果Instance是一个static静态函数的话,就可以不需要通过一个对象,而可以直接被调用。如下:class A
    {
    private:
        A():data(10){ cout << "A" << endl; }
        ~A(){ cout << "~A" << endl; }
    
        public:
        static A& Instance()
        {
            static A a;
            return a;
        }
    
        void Print()
        {
            cout << data << endl;
        }
    
    private:
        int data;
    };
    
    A& ra = A::Instance();
    ra.Print();
    
    上面的代码其实是设计模式singleton模式的一个简单的C++代码实现。
    
    
    还有一个情况是:通常将拷贝构造函数和operator=(赋值操作符重载)声明成private,但是没有实现体。
    这个的目的是禁止一个类的外部用户对这个类的对象进行复制动作。
    细节请看《effective C++》里面的一个条款。具体哪个条款不记得了。
    展开全文
  • 已经不能从外部调用构造函数了,但是对象必须被构造,应该如何解决,麻烦大家帮忙说明,关于构造,析构函数声明为私有和保护时的用法??? 提出这个问题,说明你已经对c++有所思考了。 从语法上来讲,一个函数...
  • 已经不能从外部调用构造函数了,但是对象必须被构造,应该如何解决,麻烦大家帮忙说明,关于构造,析构函数声明为私有和保护时的用法??? 提出这个问题,说明你已经对c++有所思考了。 从语法上来讲,一个...
  • 已经不能从外部调用构造函数了,但是对象必须被构造,应该如何解决,麻烦大家帮忙说明,关于构造,析构函数声明为私有和保护时的用法???   提出这个问题,说明你已经对c++有所思考了。 从语法上来讲,一个...
  • 已经不能从外部调用构造函数了,但是对象必须被构造,应该如何解决,麻烦大家帮忙说明,关于构造,析构函数声明为私有和保护时的用法???   提出这个问题,说明你已经对c++有所思考了。 从语法上来讲,一个函数...
  • 已经不能从外部调用构造函数了,但是对象必须被构造,应该如何解决,麻烦大家帮忙说明,关于构造,析构函数声明为私有和保护时的用法, 回答: 从语法上来讲,一个函数被声明为protected或者private,那么...
  • 已经不能从外部调用构造函数了,但是对象必须被构造,应该如何解决,麻烦大家帮忙说明,关于构造,析构函数声明为私有和保护时的用法??? 提出这个问题,说明你已经对c++有所思考了。 从语法上来讲,一个函数被...
  • 已经不能从外部调用构造函数了,但是对象必须被构造,应该如何解决,麻烦大家帮忙说明,关于构造,析构函数声明为私有和保护时的用法???提出这个问题,说明你已经对c++有所思考了。从语法上来讲,一个函数被声明...
  • 已经不能从外部调用构造函数了,但是对象必须被构造,应该如何解决,麻烦大家帮忙说明,关于构造,析构函数声明为私有和保护时的用法??? 从语法上来讲,一个函数被声明为protected或者private,那么这个函数就...
  • 已经不能从外部调用构造函数了,但是对象必须被构造,应该如何解决,麻烦大家帮忙说明,关于构造,析构函数声明为私有和保护时的用法??? 提出这个问题,说明你已经对c++有所思考了。 从语法上来讲,一个函数被...
  • 对于protected的函数子类的“内部”的其他函数可以调用之。 而对于private的函数,只能被本类“内部”的其他函数说调用。 语法上就是这么规定的,你肯定也知道的咯。 那么为什么有时候将构造函...
  • 虚函数:虚函数相当于函数指针,占用四个字节(对于32位),在类中虚函数占用四个...不能将友元函数说明为虚函数,但是虚函数可以是另一个类的友元。 3.析构函数可以是虚函数,但是构造函数不能是虚函数。#inclu...
  • 1,对于子类构造函数说明,下列叙述中错误的是( )。 A子类不能继承父类的无参构造函数。 B子类可以在自己的构造函数中使用super关键字来调用父类的含参数构造函数,但这个调用语句必须是子类构造函数的第一个可...
  •  定义一个类的对象,首先系统已经给这个对象分配了空间,然后会调用构造函数说明:假设存在构造函数)。一个类有多个对象,当程序中调用对象的某个函数时,有可能要访问到这个对象的成员变量。而对于同一个类的每...
  • 1.对于子类构造函数说明,下列叙述中错误的是( )。 子类可以继承父类的构造函数。 子类中调用父类构造函数不可以直接书写父类构造函数,而应该用super();。 用new创建子类的对象时,若子类没有带参构造函数,将...
  • 每日10道JAVA题(20180713)

    千次阅读 2018-07-13 19:18:00
    对于子类构造函数说明,下列叙述中错误的是( )。A.子类不能继承父类的无参构造函数。B.子类可以在自己的构造函数中使用super关键字来调用父类的含参数构造函数,但这个调用语句必须是子类构造函数的第一个可执行...
  • 牛客易错题记录

    2018-12-22 20:40:08
    2.对于子类构造函数说明,下列叙述中错误的是( )。 正确答案: A 你的答案: C (错误) 子类可以继承父类的构造函数。 子类中调用父类构造函数不可以直接书写父类构造函数,而应该用super();。 用new创建子类的...
  • 每日10道JAVA题(20180712)

    千次阅读 2018-07-12 15:00:53
    对于子类构造函数说明,下列叙述中错误的是( )。A.子类可以继承父类的构造函数。B.子类中调用父类构造函数不可以直接书写父类构造函数,而应该用super();。C.用new创建子类的对象时,若子类没有带参构造函...

空空如也

空空如也

1 2 3 4
收藏数 63
精华内容 25
关键字:

对于子类构造函数说明