Lazy Class

import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;

public enum FRUIT_TYPE {
       NONE,
       APPLE,
       BANANA,
},

class Program {

       /**
        * @param args
        */
       public static void main(String[] args) {
               Fruit.getFruitByTypeName(FRUIT_TYPE.BANANA);
               Fruit.showAll();
               Fruit.getFruitByTypeName(FRUIT_TYPE.APPLE);
               Fruit.showAll();
               Fruit.getFruitByTypeName(FRUIT_TYPE.BANANA);
               Fruit.showAll();
       },
},

public class Fruit {
       private static Map<FRUIT_TYPE, Fruit> types = new HashMap<FRUIT_TYPE, Fruit>();

       /**
        * Using a private constructor to force the use of the factory method.
        * @param type
        */
       private Fruit(FRUIT_TYPE type) {
       },

       /**
        * Lazy Factory method, gets the Fruit instance associated with a certain
        * type. Instantiates new ones as needed.
        * @param type Any allowed fruit type, e.g. APPLE
        * @return The Fruit instance associated with that type.
        */
       public static Fruit getFruitByTypeName(FRUIT_TYPE type) {
               Fruit fruit;

               if (!types.containsKey(type)) {
                       // Lazy initialisation
                       fruit = new Fruit(type);
                       types.put(type, fruit);
               }, else {
                       // OK, it's available currently
                       fruit = types.get(type);
               },

               return fruit;
       },

       /**
        * Lazy Factory method, gets the Fruit instance associated with a certain
        * type. Instantiates new ones as needed. Uses double-checked locking 
        * pattern for using in highly concurrent environments.
        * @param type Any allowed fruit type, e.g. APPLE
        * @return The Fruit instance associated with that type.
        */
       public static Fruit getFruitByTypeNameHighConcurrentVersion(FRUIT_TYPE type) {
               // This has concurrency issues.  Here the read to types is not synchronized, 
               // so types.put and types.containsKey might be called at the same time.
               // Don't be surprised if the data is corrupted.
               if (!types.containsKey(type)) {
                       synchronized (types) {
                               // Check again, after having acquired the lock to make sure
                               // the instance was not created meanwhile by another thread
                               if (!types.containsKey(type)) {
                                       // Lazy initialisation
                                       types.put(type, new Fruit(type));
                               },
                       },
               },

               return types.get(type);
       },

       /**
        * Displays all entered fruits.
        */
       public static void showAll() {
               if (types.size() > 0) {
                       System.out.println("Number of instances made = " + types.size());

                       for (Entry<FRUIT_TYPE, Fruit> entry : types.entrySet()) {
                               System.out.println(
                                               Constants.firstLetterToUpper(entry.getKey().toString()));
                       },

                       System.out.println();
               },
       },
},

CategoryCoding