Java设计模式之工厂模式(三种)

工厂模式 

1. 简单工厂 

理解 

简单工厂模式的工厂类一般是使用静态方法，通过接收的参数的不同来返回不同的对象实例。 
不修改代码的话，是无法扩展的。 
例子 

产品接口 

//产品接口 
public interface ProductI { 
  public void productName(); 
} 
产品实体类 

public class ProductA implements ProductI { 
  @Override 
  public void productName() { 
      System.out.println("product A"); 
  } 
} 
public class ProductB implements ProductI { 
  @Override 
  public void productName() { 
      System.out.println("product B"); 
  } 
} 
工厂类 

// 简单工厂模式 
public class Factory { 
  public ProductI create(String productName) { 
      switch (productName) { 
          case "A": 
              return new ProductA(); 
          case "B": 
              return new ProductB(); 
          default: 
              return null; 
      } 
  } 
} 
测试类 

public class Client { 
  public static void main(String[] args) { 
      Factory factory = new Factory(); 
      ProductI productA = factory.create("A"); 
      productA.productName(); 
      // 
      ProductI productB = factory.create("B"); 
      productB.productName(); 
  } 
} 
输出 

product A 

product B 

工厂方法 
理解 

工厂方法是针 对每一种产品提供一个工厂类 。通过不同的工厂实例来创建不同的产品实例。 
在同一等级结构中， 支持增加任意产品 。 
例子 

产品接口和产品实体类和简单工厂都一样。 

工厂接口 

public interface FactoryI { 
  // 工厂的目的是为了生产产品 
  public ProductI create(); 
} 
工厂实体类 

public class FactoryA implements FactoryI { 
  @Override 
  public ProductI create() { 
      return new ProductA(); 
  } 
} 
public class FactoryB implements FactoryI { 
  @Override 
  public ProductI create() { 
      return new ProductB(); 
  } 
} 
测试类 

// 工厂方法模式 
public class Client { 
  public static void main(String[] args) { 
      FactoryI factoryA = new FactoryA(); 
      ProductI productA = factoryA.create(); 
      productA.productName(); 
      // 
      FactoryI factoryB = new FactoryB(); 
      ProductI productB = factoryB.create(); 
      productB.productName(); 
  } 
} 
输出 

product A 

product B 

抽象工厂 
理解 

抽象工厂是应对产品族概念的。比如说，每个汽车公司可能要同时生产轿车，货车，客车，那么每一个工厂都要有创建轿车，货车和客车的方法。 
应对产品族概念而生，增加新的产品线很容易，但是无法增加新的产品。 
和工厂方法的区别是，抽象工厂往往有多种方法，可以生产多种产品，即产品簇。 
例子 

抽象工厂类 

// 抽线工厂模式 
public interface AbstractFactory { 
  public ProductAI createProductA(); 
  public ProductBI createProductB(); 
} 
工厂实体类 

public class Factory1 implements AbstractFactory { 
  @Override 
  public ProductAI createProductA() { 
      return new ProductA1(); 
  } 

  @Override 
  public ProductBI createProductB() { 
      return new ProductB1(); 
  } 
} 
public class Factory2 implements AbstractFactory { 
  @Override 
  public ProductAI createProductA() { 
      return new ProductA2(); 
  } 

  @Override 
  public ProductBI createProductB() { 
      return new ProductB2(); 
  } 
} 
产品接口 

//产品接口 
public interface ProductBI { 
  public void productName(); 
} 
//产品接口 
public interface ProductAI { 
  public void productName(); 
} 
产品实体类 

public class ProductA1 implements ProductAI { 
  @Override 
  public void productName() { 
      System.out.println("product A1"); 
  } 
}