如何在Java代码中传递通用枚举键

我有两个类，即

ChildOne

和

ChildTwo

，它们正在扩展

Base

类need

Base

和一个名为

AgeEnum

的枚举。有一种方法，即

getAge（）

在子类中很常见，现在我想在基类中移动该公共方法，我还想做一些事情，以便在调用 对象（ex-

ChildOne.getAge（）

）应该返回枚举中定义的该子对象的年龄

• 基类

   public class BaseClass {
      ***// Define getAge() here somehow to get the dynamic value of the*** 
   }
  

• 一班的孩子

   public class ChildOne extends BaseClass {
      public int getAge(){
          return AgeEnum.ChildAge.CHILD_ONE.getValue();
      }
   }
  

• 儿童二班

   public class ChildTwo extends BaseClass {
      public int getAge(){
          return AgeEnum.ChildAge.CHILD_TWO.getValue();
      }
   }
  

• 枚举

   public class AgeEnum {
      public enum ChildAge {
          CHILD_ONE(12), 
          CHILD_TWO(19);
  
          private ChildAge(final int text) {
              this.text = text;
          }
  
          private final int text;
  
          public int getValue() {
              return text;
          }
      }
   }
  

到目前为止，我已经分析过，如果我们可以这样做，但是如何在enum调用中配置它，在这种情况下，如果我调用子类的

getAge（）

，我将从enum中获取值，我所要做的就是识别子类并在运行时传递enum常量（如果该类是这样的话）（可能是我将从上下文中获取类实例，并使用反射获取类名）：

公共类基类{
公共整数getAge（）{
返回AgeEnum.ChildAge..getValue（）；
}
}

您可以通过名称获取枚举常量，例如

ChildAge enumConstant = ChildAge.valueOf("CHILD_ONE");

然后，您可以使用以下内容：

System.out.println(ChildAge.valueOf("CHILD_ONE").getValue());

打印12张

---

如果你真的想把你的子类“连接”到一个枚举常量，我会简单地硬编码它们，因为你（只能）硬编码一个子类

ChildAge enumConstant = ChildAge.valueOf("CHILD_ONE");

然后，您可以使用以下内容：

System.out.println(ChildAge.valueOf("CHILD_ONE").getValue());

打印12张

---

如果你真的想将你的子类“连接”到一个枚举常量，我会简单地对它们进行硬编码，因为你（只能）也对一个子类进行硬编码。

一种方法是让

enum

成为基类的一个属性。这个属性可以作为基类构造函数的一个参数：

public class BaseClass {

    private final AgeEnum.ChildAge age;

    public BaseClass(AgeEnum.ChildAge age) {
        this.age = age;
    }

    public int getAge() {
        return this.age.getValue();
    }
}

然后，子类只需要指定正确的枚举：

public class ChildOne extends BaseClass {

    public ChildOne() {
        super(AgeEnum.ChildAge.CHILD_ONE);
    }
}

以及：

---

一种方法是让

enum

成为基类的属性。该属性可以作为基类构造函数的参数：

public class BaseClass {

    private final AgeEnum.ChildAge age;

    public BaseClass(AgeEnum.ChildAge age) {
        this.age = age;
    }

    public int getAge() {
        return this.age.getValue();
    }
}

然后，子类只需要指定正确的枚举：

public class ChildOne extends BaseClass {

    public ChildOne() {
        super(AgeEnum.ChildAge.CHILD_ONE);
    }
}

以及：

---

首先，让我们从最明显的解决方案开始。由于您的任务没有假定可能存在既不是

ChildOne

也不是

ChildTwo

的

BaseClass

实例，因此根本不需要将实现向上移动到类层次结构。显然，您希望使该方法在基类型上可用，通过声明基类型抽象，它很容易工作：

一般来说，可以并建议对代码进行结构化，以尽量减少代码重复，例如

public abstract class BaseClass {
    public int getAge() {
        return childAge().getValue();
    }
    abstract AgeEnum.ChildAge childAge();
}
public class ChildOne extends BaseClass {
    @Override AgeEnum.ChildAge childAge() {
        return AgeEnum.ChildAge.CHILD_ONE;
    }
}
public class ChildTwo extends BaseClass {
    @Override AgeEnum.ChildAge childAge() {
        return AgeEnum.ChildAge.CHILD_TWO;
    }
}

但在这里，代码重复太少，不值得现在使用两种方法来提高复杂性

为了完整性，可以使这些关联成为子类的固定

静态
属性，可由基类实现查询

public abstract class BaseClass {
    @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.TYPE)
    @interface Age { AgeEnum.ChildAge value(); }

    public int getAge() {
        return getClass().getAnnotation(Age.class).value().getValue();
    }
}

@Age(AgeEnum.ChildAge.CHILD_ONE)
public class ChildOne extends BaseClass {
}

@Age(AgeEnum.ChildAge.CHILD_TWO)
public class ChildTwo extends BaseClass {
}

但是，在这些简单的情况下，复杂度的提高是否会带来回报，这还是一个疑问。我认为，您只需要基类是
抽象的
，就像在第一个示例中一样…
首先，让我们从最明显的解决方案开始。因为您的任务并不假设可能存在不存在的
基类
实例她的
ChildOne
或
ChildTwo
，根本不需要将实现向上移动到类层次结构中。显然，您希望在基类型中使用该方法，通过声明基类型抽象，该方法很容易工作：

一般来说，可以并建议对代码进行结构化，以尽量减少代码重复，例如

public abstract class BaseClass {
    public int getAge() {
        return childAge().getValue();
    }
    abstract AgeEnum.ChildAge childAge();
}
public class ChildOne extends BaseClass {
    @Override AgeEnum.ChildAge childAge() {
        return AgeEnum.ChildAge.CHILD_ONE;
    }
}
public class ChildTwo extends BaseClass {
    @Override AgeEnum.ChildAge childAge() {
        return AgeEnum.ChildAge.CHILD_TWO;
    }
}

但在这里，代码重复太少，不值得现在使用两种方法来提高复杂性

为了完整性，可以使这些关联成为子类的固定
静态
属性，可由基类实现查询

public abstract class BaseClass {
    @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.TYPE)
    @interface Age { AgeEnum.ChildAge value(); }

    public int getAge() {
        return getClass().getAnnotation(Age.class).value().getValue();
    }
}

@Age(AgeEnum.ChildAge.CHILD_ONE)
public class ChildOne extends BaseClass {
}

@Age(AgeEnum.ChildAge.CHILD_TWO)
public class ChildTwo extends BaseClass {
}

但是，在这些简单的情况下，复杂度的提高是否会带来回报还是一个疑问。我认为，您只需要基类是
抽象的
，就像在第一个示例中一样…
基类的实例和子级枚举之间是否存在1:1的映射？为什么不将枚举作为基类的一个属性呢？您可以通过它在构造函数中作为参数存在基类实例和子级枚举之间的1:1映射吗？为什么不让枚举成为基类的属性？可以在构造函数中作为参数传递它