Java设计模式之二工厂设计模式

二、工厂模式：

1. 用于在外部创建对象，实现对象的创建和使用分离，有利于功能的复用和系统的维护。

2. 简单工厂模式：静态工厂模式

   //前期准备：一家咖啡馆
   		public interface Coffee{
   			public void buy();
   		}
   		//前期准备：具体的咖啡类
   		public class NaTie implements Coffee{
   			@Override
   			public void buy(){
   				System.out.println("拿铁咖啡");
   			}
   		}
   		public class MeiShi implements Coffee{
   			@Override
   			public void buy(){
   				System.out.println("美式咖啡");
   			}
   		}
   		public class Other implements Coffee{
   			@Override
   			public void buy(){
   				System.out.println("其他咖啡");
   			}
   		}
   		//使用工厂创建对象
   		public class Waiter{
   			public static final int MENU_NATIE=1;
   			public static final int MENU_MEISHI=2;
   			public static Restaurant getMenu(int menuType){
   				switch(menuType){
   					case MENU_NATIE:
   						return new NaTie();
   					case MENU_MEISHI:
   						retrun new MeiShi();
   					default:
   						return new Rubish();
   				}
   			}
   		}
   		//使用测试
   		public class Customer{
   			public static void main(String[] args){
   				Coffee coffee=Waiter.getMenu(Waiter.MENU_NATIE);
   				coffee.buy();
   			}
   		}
   

   特点：可扩展性差

3. 工厂方法模式：

• 拥有4个角色：抽象工厂类、具体工厂类、抽象产品类、具体产品类

  	a. 抽象工厂类
  	public abstract class Factory{
  		public abstract Product ManuFacture();
  	}
  	b. 抽象产品类
  	public abstract class Product{
  		public abstract void Show();
  	}
  	c. 具体产品类
  	public class ProductA extends Product{
  		@Override
  		public void Show(){
  			System.out.println("生产产品A");
  		}
  	}
  	public class ProductB extends Product{
  		@Override
  		public void Show(){
  			System.out.println("生产产品B");
  		}
  	}
  	d. 具体工厂类
  	public class FactoryA extends Factory{
  		@Override
  		public Product ManuFactore(){
  			return new FactoryA();
  		}
  	}
  	public class FactoryB extends Factory{
  		@Override
  		public Product ManuFactore(){
  			return new FactoryB();
  		}
  	}
  使用测试：
  	public class FactoryPattern {
  	    public static void main(String[] args){
  	        //客户要产品A
  	        FactoryA mFactoryA = new FactoryA();
  	        mFactoryA.Manufacture().Show();
  	 
  	        //客户要产品B
  	        FactoryB mFactoryB = new FactoryB();
  	        mFactoryB.Manufacture().Show();
  	    }
  	}
  

  • 简单的写法：比上面的常用

  	//定义类
  	public Coffee{}
  	public NaTie{}
  	public MeiShi{}
  	public MoKa{}
  	
  	//定义产品接口 -- 咖啡
  	public interface CoffeeFactory{
  		public abstract Coffee[] createCoffee();
  	}
  	//工厂生产产品 -- 中国工厂
  	public class ChinaFactory implements CoffeeFactory{
  		@Override
  		public Coffee[] createCoffee(){
  			return new Coffee[]{new NaTie(),new MeiShi()};
  		}
  	}
  	//工厂生产产品 -- 美国工厂
  	public class AmericaFactory implements CoffeeFactory{
  		@Override
  		public Coffee[] createCoffee(){
  			return new Coffee[]{new NaTie(),new MoKa()};
  		}
  	}
  	//使用测试：
  	public class CoffeeFactoryTest{
  		static void print(Coffee[] c){
  			for(Coffee[] coffee : c){
  				System.out.println(coffee.getName);
  			}
  		}
  		public static void main(String[] args){
  			CoffeeFactory chinaFactory=new ChinaFactory();
  			Coffee[] chinaCoffees = chinaFactory.createCoffee();
  			print(chinaCoffees);
  		}
  	}
  

4. 抽象工厂模式 : 适用于一般性
   适用场景：适用于多个产品，不同的工厂生产所有或部分产品
   实现过程：
   a. 定义接口，抽象方法为产品种类 – 产品家族
   b. 具体的工厂实现产品家族的接口，生产自己产品对象
   代码实现：

   	//定义产品类
   	public class Coffee{}
   	public class Tea{}
   	public clss Sodas{}
   	
   	//定义产品家族的接口
   	public interface DrinkFactory{
   		public Coffee createCoffee();
   		public Tea createTea();
   		public Sodas createSodas();
   	}
   	
   	//定义具体工厂创建自己的产品(咖啡+茶) -- 中国工厂
   	public class ChinaDrinkFactory implements DrinkFactory{
   		@Override
   		public Coffee createCoffee(){
   			return new NaTie();
   		}
   		@Override
   		public Tea createTea(){
   			return new MilkTea();
   		}
   		@Override
   		public Sodas createSodas(){
   			return null;
   		}
   	}
   	
   	//定义具体工厂创建自己的产品(咖啡+汽水) -- 美国工厂
   	public class AmericaDrinkFactory implements DrinkFactory{
   		@Override
   		public Coffee createCoffee(){
   			return new NaTie();
   		}
   		@Override
   		public Tea createTea(){
   			return null;
   		}
   		
   		@Override
   		public Sodas createSodas(){
   			return new Sodas();
   		}
   	}
   	
   	//使用测试
   	public class FactoryTest{
   		static void print(Drink drink){
   			if(dink==null)
   				System.out.println("--");
   			else
   				System.out.println("产品："+drink.getName());
   		}
   		public static void mian(String[] args){
   			DrinkFactory chinaFactory=new ChinaDrinkFactory();
   			Tea tea=chinaFactory.createCoffee();
   			print(tea);
   			DrinkFactory americaFactory=new AmericaDrinkFactory();
   			Sodas sodas=america.createSodas();
   			print(sodas);
   		}
   	}在这里插入代码片
   

总结：
简单工厂：只能起到将客户程序从具体类中解耦。
工厂方法：把对象创建委托给子类，可以看做是抽象工厂模式中只有单一产品的情况
抽象工厂：把对象创建委托给子类，可以在两个维度上创建对象使用。

参考链接：
https://baike.baidu.com/item/%E6%8A%BD%E8%B1%A1%E5%B7%A5%E5%8E%82%E6%A8%A1%E5%BC%8F/2361182?fr=aladdin
https://www.cnblogs.com/carryjack/p/7709861.html
https://blog.csdn.net/m0_37154839/article/details/79510255
https://blog.csdn.net/qq564425/article/details/81082242
https://blog.csdn.net/q89757316/article/details/80233864