09_工厂和单例模式_思路与案例

农场（FruitGardener）生产的水果（Fruit）有三种：葡萄（Grape）、苹果（Apple）和草莓（Strawberry）

public interface Fruit { public void plan(); public void grow(); public void harvest(); }

public class Apple implements Fruit { public void grow() { System.out.println(\"苹果在生长...\"); } }

public class Grape implements Fruit { public void grow() { System.out.println(\"葡萄在生长...\"); } }

public class Strawberry implements Fruit { public void grow() { System.out.println(\"草莓在生长...\"); } }

public class FruitGardener { public static Fruit createFruit(String name){ if(\"apple\".equals(name)){ return new Apple(); } if(\"grape\".equals(name)){ return new Grape(); } if(\"strawberry\".equals(name)){ return new Strawberry(); } return new Apple();

} }

public class Test { public static void main(String[] args) { FruitGardener.createFruit(\"apple\").plan(); FruitGardener.createFruit(\"grape\").grow(); FruitGardener.createFruit(\"strawberry\").grow(); } }

随着业务的扩大，农场生产的果品种类越来越多，按照原有的模式，由一个农场生产所有种类的水果，导致任务过重、判断过多，逻辑过于复杂，容易出错，难于管理，牵一发而动全身，增加新品种困难，需要改进设计模式，适应于新的情况。

工厂方法模式

将农场分为若干种：苹果农场负责生产苹果、草莓农场负责生产草莓、葡萄农场负责生产葡萄

public interface Fruit {//抽象的产品 public void grow(); }

public interface FruitFactoy {//抽象的工厂 public Fruit createFruit(); }

public class Apple implements Fruit {//具体的产品 public void grow() { System.out.println(\"苹果在生长...\"); } }

public class Grape implements Fruit {//具体的产品 public void grow() { System.out.println(\"葡萄在生长...\"); } }

public class Strawberry implements Fruit {//具体的产品 public void grow() { System.out.println(\"草莓在生长...\"); }

}

public class AppleFactory implements FruitFactoy {//具体的工厂 public Fruit createFruit() { return new Apple(); } }

public class GrapeFactory implements FruitFactoy {//具体的工厂 public Fruit createFruit() { return new Grape(); } }

public class StrawberryFactory implements FruitFactoy {//具体的工厂 public Fruit createFruit() { return new Strawberry(); } }

public class Test { public static void main(String[] args) { new AppleFactory().createFruit().grow(); new GrapeFactory().createFruit().grow(); new StrawberryFactory().createFruit().grow(); } }

随着市场和企业定位变化，决定只生产苹果、葡萄和草莓等少数果品，但每一果品呈系列化，如：普通水果、绿色水果等等，原设计模式不能很好地适应这种需要，需要改进设计模式。

抽象工厂模式

农场分为两种：普通农场生产各种普通水果，绿色农场生产各种绿色水果。

public interface Fruit {//抽象的水果产品 public void grow(); }

public interface FruitFactoy {//抽象的工厂类 public Fruit createApple();//生产苹果 public Fruit createGrape();//生产葡萄 public Fruit createStrawberry();//生产草莓 }

public class Apple implements Fruit {//具体的产品 public void grow() { System.out.println(\"苹果在生长...\"); } }

public class Grape implements Fruit {//具体的产品 public void grow() { System.out.println(\"葡萄在生长...\"); } }

public class Strawberry implements Fruit {//具体的产品 public void grow() { System.out.println(\"草莓在生长...\"); } }

public class GreenApple implements Fruit {//具体的产品 public void grow() { System.out.println(\"绿色苹果在生长...\"); } }

public class GreenGrape implements Fruit {//具体的产品 public void grow() { System.out.println(\"绿色葡萄在生长...\"); } }

public class GreenStrawberry implements Fruit {//具体的产品 public void grow() { System.out.println(\"绿色草莓在生长...\"); } }

public class GeneralFruitFactory implements FruitFactory{//具体的工厂-普通农场

public class Test { public static void main(String[] args) { FruitFactory factory=null; factory=new GreenFruitFactory();

factory.createApple().grow(); factory.createGrape().grow(); factory.createStrawberry().grow(); factory=new GeneralFruitFactory(); factory.createApple().grow(); factory.createGrape().grow(); factory.createStrawberry().grow(); } } public Fruit createApple() { return new Apple(); } public Fruit createGrape() { return new Grape(); } public Fruit createStrawberry() { return new Strawberry(); } }

public class GreenFruitFactory implements FruitFactory{//具体的工厂-绿色农场 public Fruit createApple() { return new GreenApple(); } public Fruit createGrape() { return new GreenGrape(); } public Fruit createStrawberry() { return new GreenStrawberry(); } }

public class Test { public static void main(String[] args) { FruitFactory factory=null; factory=new GreenFruitFactory(); factory.createApple().grow(); factory.createGrape().grow(); factory.createStrawberry().grow();

factory=new GeneralFruitFactory(); factory.createApple().grow(); factory.createGrape().grow(); factory.createStrawberry().grow(); } }

单例模式

饿汉式

public class Apple implements Fruit { private static Apple instance=new Apple(); private Apple(){} public static Apple getInstance(){ return instance; } public void grow() { System.out.println(\"苹果在生长...\"); } }

懒汉式

public class Grape implements Fruit { private static Grape instance; private Grape(){} public synchronized static Grape getInstance(){ if(instance==null){ instance=new Grape(); } return instance; } public void grow() { System.out.println(\"葡萄在生长...\"); } }

优化后的懒汉式

public class Strawberry implements Fruit { private static class StrawberrySingleton{ private static Strawberry instance=new Strawberry(); }

public static Strawberry getInstance(){ return StrawberrySingleton.instance; } private Strawberry(){} public void grow() { System.out.println(\"草莓在生长...\"); } }

登记式

public class Apple{ private static final Map map=new HashMap(); public static Apple getInstance(String appleClassName) throws Exception{ if(appleClassName==null){ appleClassName=Apple.class.getName(); } Apple instance=map.get(appleClassName); if(instance==null){ instance=(Apple)

Class.forName(appleClassName).newInstance(); map.put(appleClassName, instance); } return instance; } public static Apple getInstance(){ try { return Apple.getInstance(null); } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); } return null; } protected Apple(){} public void grow() { System.out.println(\"苹果在生长...\"); }

}

public class RedApple extends Apple { public static Apple getInstance(){ try { return Apple.getInstance(RedApple.class.getName()); } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); } return null; } RedApple(){} public void grow() { System.out.println(\"红苹果在生长...\"); } }