关于继承：Java – 具有相同方法的不同对象的数组


Java - array of different objects that have the same method(s)

我在练习继承。

我有两个类似的类，我想把它们同化到一个数组中，所以我想用对象类作为超类，因为所有的东西都是对象的子类。

例如，我将t类和ct类放入一个名为all like so的数组中：

1
2
3
4
5
6
7
8
9
10
11
12
13
 Object all[] = new Object[6];

    all[0] = T1;

    all[1] = CT2;

    all[2] =T3;

    all[3] = CT1;

    all[4] = T2;

    all[5] = CT3;

我跳过了声明，因为这不是我的问题。

当我希望使用循环调用数组中的函数时，我的真正问题是：

1
2
3
4
for (int i = 0; i < 6; i++) {

    all[i].beingShot(randomNum, randomNum, AK47.getAccuracy());
}

分别涉及t和ct的类都有beingshot方法，这是公共的。

Eclipse建议将其作为快速修复。我在想，除了创建自己的对象类来保存beingshot方法，或者将其添加到对象类之外，是否还有其他逻辑选择，尽管从长远来看，这些选择中的任何一个都会导致更多的问题。

谢谢！

相关讨论

如果两个类都实现相同的方法，那么您应该考虑创建一个Interface。

接口功能强大，易于使用。

您可以调用接口Shootable。

您可以创建一个实现可拍摄的不同对象的数组，并对它们进行相同的处理。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
// Define a VERY simple interface with one method.

interface Shootable {
    public void beingShot();
}

// Any class that implements this interface can be treated interchangeably

class Revolver implements Shootable {
    public void beingShot() {
        System.out.println("Revolver: firing 1 round");
}

class MachineGun implements Shootable {
    public void beingShot() {
        System.out.println("Machine Gun: firing 50 rounds");
    }
}

class HockeyPuck implements Shootable {
    public void beingShot() {
        System.out.println("Hockey Puck: 80 MPH slapshot");
    }
}

class RayBourquePuck implements Shootable {
    public void beingShot() {
        System.out.println("Hockey Puck: 110 MPH slapshot");
    }
}

class OunceOfWhiskey implements Shootable {
    public void beingShot() {
        System.out.println("Whiskey Shot: 1 oz down the hatch...");
    }
}

// You can declare an array of objects that implement Shootable

Shootable[] shooters = new Shootable[4];

// You can store any Shootable object in your array:

shooters[0] = new MachineGun();
shooters[1] = new Revolver();
shooters[2] = new HockeyPuck();
shooters[3] = new OunceOfWhiskey();

// A Shootable object can reference any item from the array

Shootable anyShootableItem;

// The same object can to refer to a MachineGun OR a HockeyPuck

anyShootableItem = shooters[0];
anyShootableItem.beingShot();

anyShootableItem = shooters[2];
anyShootableItem.beingShot();

// You can call beingShot on any item from the array without casting

shooters[0].beingShot();
shooters[1].beingShot();

// Let's shoot each object for fun:

for (Shootable s : shooters) {
    s.beingShot();
}

这是一个很好的相关问题和答案。

相关讨论

您需要将您的object引用类型化为适当的类来调用它们的方法。

对于从您的array中获取的每个引用，您需要使用instanceof运算符进行检查，其中，instanceof运算符是您的对象引用所引用的实例。因此，您可以将该类的引用类型化。

但是打字是一件很难看的事情。你应该尽量避免。如果您必须根据精确的子类选择要调用的方法，那么您可能应该使用Interface。这是你在这里实现你想要的最好方式…

我认为你已经掌握了足够的关于如何实现它的信息。

相关讨论

对象没有Beingshot方法。如果数组中的所有对象都属于同一类，那么数组应该属于同一类。否则，它们都应该实现相同的接口或扩展相同的类。我无法想象为什么要在这里显式扩展对象，它不添加任何功能。

相关讨论

你不能这么做……因为Java不支持扩展方法。(C)

阅读以下链接：

等价于C扩展方法的Java语言