在 Java 中,如何创建一个 class,其方法在每个实例中都不同?
In Java, how can I create a class whose methods are different in each instance?
我正在开发一个基本的游戏 AI,我正在尝试使用名为 Transition
的抽象 class 来封装行为树中节点之间的转换。
现在,Transition
看起来像这样:
package com.game.behaviors;
public abstract class Transition {
public abstract Node getNextNode();
}
我想要做的是在 getNextNode 方法中对每个 Transition 实例指定逻辑。例如,某些转换将始终 return 相同 Node
,而其他转换可能 return 基于随机数生成器或某些其他逻辑的几个节点之一。
我知道我可以通过为每个我想要的行为创建一个继承自 Transition
的 class,然后获取那些 classes 的实例来实现这一点,如下所示:
class RealTransition extends Transtition{
Node thisNode = someNode;
public Node getNextNode(){
return thisNode;
}
}
RealTransition rt = new RealTransition();
someObject.someMethodThatWantsATransition(rt);
作为一个主要在 Java 脚本中工作的 Java 菜鸟,这感觉很笨拙。创建一个我知道我只会实例化一次的新 class 感觉应该是不必要的,特别是因为我可能要定义 lots 转换。有没有更好的方法来定义我的转换如何工作?
Java 最巧妙的功能之一是能够使 enum
的每个值表现不同。基本上,每个值都是一个继承自父对象 enum
的单例对象。这听起来很适合您的工作。
有关详细信息,请参阅 Thinking in Java 中的 Constant-specific 方法。它从该 PDF 的第 740 页开始。
[编辑:从上面的 link 复制的示例。当树的节点(例如,游戏中的角色类型)预先固定时,这是一个很好的模式。它在应用于即时创建的对象时不起作用。]
//: enumerated/CarWash.java
import java.util.*;
import static net.mindview.util.Print.*;
public class CarWash {
public enum Cycle {
UNDERBODY {
void action() { print("Spraying the underbody"); }
},
WHEELWASH {
void action() { print("Washing the wheels"); }
},
PREWASH {
void action() { print("Loosening the dirt"); }
},
BASIC {
void action() { print("The basic wash"); }
},
HOTWAX {
void action() { print("Applying hot wax"); }
},
RINSE {
void action() { print("Rinsing"); }
},
BLOWDRY {
void action() { print("Blowing dry"); }
};
abstract void action();
}
EnumSet<Cycle> cycles =
EnumSet.of(Cycle.BASIC, Cycle.RINSE);
public void add(Cycle cycle) { cycles.add(cycle); }
public void washCar() {
for(Cycle c : cycles)
c.action();
}
public String toString() { return cycles.toString(); }
public static void main(String[] args) {
CarWash wash = new CarWash();
print(wash);
wash.washCar();
// Order of addition is unimportant:
wash.add(Cycle.BLOWDRY);
wash.add(Cycle.BLOWDRY); // Duplicates ignored
wash.add(Cycle.RINSE);
wash.add(Cycle.HOTWAX);
print(wash);
wash.washCar();
}
} /* Output:
[BASIC, RINSE]
The basic wash
Rinsing
[BASIC, HOTWAX, RINSE, BLOWDRY]
The basic wash
Applying hot wax
Rinsing
Blowing dry
如@ajb 所述,您可以使用 Java 8 中的函数式接口来做同样的事情。
它基本上是一样的,但是你使用匿名 类 来传递你想要的行为。
像这样定义你的Transition
:
@FunctionalInterface
public interface Transition {
public Node getNextNode();
}
然后在您的方法中使用 lambda 表达式:
someObject.someMethodThatWantsATransition(() -> {
// your method body here;
});
由于任何功能接口只能有一个方法,因此实例化了一个新的 Transition
并且调用了唯一的现有方法。
我正在开发一个基本的游戏 AI,我正在尝试使用名为 Transition
的抽象 class 来封装行为树中节点之间的转换。
现在,Transition
看起来像这样:
package com.game.behaviors;
public abstract class Transition {
public abstract Node getNextNode();
}
我想要做的是在 getNextNode 方法中对每个 Transition 实例指定逻辑。例如,某些转换将始终 return 相同 Node
,而其他转换可能 return 基于随机数生成器或某些其他逻辑的几个节点之一。
我知道我可以通过为每个我想要的行为创建一个继承自 Transition
的 class,然后获取那些 classes 的实例来实现这一点,如下所示:
class RealTransition extends Transtition{
Node thisNode = someNode;
public Node getNextNode(){
return thisNode;
}
}
RealTransition rt = new RealTransition();
someObject.someMethodThatWantsATransition(rt);
作为一个主要在 Java 脚本中工作的 Java 菜鸟,这感觉很笨拙。创建一个我知道我只会实例化一次的新 class 感觉应该是不必要的,特别是因为我可能要定义 lots 转换。有没有更好的方法来定义我的转换如何工作?
Java 最巧妙的功能之一是能够使 enum
的每个值表现不同。基本上,每个值都是一个继承自父对象 enum
的单例对象。这听起来很适合您的工作。
有关详细信息,请参阅 Thinking in Java 中的 Constant-specific 方法。它从该 PDF 的第 740 页开始。
[编辑:从上面的 link 复制的示例。当树的节点(例如,游戏中的角色类型)预先固定时,这是一个很好的模式。它在应用于即时创建的对象时不起作用。]
//: enumerated/CarWash.java
import java.util.*;
import static net.mindview.util.Print.*;
public class CarWash {
public enum Cycle {
UNDERBODY {
void action() { print("Spraying the underbody"); }
},
WHEELWASH {
void action() { print("Washing the wheels"); }
},
PREWASH {
void action() { print("Loosening the dirt"); }
},
BASIC {
void action() { print("The basic wash"); }
},
HOTWAX {
void action() { print("Applying hot wax"); }
},
RINSE {
void action() { print("Rinsing"); }
},
BLOWDRY {
void action() { print("Blowing dry"); }
};
abstract void action();
}
EnumSet<Cycle> cycles =
EnumSet.of(Cycle.BASIC, Cycle.RINSE);
public void add(Cycle cycle) { cycles.add(cycle); }
public void washCar() {
for(Cycle c : cycles)
c.action();
}
public String toString() { return cycles.toString(); }
public static void main(String[] args) {
CarWash wash = new CarWash();
print(wash);
wash.washCar();
// Order of addition is unimportant:
wash.add(Cycle.BLOWDRY);
wash.add(Cycle.BLOWDRY); // Duplicates ignored
wash.add(Cycle.RINSE);
wash.add(Cycle.HOTWAX);
print(wash);
wash.washCar();
}
} /* Output:
[BASIC, RINSE] The basic wash Rinsing [BASIC, HOTWAX, RINSE, BLOWDRY] The basic wash Applying hot wax Rinsing Blowing dry
如@ajb 所述,您可以使用 Java 8 中的函数式接口来做同样的事情。 它基本上是一样的,但是你使用匿名 类 来传递你想要的行为。
像这样定义你的Transition
:
@FunctionalInterface
public interface Transition {
public Node getNextNode();
}
然后在您的方法中使用 lambda 表达式:
someObject.someMethodThatWantsATransition(() -> {
// your method body here;
});
由于任何功能接口只能有一个方法,因此实例化了一个新的 Transition
并且调用了唯一的现有方法。