工厂模式

工厂模式的理念是，将组合中的对象与属性的绑定关系替换为更为松散的耦合关系，这样在主对象进行调用时，可以根据情况创建多种不同对象。通过这样的设计，完成了对象间的结构，如果存在后续的扩展，不再需要对原对象进行扩展，而可以直接在工厂类中定义新的对象。

简单工厂

简单工厂的即通过字段识别 + 分支控制的方式完成对象的选取和创建。

public abstract class Animal{
	public Animal(){
			System.out.println("这里是动物工厂");
	}
}

public class Dog extends Animal{
	public Dog(){
			System.out.println("得到了一只小狗");
	}
}

public class Sheep extends Animal{
	public Sheep(){
			System.out.println("得到了一只小羊");
	}
}

public class AnimalFactory{
	public static Animal getAnimal(String type){
		Animal Animal = null ;
		if (type.equals("dog")){
			Animal = new Dog();
		}else if(type.equals("sheep")){
			Animal = new Sheep();
		}
		return Animal;
	}
}

//调用
public class Test {
	public static void main(String[] args){
			Animal Animal = AnimalFactory.getAnimal("dog");
			// 输出 得到了一只小狗
			Animal = AnimalFactory.getAnimal("sheep");
			// 输出 得到了一只小羊
	}
}

这样只需要通过传入分支内容 交给工厂，由工厂自动创建对应的对象返回给处理流程中的类。

这里我们就可以注意到。对于用户来说。 通过工厂最终交付的是一个Animal 类型的对象，我们并不能观察到其Animal 之外的属性和方法定义。

工厂模式

工厂方法模式通过定义抽象工厂和具体工厂子类，将对象创建的职责下沉到每个工厂类中。用户只需持有抽象类型的引用，通过多态即可获取所需对象。这种设计避免了对工厂类内部进行条件判断，符合开闭原则。

public abstract class Animal{
	public Animal(){
			System.out.println("这里是动物工厂");
	}
}

public class Dog extends Animal{
	public Dog(){
			System.out.println("得到了一只小狗");
	}
}

public class Sheep extends Animal{
	public Sheep(){
			System.out.println("得到了一只小羊");
	}
}

// 抽象工厂类
public abstract class AnimalFactory {
    public abstract Animal getAnimal();
}

// 工厂实现类
public class DogFactory extends AnimalFactory {
    public Animal getAnimal() {
        return new Dog();
    }
}

public class SheepFactory extends AnimalFactory {
    public Animal getAnimal() {
        return new Sheep();
    }
}

// 调用
public class Test{
	public static void main(String[] args){
			AnimalFactory af = new DogFactory();
			Animal Animal =  af.getAnimal();
			// 输出 得到了一只小狗
			**af = new** SheepFactory**();**
			Animal **= af.**getAnimal**();
			// 输出 得到了一只小羊**
	}
}

简单工厂要求调用方显式传入类型参数（如 “dog”），这使得调用方必须了解具体的类型信息，导致调用方与产品的具体实现产生耦合。而在工厂方法中，调用方只依赖抽象工厂接口，由外部注入不同实现即可，不再关心具体产品类，有利于遵循依赖倒置原则。

扩展性能

当需要对当前工厂的设计进行扩展时，对于简单工厂需要做的 ：

1. 创建抽象类的新实现类
2. 设置条件分支处理创建为调用者创建对应的对象
3. 调用者接收调用目标的类型信息，调用工厂创建对应的对象

而对于工厂模式则是：

1. 创建抽象类的新实现类
2. 创建对应的工厂类实现类
3. 在业务过程中使用新的工厂创建对象

简单工厂通过参数传递的方式创建对象意味着在对象新增后业务的承载方对扩展已知，并且参数传递需要穿透更长的业务流程来完成对象的创建。工厂模式则在更小的作用域内完成了对象的创建控制。
举例来说，当新增 Cat 类时，必须修改 AnimalFactory 的 if/switch 分支，这违背了开闭原则。而在工厂方法中，只需新增 CatFactory 实现类即可，扩展更优雅。