Java:使用两个不同枚举的方法几乎相同的两个类；是否有可能避免冗余？(到处都是静态方法)

Question

我有两个描述两个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;
}

，可以将InsertProfileHere替换为两个配置文件枚举中的每一个。

如果有人感兴趣，该方法使用，或者更确切地说，使用EMF中的UML2元模型实现。

无论如何，我想合并这两个实用程序类以避免冗余代码。

我试过：

由于静态methods，两个配置文件的超级接口

• • 没有工作

​

由于静态methods，实用程序类的抽象类

• • 无法工作

​

• encapsulating类

中的配置文件枚举

每个人都因某种原因而不工作。

有人有什么想法吗？

编辑：

另一个实用程序方法的示例：

public static boolean hasStereotype(
    final InsertProfileHere stereo, final Element elem) {
    for (Stereotype appliedStereo : elem.getAppliedStereotypes()) {
        if (stereo == null) {
            if (InsertProfileHere.contains(appliedStereo)) {
                return true;
            }
        } else if (stereo.isEqual(appliedStereo)) {
            return true;
        }
    }
    return false;
}

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));
}

Answer 1

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

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;
  }
}

Answer 2

使用通用接口，如下例所示。

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());
    }
}