java - 关于基类和派生类的实现问题

Question

我有一个关于实现此目的的最佳方法的问题。我将描述我当前的实现以及我似乎如何将自己逼入绝境:

我有一个名为 Package 的抽象类:

public abstract class Package {
    protected String description;
    protected String packagingCode;
    protected Dimension dimensions;
    protected Weight weight;

    protected Package() {
        this.description = null;
        this.packagingCode = null;
        this.dimensions = null;
        this.weight = null;
    }

    protected Package(String description, String packagingCode, Dimension dimensions, Weight weight) throws ShippingException {
        this.description = description;
        this.packagingCode = packagingCode;
        this.dimensions = dimensions;
        this.weight = weight;

        String exceptionMessage = "";

        if(!meetsWeightRequirements()) {
            exceptionMessage = "This package's weight exceeds limits. ";
        }

        if(!meetsDimensionalRequirements()) {
            exceptionMessage += "This package's dimensions exceed limits.";
        }

        if(!StringUtils.isEmpty(exceptionMessage)) {
            throw new ShippingException(exceptionMessage);
        }
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public String getPackagingCode() {
        return packagingCode;
    }

    public void setPackagingCode(String packagingCode) {
        this.packagingCode = packagingCode;
    }

    public Dimension getPackageDimensions() {
        return dimensions;
    }

    public void setPackageDimensions(Dimension dimensions) throws ShippingException {
        this.dimensions = dimensions;

        if(!meetsDimensionalRequirements()) {
            this.dimensions = null;
            throw new ShippingException("This package's dimensions exceed limits.");
        }
    }

    public Weight getPackageWeight() {
        return weight;
    }

    public void setPackageWeight(Weight weight) throws ShippingException {
        this.weight = weight;

        if(!meetsWeightRequirements()) {
            this.weight = null;
            throw new ShippingException("This package's weight exceeds limits.");
        }
    }


    public abstract boolean meetsWeightRequirements();

    public abstract boolean meetsDimensionalRequirements();
}

然后我有类扩展这个抽象类，如下所示:

public class WeightBasedPackage extends Package {

    public boolean meetsWeightRequirements() {
        Weight weight = this.getPackageWeight();
        boolean meetsRequirements = false;

        if(weight != null) {
            meetsRequirements = (weight.getWeight() > 0);
        }

        return meetsRequirements;
    }

    public boolean meetsDimensionalRequirements() {
        return true;
    }
}

我有另一个对象 ( ShipRequest )，它维护包列表 ( List<Package> )。我还有一个使用此对象并可以访问此包列表的服务(例如 WeightBasedPackageShipService )。这个实现工作得很好，因为服务并不真正关心它是什么类型的包。这些包之间的唯一区别是它们实现抽象方法的方式。

现在问题就来了。我创建了一个新类:

public class OrderQuantityPackage extends Package {

    int quantity;

    public OrderQuantityPackage() {
        super();
    }

    public void setQuantity(int quantity) {
        this.quantity = quantity;
    }

    public int getQuantity() {
        return this.quantity;
    }

    public boolean meetsWeightRequirements() {
        return true;
    }

    public boolean meetsDimensionalRequirements() {
        return true;
    }
}

其中有 quantity field 。我需要访问服务中的此字段( OrderQuantityPackageShipService )。但是，由于它的类型是 Package我必须转换它(看起来有点笨拙)。

我的问题是，如何以更好的方式实现这一点(这样我就不必强制转换)并确保类型安全(这样如果您使用 OrderQuantityPackageShipService ，包必须是 OrderQuantityPackage 类型)。我考虑过使用泛型，但对于我想要做的事情来说似乎有点困惑( ShipRequest 有一堆其他属性，并且根据包的类型对其进行泛型似乎很奇怪)。

谢谢。

Answer 1

public abstract class Package {
    protected String description;  // These shouldn't be private fields instead of protected?
    protected String packagingCode; // Nah, I don't think so, otherwise how could I store a value into the Quantity field? =P 
    protected Dimension dimensions;  
    protected Weight weight;  
    protected int quantity;

    // Constructors, getters and setters...

    public virtual int getQuantity {
        throw new NotImplementedException();
    }

    public virtual int setQuantity(int quantity) {
        throw new NotImplementedException();
    }
}

public final class OrderQuantityPackage extends Package {
    public override int getQuantity {
        return super.quantity;
    }

    public override void setQuantity(int quantity) {
        super.quantity = quantity;
    }
}

虽然我不完全确定语法，也不完全确定 NotImplementedException，但我希望您能明白。因此，任何需要数量的 Package 派生类都可以通过重写 Quantity 属性的 getter 和 setter 来实现。

在不需要 Quantity 的地方不应引发任何异常，不应调用它，因此不应引发任何异常。此外，它证明您的模型仅在时机成熟时执行所需的操作。

除此之外，OrderQuantityShipService 不应该需要 OrderQuantityPackage 中的 Weight 属性，并且正如 Vivin 所写，无论如何都可以访问重量。

否则，您的服务中的简单转换就可以做到这一点。使用类型转换并不是一种肮脏的方式。例如，必须将事件处理程序中的发送者对象转换为他希望检查名称、状态或其他属性值的正确控件类型!然后把最一般的一类传给 Activity ，必须投...而且这个，那个不是我说选择这样的，他们是软件工程师!...

编辑 Vivin，如何在 JAVA 中从一种数据类型转换为另一种数据类型，就像在 C/C++/C# 中一样吗？

CastedType variable = (CastedType)TypeCast;