Java：两个类，具有几乎相同的方法，使用两个不同的枚举；可以避免冗余吗？（到处都是静态方法）

我有两个枚举描述了两个UML概要文件（这意味着它们定义了概要文件包含的原型）

我还有两个实用程序类，其特点是在每个概要文件上使用几乎相同的方法

例如：

public static List<Element> getStereotypedElements(final InsertProfileHere stereo, final Package pkg) {
    List<Element> extendedElements = new ArrayList<Element>();      
    if (isProfileApplied(pkg)) {
        if (hasStereotype(stereo, pkg)) {
            extendedElements.add(pkg);
        }
        extendedElements.addAll(getStereotypedElements(stereo, pkg.allOwnedElements()));
    }
    return extendedElements;
}

EDIT2：为了更好地衡量配置文件枚举实现的一部分

public enum Profile1 { 

STEREOTYPE1 ("readable stereotype1 name"),
STEREOTYPE2 ("readable stereotype2 name"),
STEREOTYPE3 ("readable stereotype3 name"),

public static final String PROFILE_NAME = "NameOfProfile";

private final String readableName;

private Profile1(final String newName) {
    readableName = newName;
}

public static Profile1 getValue(final String name) {
    for (Profile1 type : Profile1.values()) {
        if (type.toString().equals(name)) {
            return type;
        }
    }
    return null;
}

public static boolean contains(Stereotype stereotype) {
    return (stereotype.getProfile().
            getDefinition().getNsURI().contains(PROFILE_NAME));
}

---

让这两个枚举实现一个公共接口，并在（现已统一的）实用程序类中使用该接口。或者，更好的方法是将方法从实用程序类移动到接口

interface Stereotype {
  public boolean hasStereotype(Package pkg);
  public List<Element> getStereotypedElementes(Package pkg);
}

 enum Enum1 implements Stereotype {

   FOO("com.foo"), BAR("com.bar");

   Enum1(String packagename) {
     this.packagename=packagename;
   }

   private String packagename;

  @Override
  public boolean hasStereotype(Package pkg) {
    return pkg.getName().equals(packagename);
  }

  @Override
  public List<Element> getStereotypedElementes(Package pkg) {
    ...
  }

}

 enum Enum2 implements Stereotype {
   ...
 }


public class Foo {
  static List<Element> getStereotypedElements(final Stereotype stereo, final Package pkg) {
    List<Element> extendedElements = new ArrayList<Element>();      
    if (isProfileApplied(pkg)) {
        if (stereo.hasStereotype(pkg)) {
            extendedElements.add(pkg);
        }
        extendedElements.addAll(stereo.getStereotypedElements(pkg.allOwnedElements()));
    }
    return extendedElements;
  }
}

接口原型{
公共布尔hasStereotype（包包装）；
公共清单（包装件）；
}
enum Enum1实现构造型{
FOO（“com.FOO”）、BAR（“com.BAR”）；
Enum1（字符串packagename）{
this.packagename=packagename；
}
私有字符串包名；
@凌驾
公共布尔hasStereotype（包打包）{
返回pkg.getName（）.equals（packagename）；
}
@凌驾
公共列表getStereotypedElementes（包打包）{
...
}
}
EnumEnum2实现了构造型{
...
}
公开课Foo{
静态列表getStereotypedElements（最终原型立体声，最终包打包）{
List extendedElements=new ArrayList（）；
如果（应用ISPROFILE（包装））{
if（立体声HassereType（包装））{
extendedElements.add（pkg）；
}
addAll（stereo.getStereotypedElements（pkg.allOwnedElements（））；
}
返回扩展元素；
}
}

使用公共接口，如下例所示

import java.awt.Color;

public class EnumeInteraceTest
{
    public interface ICorolsEnum
    {
        public Color getColor();
    }
    public enum Colors1 implements ICorolsEnum
    {
        MAGENTA(Color.MAGENTA),
        PINK(Color.PINK);
        private Color color;

        private Colors1(Color color)
        {
            this.color = color;
        }

        @Override
        public Color getColor()
        {
            return color;
        }
    }
    public enum Colors2 implements ICorolsEnum
    {
        GREEN(Color.GREEN),
        BLUE(Color.BLUE);
        private Color color;

        private Colors2(Color color)
        {
            this.color = color;
        }

        @Override
        public Color getColor()
        {
            return color;
        }
    }

    public static void main(String[] args)
    {
        ICorolsEnum ice1 = Colors1.MAGENTA;
        System.out.println(ice1.getColor());
        ICorolsEnum ice2 = Colors2.GREEN;
        System.out.println(ice2.getColor());
    }
}

---

为什么是两个枚举？如果我们从根本上讲是类别和子类别，那么只需在一个枚举中敲打笛卡尔积，或者（更好的是IMHO）只需使用“近乎重复”的代码。。。只有一个（短）方法，是吗？当您的枚举实现相同的接口时，什么不起作用？@1:不完全是，实用程序类中有几个方法，我只发布了一个示例。@2:枚举有静态方法getValue（String），它返回适当的枚举常量，并包含（原型），它检查给定的原型是否是概要文件的一部分。使用接口时，我不能使用静态方法。@1:另外，我不知道我是否理解您的意思，但这两个配置文件不包含相同的原型。好的，在我看来，我将“原型”替换为“UMLProfile”。hassetereotype（Package）意味着我可以询问profile enum的每个实例是否有这个原型。如果我需要一个静态方法hassetereotype来检查包中是否包含任何概要文件原型，那么这也可以吗？

import java.awt.Color;

public class EnumeInteraceTest
{
    public interface ICorolsEnum
    {
        public Color getColor();
    }
    public enum Colors1 implements ICorolsEnum
    {
        MAGENTA(Color.MAGENTA),
        PINK(Color.PINK);
        private Color color;

        private Colors1(Color color)
        {
            this.color = color;
        }

        @Override
        public Color getColor()
        {
            return color;
        }
    }
    public enum Colors2 implements ICorolsEnum
    {
        GREEN(Color.GREEN),
        BLUE(Color.BLUE);
        private Color color;

        private Colors2(Color color)
        {
            this.color = color;
        }

        @Override
        public Color getColor()
        {
            return color;
        }
    }

    public static void main(String[] args)
    {
        ICorolsEnum ice1 = Colors1.MAGENTA;
        System.out.println(ice1.getColor());
        ICorolsEnum ice2 = Colors2.GREEN;
        System.out.println(ice2.getColor());
    }
}