工厂模式（简单工厂模式、工厂方法模式优缺点，使用场景）

• 工厂模式的本质

  实例化对象不使用new，用工厂方法代替
  将选择实现类，创建对象统一管理和控制。从而将调用者跟我们的实现解耦

- oop七大原则
开闭原则：一个软件的实体应当对扩展开放，对修改关闭
依赖倒转原则：要针对接口编程，不要针对实现编程
迪米特法则：只与你直接的朋友通信，而避免和陌生人通信

• 应用场景
  JDK中Calendar的getInstance方法
  JDBC中的Connection对象的获取
  Spring中IOC容器创建管理bean对象
  反射中Class对象newInstance方法

• 优点

  简单工厂模式：工厂类含有必要的判断逻辑，可以决定在什么时候创建哪一个产品类的实例，客户端可以免除直接创建产品对象的责任，而仅仅"消费"产品。简单工厂模式通过这种做法实现了对责任的分割。简单工厂模式能够根据外界给定的信息，决定究竟应该创建哪个具体类的对象。通过它，外界可以从直接创建具体产品对象的尴尬局面中摆脱出来。外界与具体类隔离开来，偶合性低。明确区分了各自的职责和权力，有利于整个软件体系结构的优化。

  工厂方法模式：工厂方法模式是为了克服简单工厂模式的缺点（主要是为了满足OCP）而设计出来的。简单工厂模式的工厂类随着产品类的增加需要增加很多方法（或代码），而工厂方法模式每个具体工厂类只完成单一任务，代码简洁。工厂方法模式完全满足OCP，即它有非常良好的扩展性。

• 缺点

  简单工厂模式：当产品有复杂的多层等级结构时，工厂类只有自己，以不变应万变，就是模式的缺点。因为工厂类集中了所有产品创建逻辑，一旦增加产品或者删除产品，整个系统都要受到影响。系统扩展困难，一旦添加新产品就不得不修改工厂逻辑，有可能造成工厂逻辑过于复杂,违背了"开放–封闭"原则(OCP).另外，简单工厂模式通常使用静态工厂方法，这使得无法由子类继承，造成工厂角色无法形成基于继承的等级结构。

  工厂方法模式：假如某个具体产品类需要进行一定的修改，很可能需要修改对应的工厂类。当同时需要修改多个产品类的时候，对工厂类的修改会变得相当麻烦。比如说，每增加一个产品，相应的也要增加一个子工厂，会加大了额外的开发量。

1.简单工厂模式（静态工厂模式）

用来生产同一等级结构的任意产品，对于增加产品，需要球盖已有代码
例如我们模仿一个车工厂，先创建车模型

	public interface Car{
		void name();
	}

然后创建实现类WuLing，模仿五菱宏光

	public class WuLing implements Car{
		@Override
		public void name(){
			System.out.println("五菱宏光")
		}
	}

创建实现类Tesla，模仿特斯拉

	public class Tesla implements Car{
		@Override
		public void name(){
			System.out.println("特斯拉")
		}
	}

创建消费者，模仿买车

	public class Consumer{
		public static void main(String[] args){
			Car wuLing = new WuLing();
			Car tesla = new Tesla();

			wuLing.name();
			tesla.name();
		}
	}

以上为原来的方法，实现买车，需要了解接口，所有的实现类，工厂模式本质为：实例化对象不使用new，我们买车，不需要知道车是怎么造的，不需要造车，我们创建工厂类

	public class CarFactory{
		public static Car getCar(String car){
			if(car.equals("五菱")){
				return new WuLing();
			}else if(car.equals("特斯拉")){
				return new Tesla();
			}else {
				return null;
			}
		}
	}

这是我们的消费者买车为

	public class Consumer{
		public static void main(String[] args){
			//Car wuLing = new WuLing();
			//Car tesla = new Tesla();
			//使用工厂创建,我们把new交给工厂
				/**
				加入造车需要很多零件，我们来造车，需要很多零件，但
				交给工厂我们不需要这些细节
				*/
			Car wuLing =CarFactory.getCar("五菱");
			Car tesla=CarFactory.getCar("特斯拉");
			wuLing.name();
			tesla.name();
		}
	}

上方就是简单工厂模式，但是不难发现简单工厂模式的弊端，如果我们新增车的类型，造不同类型的车，需要改变工厂类的代码，而我们想要实现的是新增一种车型不需要改变原来的类

2.工厂方法模式

用来生产同一等级结构的固定产品，支持增加任意产品
模仿车模型

	public interface Car{
		void name();
	}

模仿特斯拉

	public class Tesla implements Car{
		@Override
		public void name(){
			System.out.println("特斯拉")
		}
	}

模仿五菱

	public class WuLing implements Car{
		@Override
		public void name(){
			System.out.println("五菱宏光")
		}
	}

工厂方法模式，创建车工厂

public interface CarFactory{
	Car getCar();
}

创建特斯拉车工厂，造特斯拉

public class TeslaFactory implements CarFactory{
	@Override
	public Car getCar(){
		return new Tesla();
	}
}

创建五菱车工厂，造五菱

public class WuLingFactory implements CarFactory{
	@Override
	public Car getCar(){
		return new WuLing();
	}
}

模仿消费者

	public class Consumer{
		public static void main(String[] args){
			Car wuLing = new WuLingFactory().getCar();
			Car tesla = new TeslaFactory().getCar();
			wuLing.name();
			tesla.name();
		}
	}

这种情况我们再次新增一种车型，我们不需要改变原来的类，只需要新增一个车工厂，实现了解耦操作，满足开闭原则
但是这种模式如果有非常多的车，车又有很多的零件（零件接口）这种模式就满足不了我们的需求