Java Enum in details

Java 5 has brought linguistic support for enumerated types. An enum type is a type whose fields consist of a fixed set of constants. The enum provides following features
  • Typesafe
  • Namespace
  • Printable constants values
Typical and often enum is being used to replace int constants. For example constants for color codes 
public static final int RED = 0;
public static final int GREEN = 1;
public static final int BLUE = 3;
public static final int WHITE =4;
public static final int BLACK = 6;
 

This code can be replaced by following enum
public enum StandardColor {
    RED,GREEN,BLUE,WHITE,BLACK
}

Given the above enum declared, we can use the same to communicate the color preferences. For example we have Window class and it supports setting background color using setBackgroundColor(StandardColor color). One can call setBackgroundColor method on Window's instance to set background color, as shown in code below
public class Window{
    //..
    public setBackgroundColor(StandardColor color){
        if(color == StandardColor.Black){
            setBackgroundColor(#000000);
        } else if(color == StandardColor.WHITE){
            setBackgroundColor(#FFFFFF);
        }
        //..
    }
}


Windows myWindow = new Window();
myWindow.setBackgroundColor(StandardColor.BLACK);

Everything will go smooth till you have same understanding between StandardColor enum elements declaration and its implementers. Now consider the case you have to declare another color entry called “MY_COLOR” and corresponding html code will be “#0000A0”. To let the corresponding html code we may document in comment.
enum StandardColor {
    BLACK,WHITE,RED,GREEN,BLUE,
    /**
     * HTML Code #0000A0
     */
    MY_COLOR
}

Addition to that we need to modify setBackgroundColor() method
public setBackgroundColor(StandardColor color){
    if(color == StandardColor.Black){
        setBackgroundColor(#000000);
    } else if(color == StandardColor.WHITE){
        setBackgroundColor(#FFFFFF);
    } else if(color == StandardColor.MY_COLOR){
        setBackgroundColor(#0000A0);
    }
    //..
}

Here is the problems, it you modify the color code, then all corresponding needs to be changed.
Java programming language enum types are much more powerful, the enum class body can include methods and other fields.Each enum constants can be declared with values. These values are passed to the constructor when constants are created. Enum StandardColor constants with RGB values to represent its actual value will make it self explanatory.
enum StandardColor {
    RED(255,0,0),
    GREEN(0,255,0),
    BLUE(0,0,255),
    WHITE(255,255,255), 
    BLACK(0,0,0) ;
    final int r,g,b;
    private StandardColor(int rParam, int gParam, int bPram){
        r = rParam;
        g = gParam;
        b = bPram;
    }
    
    public String getHexValue(){
        return "#"+ Integer.toHexString(r)+Integer.toHexString(g)+Integer.toHexString(b);
    }
    
    private String intToHex(int i){
        return Integer.toHexString(i);
    }
}
Here enum StandardColor constants accept three integer representing red, green and blue values while declaring it. As seen in code above , it has private constructor with three integers and a public method getHexValue() to get html value of color. Now the Windows.setBackgroundColor(StandardColor) method will be much more simpler that previous version.
public setBackgroundColor(StandardColor color){
    setBackgroundColor(color.getHexValue());
}
Now doesn’t matter what modification you do in StandardColor enum like introducing new constants or changing constant’s value, all dependents need not to be cared.

Comments

Post a Comment

Popular posts from this blog

State Design Pattern by Example

Image
State pattern falls under the category of Behavioral patterns. State design pattern comes in picture when a system’s behavior is depends on its own state or some other resource’s state. If an implementation is depends on the states, we end up with snarl of conditional statement every where in code. A very neat approach to deal with such situation is to separate out every state’s behavior and use them where ever they are applicable. The state pattern allows an object to alter its behavior when is internal state changes . The object is appeared to change its class. State pattern is a way to implement the same. Class Diagram : As above class diagram shows, System class holds state instance. As state of system changes , all handle request delegated to respective State’s concrete implementation. Example : Have an example of Vending machine. Vending machine has following states No Coin Inserted Coin Inserted Dispensing Empty Following diagram explain behavior...
Read more

Eclipse command framework core expression: Property tester

Image
Addition to Eclipse command framework series, this post explains use of property tester to control command’s enable/visible properties. In earlier post we have tried declarative way to achieve same thing but property tester gives us more control. Property tester is associated with, tester class which implements PropertyTester.java, a namespace and set of property which it supports. We can refer this property tester using its namespace + a property name. It gives you call back to test() method with property name as parameter inside property tester class. We can configure property tester for type of input parameter. Here is sample declaration of property tester extension point < extension point ="org.eclipse.core.expressions.propertyTesters" > < propertyTester class ="com.example.advance.cmd.EditorTester" id ="com.example.advance.cmd.propertyTester1" namespace ="com.example.advance.cm...
Read more

Composite Design Pattern by example

Image
This post explains Composite design pattern with an example. When to use ? – Use Composite pattern when you have treat a collection of objects as they were once one thing. With Composite design pattern it is very easy to simplify operations over collection data structure. It reduces complexity of the code required if you were going to handle collection as special case. How to Use? - The Composite pattern consist of Component, Leaf and Composite Classes as shown below class diagram Component – Component declares the common interface that both the single and composite nodes will implements Leaf – The leaf class represent the singular atomic data type implementing he component interface.     Composite – Composite is an abstract entity which declares common functionality which are needed by concrete implementation for handling collection data. An Example -   Item.java public interface Item {     public double getPrice(); ...
Read more