[英]subclass elements from an arraylist won't use the overriden method in Java
我有一个带有特定类（Piece）的ArrayList，我想从中选择带有子类（矿工和炸弹）的物品。 但是，当我选择一些项目时，它将使用超类（Piece）的方法，而不是其子类。
由于ArrayList<Pieces>将包含片段的几个子类对象，因此无法为ArrayList定义更具体的类。 是否有可能从ArrayList中选择一些元素并仍使用子类中的方法？
（我发现很难找到解决此简单问题的方法。我搜索了覆盖，arrayList，方法以及其他内容，但找不到它。如果发现太明显了，我想知道找到的地方。）
主班：
import java.util.ArrayList;
public class Main {
public static void main(String[] args) {
ArrayList<Piece> pieceList = new ArrayList<>();
pieceList.add(new Miner());
pieceList.add(new Bomb());
// create new classes to test canDefeat
if (new Miner().canDefeat(new Bomb())) {
System.out.println("Yes! This line will be printed.");
}
System.out.println();
// test canDefeat with pieces from the pieceList
if (pieceList.get(0).canDefeat(pieceList.get(1))) {
System.out.println("No, this line will not be printed");
}
}
}
课件：
public abstract class Piece {
public boolean canDefeat(Piece opponent) {
return false;
}
}
类矿工：
public class Miner extends Piece {
public boolean canDefeat(Bomb opponent) {
return true;
}
}
类炸弹：
public class Bomb extends Piece {
}
为什么这样很容易：
你的Miner不会覆盖canDefeat(Piece) ，而是添加一个签名为canDefeat(Bomb)的新方法。
在代码pieceList.get(0).canDefeat(pieceList.get(1)) ，所有编译器需要使用的是Piece类型，因此它将其解析为Piece#canDefeat(Piece) 。
该怎么办却比较棘手。
我建议，哪些类型的作品可以击败其他类型的作品，但这并不是每个作品的属性； 一方面，如果您更改规则，那将很快变得脆弱。
相反，我会看一下类似的替代方案：
也许每个棋子都有一定的强度等级，较高的力量意味着棋子可以击败强度较低的棋子。 （下面的示例。）
您可以拥有一个BattleLogic类，该类可以比较碎片的类型以确定结果，这可以根据上述强度来工作，或者可以使用instanceof等按类型进行工作。通常，当到达instanceof您需要停下来思考一下您正在做的事情，以及它是否真的是这项工作的正确工具（通常不是），但这很可能是这项工作的正确工具。 BattleLogic类的优点是，所有组件都不了解其他组件。 取而代之的是，您有一件事可以从整体上了解游戏，以及在战斗时各部分的排名。 （下面的示例。）
如果您希望每个Piece都知道它还能击败哪些其他类型的棋子，那么您可以这样做，但是我认为这将导致无法维持的混乱局面。 我想到两种方法：
列出可以打败的类型。 （下面的示例。）
使用反射来实现您最初尝试做的事情。 （下面的示例。）
这是代码中的强度建议：
import java.util.ArrayList;
class Piece {
private int strength;
public Piece(int strength) {
this.strength = strength;
}
public int getStrength() {
return this.strength;
}
public boolean canDefeat(Piece opponent) {
return this.getStrength() > opponent.getStrength();
}
}
class Miner extends Piece {
public Miner() {
super(10);
}
}
class Bomb extends Piece {
public Bomb() {
super(5);
}
}
public class Main {
public static void main(String[] args) {
ArrayList<Piece> pieceList = new ArrayList<>();
pieceList.add(new Miner());
pieceList.add(new Bomb());
// create new classes to test canDefeat
if (new Miner().canDefeat(new Bomb())) {
System.out.println("Yes! This line will be printed.");
}
System.out.println();
// test canDefeat with pieces from the pieceList
if (pieceList.get(0).canDefeat(pieceList.get(1))) {
System.out.println("Yes! This line will also be printed");
}
}
}
以及代码中的BattleLogic建议：
import java.util.ArrayList;
abstract class Piece {
}
class Miner extends Piece {
}
class Bomb extends Piece {
}
class BattleLogic {
/**
* Does a battle between the two pieces.
*
* @param a The first piece
* @param b The second piece
* @return 0 for a tie, a negative number if a beats b, or a positive number if b beats a
*/
public static int battle(Piece a, Piece b) {
if (a instanceof Miner && b instanceof Bomb) {
return -1;
}
// ...further tests here...
return 0;
}
}
public class Main {
public static void main(String[] args) {
ArrayList<Piece> pieceList = new ArrayList<>();
pieceList.add(new Miner());
pieceList.add(new Bomb());
// create new classes to test canDefeat
if (BattleLogic.battle(new Miner(), new Bomb()) < 0) {
System.out.println("Yes! This line will be printed.");
}
System.out.println();
// test canDefeat with pieces from the pieceList
if (BattleLogic.battle(pieceList.get(0), pieceList.get(1)) < 0) {
System.out.println("Yes! This line will also be printed");
}
}
}
这是第三个建议，让每种类型的棋子知道它可以击败哪些棋子，以防万一。 再说一次，我不建议这样做。 我认为让各个部分彼此了解得如此之多将是一个维护问题：
// Not really recommended
import java.util.List;
import java.util.ArrayList;
abstract class Piece {
private List<Class> iDefeat;
public Piece(Class... defeats) {
this.iDefeat = new ArrayList<Class>();
for (Class c : defeats) {
this.iDefeat.add(c);
}
}
public boolean canDefeat(Piece piece) {
return this.iDefeat.contains(piece.getClass());
}
}
class Bomb extends Piece {
}
class Miner extends Piece {
public Miner() {
super(Bomb.class);
}
}
public class Main {
public static void main(String[] args) {
ArrayList<Piece> pieceList = new ArrayList<>();
pieceList.add(new Miner());
pieceList.add(new Bomb());
// create new classes to test canDefeat
if (new Miner().canDefeat(new Bomb())) {
System.out.println("Yes! This line will be printed.");
}
System.out.println();
// test canDefeat with pieces from the pieceList
if (pieceList.get(0).canDefeat(pieceList.get(1))) {
System.out.println("Yes! This line will also be printed");
}
}
}
或者，如果您要拥有数百万个片段，并且内存成为问题，则可以使列表静态。 这只是一个草图。
最后，使用反射的方式：
// Not reall recommended
import java.lang.reflect.Method;
import java.util.ArrayList;
class Piece {
public Piece() {
}
private static Method getMethodOrNull(Class cls, String name, Class... paramTypes) {
try {
return cls.getMethod(name, paramTypes);
}
catch (NoSuchMethodException nsme) {
return null;
}
}
public boolean canDefeat(Piece opponent) {
try {
Class thisClass = this.getClass();
Class oppClass = opponent.getClass();
Method m = null;
while (oppClass != Piece.class && (m = getMethodOrNull(thisClass, "canDefeat", oppClass)) == null) {
oppClass = oppClass.getSuperclass();
}
if (m != null) {
return (boolean)m.invoke(this, opponent);
}
return false;
}
catch (Exception iae) {
throw new RuntimeException("Can't access method", iae);
}
}
}
class Miner extends Piece {
public boolean canDefeat(Bomb b) {
return true;
}
}
class Bomb extends Piece {
}
public class Main {
public static void main(String[] args) {
ArrayList<Piece> pieceList = new ArrayList<>();
pieceList.add(new Miner());
pieceList.add(new Bomb());
// create new classes to test canDefeat
if (new Miner().canDefeat(new Bomb())) {
System.out.println("Yes! This line will be printed.");
}
System.out.println();
// test canDefeat with pieces from the pieceList
if (pieceList.get(0).canDefeat(pieceList.get(1))) {
System.out.println("Yes! This line will also be printed");
}
}
}
由于参数类型变窄， Miner不会覆盖Piece的canDefeat方法。 您可以通过添加轻松地进行检查
@Override
您认为您要重写的方法可以在编译时进行验证。
此外，在抽象超类中提供默认行为，而是将行为转移到具体的子级中并不是很好的OO风格，因为否则您可能会非自愿地继承要覆盖的行为。 在您的情况下，使canDefeat抽象，然后让Bomb使用Piece当前存在的行为来实现它。
您只需要更改canDefeat的签名即可接受通用类型，并确保以正确的方式进行覆盖，两个签名始终相同
件类
public abstract class Piece {
public boolean canDefeat(Piece opponent) {
return false;
}
}
矿工类
public class Miner extends Piece {
@Override
public boolean canDefeat(Piece opponent) { // Piece not Bomb
return true;
}
}
更新以让
Miner仅击败Bomb
件类
public abstract class Piece<T> {
public boolean canDefeat(T opponent) {
return false;
}
}
矿工类
public class Miner extends Piece<Bomb> {
@Override
public boolean canDefeat(Bomb opponent) { // Defeats Bomb
return true;
}
}
除了@TJ Crowder的正确答案之外，我建议您也考虑以一种更加面向数据的方法而不是面向对象的方法来实现全部内容。 这看起来像一个完美的问题，可以在实体系统框架（例如“ Artemis” ）中实现，其中您的作品是一个具有力量成分的实体，而整个逻辑都进入了战场系统。
这种方法高度可适应变化的规则。 例如，如果您的失败不仅与力量有关，而且与健康有关，那么很容易在强度成分中添加一个健康参数，甚至创建一个额外的健康成分，而BattleSystem中的逻辑则可以处理它。 在这种方法中，最困难的事情是正确设计实体，组件和系统以及满足您的特定需求的系统间通信。
Java ArrayList 不使用重写的 equals(Object o) 方法进行比较
[英]Java ArrayList does not use overriden equals(Object o) method to compare
在Java中，如果我从子类中调用一个超类方法，该超类方法将调用重写方法，那么将调用哪个类的方法？
[英]In java, if I call, from a subclass, a superclass method that calls an overriden method, which class' method will be called?
从Java中的超类类型的ArrayList调用子类方法
[英]Calling a subclass method from an ArrayList of type superclass in Java
子类测试中的 JUnit4 NullPointerException，覆盖方法
[英]JUnit4 NullPointerException in SubClass Test, overriden method
声明:本站的技术帖子网页，遵循CC BY-SA 4.0协议，如果您需要转载，请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.