枚举中的代码重复继承一个通用接口

我有几个符合一个通用接口的枚举：

    interface TableColumns
    {
      String getColumnName();
      int getColumnIndex();
      ColumnType getColumnType();
      boolean isEditable();
      int getColumnWidth();
    }

一个典型的实现是：

enum PointsTableColumns implements TrendTableColumns
{
    POINTS_COLUMN("points_column", false, ColumnType.TEXT, 400, 0);

    private String columnName;
    private boolean editable;
    private ColumnType columnType;
    private int columnWidth;
    private int columnIndex;

    private PointsTableColumns (String columnName, boolean editable, ColumnType columnType,
        int columnWidth,
        int columnIndex)
    {
        this.columnName = columnName;
        this.editable = editable;
        this.columnType = columnType;
        this.columnWidth = columnWidth;
        this.columnIndex = columnIndex;
    }

    public boolean isEditable()
    {
        return editable;
    }

    public int getColumnIndex()
    {
        return columnIndex;
    }

    public String getColumnName()
    {
        return columnName;
    }

    public int getColumnWidth()
    {
        return columnWidth;
    }

    public ColumnType getcolumnType()
    {
        return columnType;
    }
}

我有几个这样的实现（10+），每个都有多个且几乎不同的值。 现在，问题是我在这里看到很多代码重复，因为所有实现中的方法都是逐字相同的。 我知道在Java中这实际上不可能，因为枚举不能扩展实现。 我需要的是一个建议或不同的策略，这可以以更清晰的方式完成。 对此有没有一些现有的模式？

---

如果你能够以一种间接的方式生活，那么我下面提出的方法将把重复的代码减少到最小。

首先，考虑下面的供应商接口以及它的内部类：

public interface PropertiesSupplier {

    Properties properties();

    public static final class Properties {

        private final int value1;

        private final String value2;

        private final double value3;

        private Properties(int value1, String value2, double value3) {
            this.value1 = value1;
            this.value2 = value2;
            this.value3 = value3;
        }

        public static Properties of(int value1, String value2, double value3) {
            return new Properties(value1, value2, value3);
        }

        public int getValue1() {
            return this.value1;
        }

        public String getValue2() {
            return this.value2;
        }

        public double getValue3() {
            return this.value3;
        }

        @Override
        public String toString() {
            return "Properties [value1=" + this.value1 + ", value2=" + this.value2 + ", value3=" + this.value3
                    + "]";
        }
    }
}

这里没什么魔法。 内部类只是一个包含private final字段的bean，一个用于初始化它们的私有构造函数，public getters，一个工厂方法和一个overriden toString()方法。 该接口只定义了一个返回内部类的实例的方法。 请注意，内部类是最终的。 这个想法是强制执行不变性，所以它的属性不允许改变。

然后，让我们创建几个将实现此接口的枚举。 我们从MyEnum1开始，它定义了两个值：

public enum MyEnum1 implements PropertiesSupplier {
    ENUM_1_CONST_1(Properties.of(1, "hello", 0.123)), 
    ENUM_1_CONST_2(Properties.of(2, "goodbye", 7.54));

    private final Properties p;

    private MyEnum1(Properties p) {
        this.p = p;
    }

    @Override
    public Properties properties() {
        return this.p;
    }
}

接下来是MyEnum2 ，它只定义了一个值：

public enum MyEnum2 implements PropertiesSupplier {
    ENUM_2_CONST_1(Properties.of(9, "hey dude", 547.21578));

    private final Properties p;

    private MyEnum2(Properties p) {
        this.p = p;
    }

    @Override
    public Properties properties() {
        return this.p;
    }
}

如您所见，两个枚举都实现了PropertiesSupplier接口，因此它们必须为Properties properties()方法提供实现。 为了符合这一点，他们必须封装一个他们在构造函数中接收到的Properties实例。

所以现在，在这个间接之后，唯一在所有枚举中重复的代码就是Properties字段，它是作为参数接收它的构造函数以及它的getter方法。

这是一个展示如何使用枚举的示例：

MyEnum1 e1 = MyEnum1.ENUM_1_CONST_2;
MyEnum2 e2 = MyEnum2.ENUM_2_CONST_1;

System.out.println(e1.name() + " - " + e1.properties());
System.out.println(e2.name() + " - " + e2.properties());

该代码产生以下输出

ENUM_1_CONST_2 - Properties [value1=2, value2=goodbye, value3=7.54]
ENUM_2_CONST_1 - Properties [value1=9, value2=hey dude, value3=547.21578]

---

你所有的枚举看起来都是单个值。 你应该将它们合并成一个enum

enum TableColumns {

  POINTS("points_column", false, ColumnType.TEXT, 400, 0),
  FOO("foo_column", true, ColumnType.TXT, 123, 0),
  BAR("bar_column", true, ColumnType.TXT, 123, 0)
  ;
  ...rest is the same as your old POINTS_COLUMN
}

---

您应该考虑使用类并实现此方法以获取所有常量值，如下所示：

public class Utils {
    public static <T> List<T> values() {
        java.util.List<T> result = new ArrayList<>();
        Field[] fields = Bike.class.getFields();
        for (Field field : fields) {
            if (field.getModifiers() == (Modifier.PUBLIC ^ Modifier.STATIC ^ Modifier.FINAL) && field.getType().equals(Bike.class)) {
                try {
                    result.add((T) field.get(null));
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
        }
        return result;
    }
}

示例类：

public class Bike {
    public final static Bike
            HONDA = new Bike("Honda"),
            SUZUKI = new Bike("Suzuki"),
            YAMAHA = new Bike("Yamaha");

    private String name;

    public Bike(String name) {
        this.name = name;
    }

    public static List<Bike> values() {
        return Utils.<Bike>values();
    }

    public static void main(String[] args) {
        System.out.println(values());
    }
}

链接地址: http://www.djcxy.com/p/86783.html

上一篇: Code duplication in enums inheriting a common interface

下一篇: How to make two markers share the same label in the legend using matplotlib?