Customized Enum in Java8

To clarify my goal I rephrased the question. Here the use-case I am trying to solve: At the moment there are more than 50 tables in my project. At several locations these tables are used(Rendering, TableModel, etc.) The project is quite old and also includes some features which might not be necessary today however that's a different topic. One example where a table is used is this one:

exampleTable.getColumnModel().getColumn(0).setPreferredWidth(50);          
exampleTable.getColumnModel().getColumn(1).setPreferredWidth(200);        
exampleTable.getColumnModel().getColumn(2).setPreferredWidth(150);         
exampleTable.getColumnModel().getColumn(3).setPreferredWidth(100);	

and in the table model:

public Class<?> getColumnClass(int columnIndex) {
if (columnIndex == 0) {
return Integer.class;
} else if (columnIndex == 3) {
return Date.class;
}
return String.class; 
}
public int getColumnCount() {
return 4;
}
public String getColumnName(int column) {
int x=0;
if (column == x++) {
return Texts.TableColumn.ID;
} else if (column == x++) {
return Texts.TableColumn.NAME;
} else if (column == x++) {
return Texts.TableColumn.CREATOR;
} else if (column == x++) {
return Texts.TableColumn.CREATED;
} else {
return "";
}
}

Now my first attempt was to use constants for the index so I can directly read which column is meant (no widt, text, etc.) Example:

exampleTable.getColumnModel().getColumn(Constants.EXPL_TAB_COL_ID).setPreferredWidth(50);

However this has the negative side effect, that I have to use the Table name in the constant-name as for example the column ID can appear in multiple tables at different positions. The next attempt was to solve the problem by using Enums which actually worked for the original use-case of replacing the indeices with "Constants/Enums" for the readability:

exampleTable.getColumnModel().getColumn(TAB_EXPL.ID.ordinal()).setPreferredWidth(50);

However as the optimal solution would solve all the problems at once my goal is to find like this:

	for (TAB_EXPL col : TAB_EXPL.values()) {
exampleTable.getColumnModel().getColumn(col.getIndex()).setPreferredWidth(col.getPreferredWidth);
}
public Class<?> getColumnClass(int columnIndex) {
if (columnIndex == TAB_EXPL.ID.getIndex()) {
return Integer.class;
} else if (columnIndex == TAB_EXPL.CREATED.getIndex()) {
return Date.class;
}
return String.class; 
}
public int getColumnCount() {
return TAB_EXPL.values().length;
}
public String getColumnName(int column) {
for (TAB_EXPL col : TAB_EXPL.values()) {
return col.getName();
}
}

It doesn't matter if it's a class, enum or record it should just solve the problem. I also tried an approach with the EnumMap type in combination with a record however I failed when I tried to use multiple arguments(Record is defined with int Index, String name) in the put() method of the EnumMap. Also the put()-Method has to be called in a constructor or another method which makes the enum/constant attempt useless:

eMap.put(TAB_EXPL.ID, (0, "Id"));

Hope this helps to understand the problem and that someone can help me.

EDIT2 SOLUTION: I found a solution myself, however it is not exactly the one I searched and it does only work for Java version 9+. Here is an example in case someone has a similar problem or any additional ideas:

import java.util.Map;
import java.util.EnumMap;
public class HelloWorld {
public enum TAB_EXPL{ID,DATE,USER};
public enum TAB_ATT{ID,NAME,STATE};
public static void main(String[] args) {
class RecordTableColumn {
private final int index;
private final String name;
private final int colWidth;
public RecordTableColumn(int index, String name, int colWidth) {
this.index = index;
this.name = name;
this.colWidth = colWidth;
}
public int getIndex() {
return index;
}
public String getName() {
return name;
}
public int getColWidth() {
return colWidth;
}
}
EnumMap<TAB_EXPL, RecordTableColumn> TabExpl = new EnumMap<>(Map.ofEntries(
Map.entry(TAB_EXPL.ID, new RecordTableColumn(0, "Id", 10)),
Map.entry(TAB_EXPL.DATE, new RecordTableColumn(1, "Date", 30)),
Map.entry(TAB_EXPL.USER, new RecordTableColumn(2, "User", 100))
));
EnumMap<TAB_ATT, RecordTableColumn> TabAtt = new EnumMap<>(Map.ofEntries(
Map.entry(TAB_ATT.ID, new RecordTableColumn(0, "Id", 10)),
Map.entry(TAB_ATT.NAME, new RecordTableColumn(1, "Name", 100)),
Map.entry(TAB_ATT.STATE, new RecordTableColumn(2, "State", 50))
));
System.out.println("Table Example:");
for (TAB_EXPL col : TAB_EXPL.values()) {
System.out.println("Index: " + TabExpl.get(col).getIndex());
System.out.println("Name: " + TabExpl.get(col).getName());
System.out.println("Column Width: " + TabExpl.get(col).getColWidth());
}  
System.out.println("---------------------------------------------");
System.out.println("Table Att:");
for (TAB_ATT col : TAB_ATT.values()) {
System.out.println("Index: " + TabAtt.get(col).getIndex());
System.out.println("Name: " + TabAtt.get(col).getName());
System.out.println("Column Width: " + TabAtt.get(col).getColWidth());
}  
}

}

The primary benefit of enums is type safe constants. If you have columns of many different tables mixed into one enum, you're losing out on type safety.

But enums can implement interfaces. And we can define an interface that all our "table-definition" enums should implement like this:

/**
* Interface for enums that define a table. Should not be implemented by non-enum classes.
*/
public interface TableDefinition<T extends Enum<T>> {
int getPreferredWidth();
Class<?> getColumnClass();
}

Note that this interface could be implemented outside of an enum (there's no way in the type system that I know of to force an interface to only be implemented using enum), but we really only want enums.

Then we'll define a method like this somewhere (it should probably be a non-static method of ColumnModel, but I'll pretend you can't change that class for some reason):

static <T extends Enum<T> & TableDefinition<T>> void applyPreferredWidth(ColumnModel cm, Class<T> clazz) {
for (T column : clazz.getEnumConstants()) {
cm.getColumn(column.ordinal()).setPreferredWidth(column.getPreferredWidth());
}
}

Now this method (and it's magic type parameter) ensures that the class passed to it references a class that's both and enum and implements our interface. This means we can use enum methods like ordinal() (which we'll just interpret as the column index) and our own methods like getPreferredWidth().

Now an implementation of this enum could simply look like this:

public enum ExampleTable implements TableDefinition<ExampleTable> {
ID(Integer.class, 50),
NAME(String.class, 200),
CREATOR(String.class, 150),
CREATED(Instant.class, 100);
private final Class<?> columnClass;
private final int preferredWidth;
ExampleTable(Class<?> columnClass, int preferredWidth) {
this.columnClass = columnClass;
this.preferredWidth = preferredWidth;
}
@Override
public int getPreferredWidth() {
return preferredWidth;
}
@Override
public Class<?> getColumnClass() {
return columnClass;
}
}

If you don't want to write constructer and getter method. You can try lombok.

        <dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.26</version>
</dependency>

And you can write enum like this.

package com.example;
import lombok.AllArgsConstructor;
import lombok.Getter;
public class EnumClass {
@AllArgsConstructor
@Getter
public enum TableA {
ID(Integer.class, 50);
private final Class<?> aClass;
private final Integer width;
}
public static void main(String[] args) {
Class<?> aClass = TableA.ID.getAClass();
Integer width = TableA.ID.getWidth();
}
}

But you still need to write fields...