java以超类作为参数在子类中创建构造函数

我想在Java中执行类似的操作：

超类：

public class mysupclass {

    public mysupclass(int x, int y) {
       // code here
    }
}

public class mysupclass {

    public mysupclass(int x, int y) {
       // code here
    }
}

子类：

public class mysubclass extends mysupclass {

    public mysubclass (mysupclass a, mysupclass b) {
        // code here
    }
}

public class mysubclass extends mysupclass {

    public mysubclass () {
        super(mysupclass a, mysupclass b);
        // code here
    }
}

public class mysubclass extends mysupclass {

    public mysubclass (mysupclass a, mysupclass b) {
         //call to constructor of superclass
         mysupclass(a,b);
        // code here
    }
}

如何将mysupclass定义为子类构造函数的参数？

---

我必须在子类构造函数中使用super吗？我应该在super中添加什么？

作为一个好的一般规则，超类应该永远不知道子类

---

考虑重新设计类层次结构，或者使用抽象，例如实现接口的子类和该接口实例中所需的超类。

作为一个好的一般规则，超类应该永远不知道子类

---

考虑重新设计类层次结构，或使用抽象，例如实现接口的子类和该接口实例中所需的超类。

您肯定需要使用

super

来调用超类构造函数，但您想要使用的参数取决于您自己。我们不知道这些课程的目的是什么

---

就Java而言，子类构造函数具有超类类型的参数这一事实基本上是无关的——这只是巧合。您需要遵循Java的所有常规规则，在本例中，这意味着链接到超类构造函数。由于在超类中没有无参数构造函数，因此必须显式地执行此操作，为

x

和

y

提供值，您肯定需要使用

super

来调用超类构造函数，但要使用的参数取决于您自己。我们不知道这些课程的目的是什么

---

就Java而言，子类构造函数具有超类类型的参数这一事实基本上是无关的——这只是巧合。您需要遵循Java的所有常规规则，在本例中，这意味着链接到超类构造函数。由于在超类中没有无参数构造函数，因此必须显式地执行此操作，为

x

和

y

提供值，您可能需要在中添加默认构造函数，正如一般编码实践所说，如果您正在重载默认构造函数，那么您应该自己添加它。 在继续之前，您可能需要对java构造函数进行一些研究

高级：

public class mysupclass {

    public mysupclass(int x, int y) {
       // code here
       // Overloaded constructor.
    }
}

子类：

public class mysubclass extends mysupclass {

    public mysubclass (mysupclass a, mysupclass b) {
        // code here
    }
}

public class mysubclass extends mysupclass {

    public mysubclass () {
        super(mysupclass a, mysupclass b);
        // code here
    }
}

public class mysubclass extends mysupclass {

    public mysubclass (mysupclass a, mysupclass b) {
         //call to constructor of superclass
         mysupclass(a,b);
        // code here
    }
}

---

您可能希望在中添加一个默认构造函数，正如一般编码实践所说，如果您正在重载默认构造函数，那么您应该自己将其添加回中。 在继续之前，您可能需要对java构造函数进行一些研究

高级：

public class mysupclass {

    public mysupclass(int x, int y) {
       // code here
       // Overloaded constructor.
    }
}

子类：

public class mysubclass extends mysupclass {

    public mysubclass (mysupclass a, mysupclass b) {
        // code here
    }
}

public class mysubclass extends mysupclass {

    public mysubclass () {
        super(mysupclass a, mysupclass b);
        // code here
    }
}

public class mysubclass extends mysupclass {

    public mysubclass (mysupclass a, mysupclass b) {
         //call to constructor of superclass
         mysupclass(a,b);
        // code here
    }
}

---

我想你应该考虑编辑你的问题，并给出更多的细节：<代码> MySubase/COD>代表上下文。正如其他人已经解释过的，你试图把一个<代码> MySubase/Cube >作为MySuxCube的参数，它实际上期望一个<代码> int 值作为参数。一个

int值

到mysupclass的构造函数该类不能被实例化为提供参数化构造函数的u r，并且它不会调用默认构造函数。请详细说明您的要求是什么？我的意思是，通过将这些

mysupclass

作为参数传递，您想做什么？因为使用

super.variable=value设置要传递到构造函数中的变量会更容易而不是直接通过<代码> MySubase/Cube >作为参数。
 < P>我认为u SUD考虑编辑UR问题并给出更多的细节：<代码> MySubase/COD>在上下文中表示。需要一个
int
值作为参数。显然，如果不将
int值
传递给mysupclass的构造函数，则该类不能实例化为提供参数化构造函数的u r，并且它不会调用默认构造函数。请详细说明您的要求是什么？我的意思是，通过将这些
mysupclass
作为参数传递，您想做什么？因为使用
super.variable=value设置要传递到构造函数中的变量会更容易
而是直接将
mysupclass
作为参数传递。
参考：

解决方案如下：

超类：

public class mysupclass {

    public mysupclass(int x, int y) {
       // code here
    }
}

public class mysupclass {

    public mysupclass(int x, int y) {
       // code here
    }
}

子类：

public class mysubclass extends mysupclass {

    public mysubclass (mysupclass a, mysupclass b) {
        // code here
    }
}

public class mysubclass extends mysupclass {

    public mysubclass () {
        super(mysupclass a, mysupclass b);
        // code here
    }
}

public class mysubclass extends mysupclass {

    public mysubclass (mysupclass a, mysupclass b) {
         //call to constructor of superclass
         mysupclass(a,b);
        // code here
    }
}

你的参考资料：

解决方案如下：

超类：

public class mysupclass {

    public mysupclass(int x, int y) {
       // code here
    }
}

public class mysupclass {

    public mysupclass(int x, int y) {
       // code here
    }
}

子类：

public class mysubclass extends mysupclass {

    public mysubclass (mysupclass a, mysupclass b) {
        // code here
    }
}

public class mysubclass extends mysupclass {

    public mysubclass () {
        super(mysupclass a, mysupclass b);
        // code here
    }
}

public class mysubclass extends mysupclass {

    public mysubclass (mysupclass a, mysupclass b) {
         //call to constructor of superclass
         mysupclass(a,b);
        // code here
    }
}

下面是一个如何做到这一点的示例：

超类（Point2D.java）：

package test\u superArg；
公共类Point2D{
私人浮动x；
私人游船；
公共点2D（浮点x、浮点y）{
这个.x=x；
这个。y=y；
System.out.println（“父类构造函数：”）；
System.out.println（“X=“+this.X+”，Y=“+this.Y”）；
}
公共浮点getX（）{return x；}
公共浮点getY（）{return y；}
公共void setX（float x）{this.x=x；}
public void setY（float y）{this.y=y；}
}

子类（Point3D.java）：

package test\u superArg；
公共类Point3D扩展了Point2D{
私有浮动z；
公共点3D（点2D点2D，浮点z）{
super（point2d.getX（），point2d.getY（））；//必须是构造函数中的第一条语句
System.out.println（“调用super（）后”）；
这个。z=z；
System.out.println（“子类构造函数：”）；
System.out.println（“X=“+getX（）+”，Y=“+getY（）+”，Z=“+this.Z”）；
}
公共浮点getZ（）{return z；}
}

主类（Start.java）：

package test\u superArg；
公开课开始{
公共静态void main（字符串[]args）{
System.out.println（“创建父类型类对象…”）；
Point2D Point2D=新的Point2D（2.0f，4.0f）；
System.out.println（“创建子类型类对象…”）；
点3D点3D=