5

我有一个 Sport 基类，它有几个变量。我还有一些从 Sport 派生的不同类，例如 Volleyball、Soccer 等，它们具有额外的方法和变量。它们看起来有点像这样。

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) { }

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

4

5 回答 5

5

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

public otherFunction(int one, int two, Sport sport)
{
    if(sport instanceof Volleyball)
    {
        Volleyball volley = (Volleyball) sport;
        //Do Volleyball things
    }
    else
    {
        //Only do sport things.
    }
}
于 2012-12-20T22:03:25.790 回答
4

你不应该。如果该函数要与抽象 Sport 一起使用，那么它所需的所有信息都应该在 Sport 中可用。否则，您应该真正为每个功能（或策略/处理程序或类似）。

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

instanceof不过，您可以通过检查然后强制转换来做到这一点：

if (sport instanceof Volleyball) {
  Volleyball v = (Volleyball)sport;
}
于 2012-12-20T22:01:30.283 回答
1

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

同时，考虑到您的帖子，我认为您正在尝试混合不同的职责，它们是：

  1. 处理 Sport 实例。
  2. 处理 Sport 实例的衍生物。

这可能意味着您的方法根本不需要 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)

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

于 2012-12-20T22:57:57.430 回答
0

答案是，你不能。您需要向基类添加成员，可能是抽象方法，例如 getTypeOfSport()。

于 2012-12-20T22:00:54.810 回答
0

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

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 */ }
}
于 2012-12-20T22:18:47.250 回答