枚举抽象问题 [英] Enum abstraction problem
问题描述
public interface State {
};
public interface Dynamics {
getObservationChance（状态，观察观察）;
};
class SpecialState实现状态{
};
enum SpecialObservation（）{
FREE，WALL等
}
class SpecialDynamics实现动态{
getObservationChance（状态，观察观察）{
//状态应该是SpecialState，观察应该是SpecialObservation！
}
};
class Main {
Main（State state，Observation observation，Dynamics dynamics）{
dynamics.getObservationChance（state，observation）;
}
};
SecialObservation应该是可能观察到的枚举（或类似的东西），但是我想要抽象表示的问题。所以我想要一个观察应该包含观察和一个函数返回所有可能的观察列表。最后一件事对于我正在实施的算法非常重要，因为我必须总结所有可能的观察结果。
谢谢！
您需要参数化类型 - 您有树型类型的家庭：状态，观察和动态。
如果我们将观察枚举作为参数类型，我们可以将您的类型转换为以下类型：
public界面观察< O延伸观察>> {
...
}
public interface State< O extends Observation< O>> {
}
public interface Dynamics< O extends Observation< O>> {
getObservationChance（State O状态，O观察）;
}
枚举SpecialObservation实现观察< SpecialObservation> {
FREE，WALL等
}
class SpecialState实现状态< SpecialObservation> {
}
class SpecialDynamics实现动态< SpecialObservation> {
getObservationChance（State< SpecialObservation> state，SpecialObservation观察）{
//状态应该是SpecialState，观察应该是SpecialObservation！
}
}
class Main< O extends Observation> {
Main（状态，状态，O观察，动力学动态）{
dynamics.getObservationChance（state，观察）;
}
}
此方法仅在我们的状态界面的方法对于getObservationChance方法来说，这是足够的。
一个更一般的方法是对所有三种类型进行参数化：
public interface Observation< O extends Observation< O，S，D>
S extends State< O，S，D>
D extends Dynamics O，S，D>>
{
...
}
public interface State< O extends Observation< O，S，D>，
S扩展状态< S，D>，
D扩展动态 {
}
public interface Dynamics< O extends Observation< O，S，D>，
S扩展状态< O，S，D>
D动态和LT; O，S，D>> {
getObservationChance（S状态，O观察）;
}
然后我们可以将这些实现定义为：
枚举SpecialObservation实现观察< SpecialObservation，SpecialState，SpecialDynamics> {
FREE，WALL等
}
class SpecialState实现状态< SpecialObservation，SpecialState，SpecialDynamics> {
}
class SpecialDynamics实现动态< SpecialObservation，SpecialState，SpecialDynamics> {
getObservationChance（SpecialObservation状态，SpecialObservation观察）{
//状态应该是SpecialState，观察应该是SpecialObservation！
}
}
主类然后需要所有三个参数，当然：
class Main< O extends Observation< O，S，D>，
S扩展状态< O，S ，D>，
D扩展动态 {
Main（S state，O观察，D动态）{
dynamics.getObservationChance（state，观察）;
}
}
在你的情况下，事实上动态只取决于观察和状态，而不是相反的方式（这些不依赖于彼此），所以另一种方式是这样的：
public interface Observation {
...
}
public interface State {
}
public interface Dynamics< S extends州，
O延伸观察> {
getObservationChance（S状态，O观察）;
}
枚举SpecialObservation实现观察{
FREE，WALL等
}
class SpecialState实现状态{
}
class SpecialDynamics实现Dynamics< SpecialState，SpecialObservation> {
getObservationChance（SpecialState state，SpecialObservation观察）{
//状态应该是SpecialState，观察应该是SpecialObservation！
}
}
class Main< S extends State，O extends Observation> {
Main（S状态，O观察，动态，S，O>动态）{
dynamics.getObservationChance（state，观察）;
}
}
编辑：
关于getAllObservations方法：
只要你以某种方式使你的类型参数具体化，这里没有真正的问题。
要访问特定类型的枚举常量列表，您需要直接访问此类型（ SpecialObservation.values（））或类对象像这样：
class Main< S extends State，O extends Observation> {
public O [] getAllObservations（Class< O> oClass）{
return oClass.getEnumConstants（）;
}
主（S状态，动态< S，O>动态，Class< O>观察类）{
O [] observations = getAllObservations（observeClass） （o o：观察）
{
dynamics.getObservationChance（state，观察）;
}
}
}
（这只适用于O是一个枚举类，当然是。）
如果你有一个混合列表，它变得更加复杂，然后输入安全匹配也不是很简单动态，行动，观察和州级课程。
I am currently struggling with a java abstraction problem. I have something like this:
public interface State {
};
public interface Dynamics {
getObservationChance(State state, Observation observation);
};
class SpecialState implements State {
};
enum SpecialObservation() {
FREE, WALL, etc.
}
class SpecialDynamics implements Dynamics {
getObservationChance(State state, Observation observation) {
// state should be SpecialState, observation should be SpecialObservation!
}
};
class Main {
Main(State state, Observation observation, Dynamics dynamics) {
dynamics.getObservationChance(state, observation);
}
};
SecialObservation should be an enum (or something like that) of possible observations, but I want to have an abstract representation of the problem. So I want an Observation that should contain the observation and a function that returns a list of all possible observations. The last thing is very important for an algorithm I am implementing, since I have to summarize over all possible observations.
Thanks!
You need parametrized types here - you have families of tree types each: a state, a observation, and a dynamics.
If we take the observation enum as the parameter type, we could convert your type to something like this:
public interface Observation<O extends Observation<O>> {
...
}
public interface State<O extends Observation<O>> {
}
public interface Dynamics<O extends Observation<O>> {
getObservationChance(State<O> state, O observation);
}
enum SpecialObservation implements Observation<SpecialObservation> {
FREE, WALL, etc.
}
class SpecialState implements State<SpecialObservation> {
}
class SpecialDynamics implements Dynamics<SpecialObservation> {
getObservationChance(State<SpecialObservation> state, SpecialObservation observation) {
// state should be SpecialState, observation should be SpecialObservation!
}
}
class Main<O extends Observation> {
Main(State<O> state, O observation, Dynamics<O> dynamics) {
dynamics.getObservationChance(state, observation);
}
}
This approach only works if the methods of our State interface are enough for the getObservationChance method, of course.
A more general approach would be to parametrize over all three types:
public interface Observation<O extends Observation<O, S, D>,
S extends State<O,S,D>,
D extends Dynamics<O,S,D>>
{
...
}
public interface State<O extends Observation<O,S,D>,
S extends State<O,S,D>,
D extends Dynamics<O,S,D>> {
}
public interface Dynamics<O extends Observation<O,S,D>,
S extends State<O,S,D>,
D extends Dynamics<O,S,D>> {
getObservationChance(S state, O observation);
}
Then we can define the implementations as this:
enum SpecialObservation implements Observation<SpecialObservation, SpecialState, SpecialDynamics> {
FREE, WALL, etc.
}
class SpecialState implements State<SpecialObservation, SpecialState, SpecialDynamics> {
}
class SpecialDynamics implements Dynamics<SpecialObservation, SpecialState, SpecialDynamics> {
getObservationChance(SpecialObservation state, SpecialObservation observation) {
// state should be SpecialState, observation should be SpecialObservation!
}
}
The main class then needs all three parameters, of course:
class Main<O extends Observation<O,S,D>,
S extends State<O,S,D>,
D extends Dynamics<O,S,D>> {
Main(S state, O observation, D dynamics) {
dynamics.getObservationChance(state, observation);
}
}
In your case in fact the dynamics is only dependent on the observation and state, and not the other way around (and these are not dependent on each other), so another way would be this:
public interface Observation {
...
}
public interface State {
}
public interface Dynamics<S extends State,
O extends Observation> {
getObservationChance(S state, O observation);
}
enum SpecialObservation implements Observation {
FREE, WALL, etc.
}
class SpecialState implements State {
}
class SpecialDynamics implements Dynamics<SpecialState, SpecialObservation> {
getObservationChance(SpecialState state, SpecialObservation observation) {
// state should be SpecialState, observation should be SpecialObservation!
}
}
class Main<S extends State, O extends Observation> {
Main(S state, O observation, Dynamics<S, O> dynamics) {
dynamics.getObservationChance(state, observation);
}
}
Edit:
About the getAllObservations method:
As long as you somehow can make your type parameters concrete, there is no real problem here.
To access the list of enum constants of a specific type, you need access to this type - either directly (SpecialObservation.values()), or with a class object like here:
class Main<S extends State, O extends Observation> {
public O[] getAllObservations(Class<O> oClass) {
return oClass.getEnumConstants();
}
Main(S state, Dynamics<S, O> dynamics, Class<O> observationClass) {
O[] observations = getAllObservations(observationClass);
for(O o : observations) {
dynamics.getObservationChance(state, observation);
}
}
}
(This only works if O is an enum class, of course.)
If you have a mixed list, it gets more complicated, and then it is also not really easy to type-safely match the Dynamics, Action, Observation and State classes.
这篇关于枚举抽象问题的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
