标签：产品 interface strong nts def 静态方法 tor 使用 name
简单工厂模式的工厂类一般是使用静态方法，通过接收的参数的不同来返回不同的对象实例。(不修改代码的话，是无法扩展的。 )
1 //产品接口 2 interface IProduct { 3 public void productName(); 4 } 5 6 //产品实体类 7 class ProductA implements IProduct { 8 @Override 9 public void productName() { 10 System.out.println("product A"); 11 } 12 } 13 14 class ProductB implements IProduct { 15 @Override 16 public void productName() { 17 System.out.println("product B"); 18 } 19 } 20 21 //工厂类 22 class Factory { 23 public IProduct create(String productName) { 24 switch (productName) { 25 case "A": 26 return new ProductA(); 27 case "B": 28 return new ProductB(); 29 default: 30 return null; 31 } 32 } 33 } 34 35 //测试类 36 class Client { 37 38 public static void main(String[] args) { 39 Factory factory = new Factory(); 40 IProduct productA = factory.create("A"); 41 productA.productName(); 42 43 IProduct productB = factory.create("B"); 44 productB.productName(); 45 } 46 } 47 48 输出 ： 49 product A 50 product B
工厂方法是针 对每一种产品提供一个工厂类 。通过不同的工厂实例来创建不同的产品实例。 (在同一等级结构中， 支持增加任意产品 。)
1 //产品接口 2 interface IProduct { 3 public void productName(); 4 } 5 6 //产品实体类 7 class ProductA implements IProduct { 8 @Override 9 public void productName() { 10 System.out.println("product A"); 11 } 12 } 13 class ProductB implements IProduct { 14 @Override 15 public void productName() { 16 System.out.println("product B"); 17 } 18 } 19 20 //工厂接口 21 interface IFactory { 22 public IProduct create(); 23 } 24 25 //工厂实体类 26 class FactoryA implements IFactory { 27 @Override 28 public IProduct create() { 29 return new ProductA(); 30 } 31 } 32 class FactoryB implements IFactory { 33 @Override 34 public IProduct create() { 35 return new ProductB(); 36 } 37 } 38 39 //测试类 40 class Client { 41 public static void main(String[] args) { 42 IFactory factoryA = new FactoryA(); 43 IProduct productA = factoryA.create(); 44 productA.productName(); 45 46 IFactory factoryB = new FactoryB(); 47 IProduct productB = factoryB.create(); 48 productB.productName(); 49 } 50 } 51 52 输出： 53 product A 54 product B
抽象工厂是应对产品族概念的。比如说，每个汽车公司可能要同时生产轿车，货车，客车，那么每一个工厂都要有创建轿车，货车和客车的方法。
(应对产品族概念而生，增加新的产品线很容易，但是无法增加新的产品。)
和工厂方法的区别是: 抽象工厂往往有多种方法，可以生产多种产品，即产品簇。
1 //抽象工厂接口 2 interface AbstractFactory { 3 public IProductA createProductA(); 4 public IProductB createProductB(); 5 } 6 7 //工厂实体类 8 class FactoryA implements AbstractFactory { 9 @Override 10 public IProductA createProductA() { 11 return new ProductA1(); 12 } 13 14 @Override 15 public IProductB createProductB() { 16 return new ProductB1(); 17 } 18 } 19 class FactoryB implements AbstractFactory { 20 @Override 21 public IProductA createProductA() { 22 return new ProductA2(); 23 } 24 25 @Override 26 public IProductB createProductB() { 27 return new ProductB2(); 28 } 29 } 30 31 //产品接口 32 interface IProductA { 33 public void productName(); 34 } 35 interface IProductB { 36 public void productName(); 37 } 38 39 //产品实体类 40 class ProductA1 implements IProductA { 41 @Override 42 public void productName() { 43 System.out.println("product A1"); 44 } 45 } 46 class ProductA2 implements IProductA { 47 @Override 48 public void productName() { 49 System.out.println("product A2"); 50 } 51 } 52 class ProductB1 implements IProductB { 53 @Override 54 public void productName() { 55 System.out.println("product B1"); 56 } 57 } 58 class ProductB2 implements IProductB { 59 @Override 60 public void productName() { 61 System.out.println("product B2"); 62 } 63 } 64 65 //测试类 66 class Client { 67 public static void main(String[] args) { 68 AbstractFactory factoryA = new FactoryA(); 69 IProductA productA1 = factoryA.createProductA(); 70 IProductB productB1 = factoryA.createProductB(); 71 productA1.productName(); 72 productB1.productName(); 73 74 AbstractFactory factoryB = new FactoryB(); 75 IProductA productA2 = factoryB.createProductA(); 76 IProductB productB2 = factoryB.createProductB(); 77 productA2.productName(); 78 productB2.productName(); 79 } 80 } 81 82 输出： 83 product A1 84 product B1 85 product A2 86 product B2
标签：产品 interface strong nts def 静态方法 tor 使用 name
原文地址：http://www.cnblogs.com/Small-music/p/7497392.html
