一.简单工厂模式
场景：当两种物品实现同一个接口，根据不同场景使用不同物品
目的：可以通过一个类根据不同参数实例化不同的物品，对操作统一处理。
优点：1.屏蔽内部
2.对不同的操作进行统一管理
缺点：每添加一种类别都需要修改工厂类。所以这个是不提倡的。
类图：
代码：
接口
1. public interface IProduct { 2. 3. public void method(); 4. }
实现类
1. public class ProductA implements IProduct{ 2. 3. public void method() { 4. System.out.println("产品A方法"); 5. } 6. 7. }
1. public class ProductB implements IProduct{ 2. 3. public void method() { 4. System.out.println("产品B方法"); 5. } 6. 7. }
工厂类
1. public class Creator { 2. 3. private Creator(){} 4. 5. public static IProduct createProduct(String productName){ 6. if (productName == null) { 7. return null; 8. } 9. if (productName.equals("A")) { 10. return new ProductA(); 11. }else if (productName.equals("B")) { 12. return new ProductB(); 13. }else { 14. return null; 15. } 16. } 17. }
调用
1. 复制代码 2. public class Client { 3. 4. public static void main(String[] args) { 5. IProduct product1 = Creator.createProduct("A"); 6. product1.method(); 7. 8. IProduct product2 = Creator.createProduct("B"); 9. product2.method(); 10. 11. 12. //如果不用工厂模式 13. ProductA product1 = new ProductA(); 14. ProductB product1 = new ProductB(); 15. 16. } 17. }
二.工厂方法模式
场景：简单工厂模式每添加一个物品，就需要修改工厂。为了避免修改工厂，抽象了工厂方法模式。
优点：1.避免工厂中if else的判断
2.当添加产品时。可以不修改工厂
缺点：项目类变多了，结构变复杂了。
类图：
代码：
产品接口:
1. public interface IProduct { 2. 3. public void method(); 4. }
产品实现类：
1. public class ProductA implements IProduct{ 2. 3. public void method() { 4. System.out.println("产品A方法"); 5. } 6. 7. }
1. public class ProductB implements IProduct{ 2. 3. public void method() { 4. System.out.println("产品B方法"); 5. } 6. 7. }
工厂接口：
1. public interface Factory{ 2. 3. public IProduct create(); 4. }
工厂实现类：
1. public class FactoryToA implements Factory{ 2. 3. public IProduct create(){ 4. return new ProductA(); 5. } 6. 7. }
1. public class FactoryToB implements Factory{ 2. 3. public IProduct create(){ 4. return new ProductB(); 5. } 6. 7. }
调用：
1. 2. public class Client { 3. 4. public static void main(String[] args) { 5. Facotry facotry = new FacotryToA(); 6. Product product= facotry.create(); 7. product.method(); 8. 9. Facotry facotry2 = new FacotryToB(); 10. Product product2= facotry2.create(); 11. product2.method(); 12. } 13. }
三.抽象工厂模式
场景：产品不是一个产品，而是一系列产品。
缺点：项目类变多了，结构变复杂了。
类图：
代码：
产品接口：
1. interface ProductA { 2. 3. void methodA(); 4. } 5. 6. interface ProductB { 7. 8. void methodB(); 9. }
产品实现
1. 2. class ProductA1 implements ProductA{ 3. 4. public void methodA() { 5. System.out.println("产品A1"); 6. } 7. 8. } 9. 10. class ProductA2 implements ProductA{ 11. 12. public void methodA() { 13. System.out.println("产品A2"); 14. } 15. 16. } 17. 18. class ProductB1 implements ProductB{ 19. 20. public void methodB() { 21. System.out.println("产品B1"); 22. } 23. 24. } 25. 26. class ProductB2 implements ProductB{ 27. 28. public void methodB() { 29. System.out.println("产品B2"); 30. } 31. 32. }
工厂类接口
1. public interface Facotry{ 2. 3. ProductA createProductA(); 4. 5. ProductB createProductB(); 6. 7. }
工厂实现类
1. public class FacotryToA implements Facotry{ 2. 3. public ProductA createProductA() { 4. return new ProductA1(); 5. } 6. 7. public ProductB createProductB() { 8. return new ProductB1(); 9. } 10. 11. } 12. 13. 14. public class FacotryToB implements Facotry{ 15. 16. public ProductA createProductA() { 17. return new ProductA2(); 18. } 19. 20. public ProductB createProductB() { 21. return new ProductB2(); 22. } 23. 24. }
调用：
1. public class Client { 2. 3. public static void main(String[] args) throws Exception { 4. Factory factory = new FactoryToA(); 5. ProductA productA = factory.createProductA(); 6. ProductB productB = factory.createProductB(); 7. productA.methodA(); 8. productB.methodB(); 9. 10. Factory factory = new FactoryToB() 11. productA = factory.createProductA(); 12. productB = factory.createProductB(); 13. productA.methodA(); 14. productB.methodB(); 15. } 16. }
