扩展

Question

我正在尝试编写一个扩展另一个抽象类的抽象类。超类是Expression：

public abstract class Expression {
    String expression;

    /*Empty Constructor for Expression object */
    public Expression(){
    }

    /*Constructor for Expression object with String expression*/
    public Expression(String expression){
        this.expression = new String(expression);
    }

并且extends类是CompoundExpression，其中包含两个类型为Expression的变量：

public abstract class CompoundExpression extends Expression {
    Expression firstOperand, secondOperand;

    public CompoundExpression(Expression first, Expression second){
        String strFirst = first.expression;
        String strSecond = second.expression;

        this.firstOperand = super(strFirst);
        this.secondOperand = super(strSecond);
    }
}

我认为我这样做是错误的，因为它不起作用......有人可以帮我理解为什么吗？我怎么能以正确的方式做到这一点？

我想也许这样写：

public abstract class CompoundExpression extends Expression {

    Expression firstOperand, secondOperand;

    public CompoundExpression(Expression first, Expression second){

        this.firstOperand.expression = first.expression;
        this.secondOperand.expression = second.expression;
    }
}

您怎么看？

Answer 1

您传递给Expression的构造函数的CompoundExpression对象已经创建。没有必要调用父构造函数（实际上，那个地方非法）。

替换

this.firstOperand = super(strFirst);
this.secondOperand = super(strSecond);

简单地通过

this.firstOperand = first;
this.secondOperand = second;

另一种可能性是在此构造函数中构造Expression个对象。那么你不需要传递Expression但只需要字符串：

public CompoundExpression(String strFirst, String strSecond){
    this.firstOperand = new Expression(strFirst);
    this.secondOperand = new Expression(strSecond);
}

这完全取决于你想要实现的目标。

Answer 2

在这种情况下，您似乎都是封装和扩展。两者都是合理的事情，但这是两者中的混合物。你想要哪一个取决于你的具体用例，所以我将解释两个

扩展

这是父子关系。在这种情况下，孩子是父母。比如猫是一个mammel。这将实现如下

public abstract class CompoundExpression extends Expression {


    public CompoundExpression(String first){
        super(first);
    }

    //Other methods that make this class different from the parent class
}

封装

这是一个＆＃34;有一个＆＃34;关系。例如，一只猫有一个＆＃34;腿。在这种情况下，您不需要使用＆＃34; extends＆＃34;关键字

public abstract class CompoundExpression{

    Expression firstOperand, secondOperand;

    public CompoundExpression(Expression first, Expression second){

        this.firstOperand = first;
        this.secondOperand = second;
    }

    //other methods to use the encapsulated Expressions
}

扩展和封装同一个类

这有其用途，但远不如上述两种;你需要非常小心，但正如你所提到的，你可以扩展一个类并封装一个或多个该类。对此的类比可能是一只雌猫同时是一只猫并且可以包含猫（以小猫的形式）。当这样做时，总是表现得好像是巧合＆＃34;你封装的类和你扩展的类是相同的

这将如下

public abstract class CompoundExpression extends Expression{

    Expression firstOperand, secondOperand;

    public CompoundExpression(String myString, Expression first, Expression second){

        super(myString);
        this.firstOperand = first;
        this.secondOperand = second;
    }

    //other methods to make this class unique

}

正如我所说，我个人从来没有这样做过，不应该被视为＆＃34;默认＆＃34;封装的方式。在做这个之前确保你真的知道你在做什么

结论

鉴于单个CompoundExpression包含2个单独的表达式，我怀疑你想要一个封装关系

Answer 3

你不能这样做：

this.firstOperand = super(strFirst);
this.secondOperand = super(strSecond);

你正在通过super调用构造函数（这是不可能的，因为super应该永远是第一个）并且你试图直接使用抽象类的构造函数，这也是不可能的。

你需要做的是，有一个非抽象的类将实现“Expression”，然后只需调用它：

this.firstOperand = new ExpressionImpl(strFirst);
this.secondOperand = new ExpressionImpl(strSecond);

同样，在这种情况下，您不需要在CompoundExpression类中扩展Expression。

祝你好运！

Answer 4

我看到你有点混乱。扩展是一回事。我想你想要的是另一个。这是扩展名：

public class Point2D {
    int x;
    int y;

    public Point2D(int x, int y) {
        this.x = x;
        this.y = y;
    }


    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }

}

班级Point3D正在扩展前一个

public class Point3D extends Point2D{

    int z;

    public Point3D(int z, int x, int y) {
        super(x, y);
        this.z = z;
    }

    public int getZ() {
        return z;
    }

    public void setZ(int z) {
        this.z = z;
    }

}

您只需要一个简单的POJO，它使用您之前定义的Expression类。只不过它，只是封装你定义的类型..

public abstract class CompoundExpression{

    Expression firstOperand, secondOperand;

    public CompoundExpression(Expression first, Expression second){

        this.firstOperand = new Expression(strFirst);
        this.secondOperand = new Expression(strSecond);
    }
}

在Java中使用两个超类参数扩展类

4 个答案:

扩展

封装

扩展和封装同一个类

结论