//如果父类有 带 参数 的构造函数
//那么子类 一定要在构造函数 中显示的调用父类的构造函数
//super(...);
//是否一定这样的,如果遇到下边的情况,怎么办呢public class parent {
public int i=0; //为了方便,写成 public 了
public int j=0; // 定义一个 int j
public parent(int i,int j){
this.i = i;
this.j = 2*j; // 父类构造函数把 j 定义成 参数的 两倍
}
}//--------------public class child extends parent{
child(int j){ // 想在子类的构造函数中把 j 定义成参数 的三倍.
super(i,j*1.5); //这样作 是不可以的,因为 j 不是 double 的,怎么办呢
}
public void printi(){
System.out.println (i);
}
}
//感觉总用 super 调用 太笨了点
//这个只是我随便想到的一个情况来试验一下,请 达人 指点
//那么子类 一定要在构造函数 中显示的调用父类的构造函数
//super(...);
//是否一定这样的,如果遇到下边的情况,怎么办呢public class parent {
public int i=0; //为了方便,写成 public 了
public int j=0; // 定义一个 int j
public parent(int i,int j){
this.i = i;
this.j = 2*j; // 父类构造函数把 j 定义成 参数的 两倍
}
}//--------------public class child extends parent{
child(int j){ // 想在子类的构造函数中把 j 定义成参数 的三倍.
super(i,j*1.5); //这样作 是不可以的,因为 j 不是 double 的,怎么办呢
}
public void printi(){
System.out.println (i);
}
}
//感觉总用 super 调用 太笨了点
//这个只是我随便想到的一个情况来试验一下,请 达人 指点
child(int j){
super(i,j);
j=j*1.5;
}
public void printi(){
System.out.println (i);
}
}
注意：如果你不显示的调用的话，那么它会自动调用父类的默认构造函数，显然你的父类没有默认构造函数，此时会出错。
但是既然调用了super,super就肯定会对子类里边的元素有影响
有时候 根本就不想用父类构造函数里的东西,
一切都在子类构造函数里完成,这样多好
public static int i=0; //为了方便,写成 public 了
public static double j=0;
//public static int l=0; // 定义一个 int j
public Parent(int i,double j){
this.i = i;
this.j = 2*j; // 父类构造函数把 j 定义成 参数的 两倍
}
}//--------------class Child extends Parent{
Child(int j){ // 想在子类的构造函数中把 j 定义成参数 的三倍.
super(i,j*1.5); //这样作 是不可以的,因为 j 不是 double 的,怎么办呢
}
public static void main(String[] args){
Child x = new Child(5);
System.out.println(j);
}}
这样就可以了 !
是啊,要显示的调用,
但是既然调用了super,super就肯定会对子类里边的元素有影响
有时候 根本就不想用父类构造函数里的东西,
一切都在子类构造函数里完成,这样多好
------------------------------------------------------------
TO gutou9(骨头):
请原谅我的冒昧，不过我认为楼主提出这样的问题，可能有以下两个原因
1. 对对象的初始化不够熟悉
2. 对继承机制理解不够
这里之所以需要显示的调用super(ParamName ParamValue)，是因为由于child inherit parent，所以当初始化child object时，必须首先拥有一个对parent object的引用（而无论你的程序实现中是否需要在child中使用继承自parent的methods or fields）。
如果，您是对继承机制不够熟悉，所以认为child中从头到尾根本不需要使用继承自parent的东西，那请您自问您选择继承的原始动机是什么？（好玩 or 实验？）
如果您的疑问出自，希望在初始化时可以直接调用default constructor而不是显式的调用那些parent中的构造函数，那么您就是对对象的初始化不够理解，以下的代码可以说明，为什么必须显式的调用带有参数的constructor，代码如下： interface Initialized {} class Initialize1 implements Initialized {
// 自动拥有一个default constructor,
// 形式如同 public Initialize1 {},
// 当初始化该类的对象时，系统自动调用默认构造函数。
} class Initialize2 implements Initialized {
// 显式地实现默认构造函数。
public Initialize2() { }
} class Initialize3 implements Initialized {
// 没有默认构造函数，
// 系统也不会自动赋予一个默认构造函数，
// 初始化该对象时，必须显式地调用以下带参数的构造函数。
public Initialize3(int nondefault) {}
} class TestInitialized {
public static void main(String[] args) {
Initialized instance = null; // Right, beacuse default constructor will be called,
// while a object is initialized.
instance = new Initialize1(); // Right, beacuse this class has a obvious default constructor,
// and it will be called, while a object is initialized.
instance = new Initialize2();
// That's wrong, beacuse this class doesn't have a default constructor.
// instance = new Initialize3(); // Don't do this.
// If you want to initialize a object by Initialize3 class
// you must call constructor [Initialized3(int nondefault)]
instance = new Initialize3(1); // Right
}
} 正如你所看到的，如果你不给类定义任何constructor，那么系统将会自动分配一个默认构造函数，这样在继承自该类的所有子对象中，即使不显式地调用super()构造函数，系统也会默认调用，但是如果在类中已经定义了任何形式的构造函数，系统便不会自动添加默认构造函数，这样在初始化该类的对象时，就必须显式的调用该类自定义的构造函数。
如果你了解了对象的初始化机制，同时也明白初始化一个child object，必然要拥有一个对parent object的引用（否则，当我需要使用继承下来的fields or methods时，如何映射到这些东西呢？），那么以上的问题就可迎刃而解了。@.@||~