Java设计模式

Question

I am having a class named DBObject which returns two different class objects.If the input string is water it returns object1 else object2.

My requirement is , now it it is returning objects based on if else...but in future some more objects will be added. So, instead of using elseif which makes code static, is there any dymanic way to return the class objects?

I mean can i use any java design pattern in this scenario?

code:

if(str=="water")
 return new object1()
else if...
     return new object3()
else if...
     return new object4()
else if...
     return new object5()
else if...
     return new object6()  
else
  return new object2()

Answer 1

First, replace if(str=="water") by if("water".equals(str)) . Operator == compares references while method equals() compares objects.

Second, there are several approaches. The first one is using dynamic class loading: Class.forName(className) . In your case you can hold map between symbolic names and the fully qualified class names, so your code will look like:

Class.forName(map.get(str)).newInstance()

If your concrete classes list is not so dynamic you can use enum as a factory:

enum Factory {
    red {
        public Color create() {
            new Red();
        }
    },
    green {
        public Color create() {
            new Green();
        }
    };

    public abstract Color create();
}

String colorName = ...;
Color c = Factory.valueOf(colorName).create();

Going forward you can use dynamic discovery of available implementation using for example SPI:

• http://docs.oracle.com/javase/6/docs/api/java/util/spi/package-summary.html
• http://code.google.com/p/spi/

Answer 2

You're talking about implementation level here, not design level. For implementation you need Java Reflection , which you can use like:

Object obj = Class.forName(type).newInstance();

On design level Abstract Factory is the closest pattern.

Answer 3

You could use a map, using String as key and java.lang.Class as value. Your classes probably share a common super class or interface, which you can specify as the generic type argument in your map definition:

Map<String, Class<? extends SomeSuperClass>> types = new HashMap<String, Class<? extends SomeSuperClass>>();
types.put("water", object1.class);

You can use reflection to create instances of classes (see http://docs.oracle.com/javase/1.5.0/docs/api/java/lang/Class.html for further information):

SomeSuperClass instance = types.get("water").newInstance();

Answer 4

I would replace that string with an enum. It clearly is something with a limited number of values that have special meanings, with only one instance of each required - exactly right for an enum. Plus you get better type-safety; someone can't pass in "fire" as the argument if it's not a valid thing to construct.

If you do that:

public enum ObjectType {
    WATER,
    AIR,
    EARTH
}

public static Foo createObject(ObjectType objType) {
    switch (objType) {
        case WATER: return new object1();
        case AIR:   return new object2();
        case EARTH: return new object3();
        default: // throw new IllegalArgumentException or something similar
    }
}

I think this is fairly easy to understand, and fairly stable as interfaces go.

If there's more complexity in creating the objects, then rather than explicitly coding the new object1() logic in the cases, you might want to maintain a map of factory objects of some sort (still keyed off the enum). The logic of the createObject method then would essentially be factoryMap.get(objType).constructInstance() .