Enums with constructors and Abstract Methods

Enums with constructors

An enum cannot have a public constructor; however, private constructors are acceptable (constructors for enums are package-private by default): 

public enum Coin {
	PENNY(1), NICKEL(5), DIME(10), QUARTER(25); // usual names for US coins
	// note that the above parentheses and the constructor arguments match
	private int value;
	Coin(int value) {
		this.value = value;
	}
	public int getValue() {
		return value;
	}
}
 
int p = Coin.NICKEL.getValue(); // the int value will be 5

It is recommended that you keep all fields private and provide getter methods, as there are a finite number of instances for an enum.

If you were to implement an Enum as a class instead, it would look like this:

public class Coin<T extends Coin<T>> implements Comparable<T>, Serializable{
 
	public static final Coin PENNY = new Coin(1);
	public static final Coin NICKEL = new Coin(5);
	public static final Coin DIME = new Coin(10);
	public static final Coin QUARTER = new Coin(25);
	private int value;
 
	private Coin(int value){
		this.value = value;
	}
 
	public int getValue() {
		return value;
	}
}
 
int p = Coin.NICKEL.getValue(); // the int value will be 5

Enum constants are technically mutable, so a setter could be added to change the internal structure of an enum constant. However, this is considered very bad practice and should be avoided.

Best practice is to make Enum fields immutable, with final:

public enum Coin {
 
	PENNY(1), NICKEL(5), DIME(10), QUARTER(25);
	private final int value;
 
	Coin(int value){
		this.value = value;
	}
	...
}

You may define multiple constructors in the same enum. When you do, the arguments you pass in your enum declaration decide which constructor is called: 

public enum Coin {
 
	PENNY(1, true), NICKEL(5, false), DIME(10), QUARTER(25);
 
	private final int value;
	private final boolean isCopperColored;
 
	Coin(int value){
		this(value, false);
	}
 
	Coin(int value, boolean isCopperColored){
		this.value = value;
		this.isCopperColored = isCopperColored;
	}
	...
}

Note : All non-primitive enum fields should implement Serializable because the Enum class does.

Enums with Abstract Methods

Enums can define abstract methods, which each enum member is required to implement.

enum GameMove {
    LEFT {
        public boolean performAction(Player player) {
            return player.moveLeft();
        }
    },
    RIGHT {
        public boolean performAction(Player player) {
            return player.moveRight();
        }
    },
    JUMP {
        public boolean performAction(Player player) {
            return player.isJumping();
        }
    };
 
    public abstract boolean performAction(Player player);
}
 

This allows for each enum member to define its own behaviour for a given operation, without having to switch on types in a method in the top-level definition.

Note that this pattern is a short form of what is typically achieved using polymorphism and/or implementing interfaces.

Basic Programs

Learn All in Tamil © Designed & Developed By Tutor Joes | Privacy Policy | Terms & Conditions