Question

我有一个Sport基类，它有几个变量。我还有一些来自运动的不同类别，如排球，足球等，有其他方法和变量。他们看起来有点像这样。

public class Sport {
    public String commonVar;
    public Sport(String c) {
        this.commonVar = c;
    }
}

然后排球：

public class Volleyball extends Sport {
    public String onlyVolleyball;
    public Volleyball(String c, String thisVar) {
        super(c);
        this.onlyVolleyball = thisVar;
    }
}

现在我想将Sport的派生类传递给其他地方的函数，但是制作参数

public otherFunction(int one, int two, Sport sport) { }

仅将运动视为运动对象（它将接受派生类，但我无法访问Sport不常见的任何变量和方法）。我的问题是如何创建一个能够在不丢失任何数据的情况下发送所有类型的体育衍生产品的功能？

Answer 1

你不能，但你可以检查对象是否实际上是扩展类的成员，然后转换它并使用它，如下所示：

public otherFunction(int one, int two, Sport sport)
{
    if(sport instanceof Volleyball)
    {
        Volleyball volley = (Volleyball) sport;
        //Do Volleyball things
    }
    else
    {
        //Only do sport things.
    }
}

Answer 2

你不应该。如果该功能适用于抽象运动，那么它所需的所有信息都应该在Sport中提供。否则，你应该为每个人提供功能（或策略/处理程序或类似功能）。

您正在以面向对象原则打破开放封闭原则（SOLID中的O）。

你可以这样做，用instanceof检查，然后施放：

if (sport instanceof Volleyball) {
  Volleyball v = (Volleyball)sport;
}

Answer 3

基本上，解决问题取决于你真正想要实现的目标。

同时，考虑到你的帖子，在我看来你试图混合不同的职责，这些职责是：

处理体育实例。
处理体育实例的衍生物。

这可能意味着您的方法根本不需要Sport实例。它实际需要的是获得特定的运动。如果我错了，请纠正我。

因此，最简单的解决方案是声明otherFunction，如下所示：

public otherFunction(int one, int two, VolleyBall sport)
public otherFunction(int one, int two, Soccer sport)
public otherFunction(int one, int two, BasketBall sport)
public otherFunction(int one, int two, AnyOtherAwsomeSport sport)

通过这种方式，您可以清楚地了解您的功能正在处理什么样的运动而且你有非常清晰的界面，易于理解和维护。

Answer 4

答案是，你做不到。您需要将成员（可能是抽象方法，例如getTypeOfSport（））添加到基类中。

Answer 5

你正在处理“表达问题”;很难解决。你可以做的一件事是：

public interface SportFunction {
    void doChessFunction(Chess sport);
    void doVolleyballFunction(Volleyball sport);
}

public abstract class Sport {
    public String commonVar;
    public Sport(String c) {
        this.commonVar = c;
    }
    public abstract void doSportFunction(SportFunction function);
}

public class Volleyball extends Sport {
    public String onlyVolleyball;
    public Volleyball(String c, String thisVar) {
        super(c);
        this.onlyVolleyball = thisVar;
    }

    public void doSportFunction(SportFunction function) {
        function.doVolleyballFunction(this);
    }
}

public class Chess extends Sport {
    public int onlyChess;
    public Chess(String c, int thisVar) {
        super(c);
        this.onlyChess = thisVar;
    }

    public void doSportFunction(SportFunction function) {
        function.doChessFunction(this);
    }
}

然后使用这样的类：

public void otherFunction(int one, int two, Sport sport) {
   sport.doSportFunction(new OtherSportFunction(one, two));
}

public class OtherSportFunction implements SportFunction {
   public OtherSportFunction(int one, int two) { /* do stuff */ }
   public void doChessFunction(Chess sport) { /* do chess stuff */ }
   public void doVolleyballFunction(Volleyball sport) { /* do volleyball stuff */ }
}

如何将派生类传递给接受父类型的函数

5 个答案: