简单工厂模式(Simple Factory Pattern)是指由一个工厂对象决定创建出哪一种产品类的实例，但是它不属于设计模式。
简单工厂适用于工厂类负责创建的对象较少的场景，且客户端只需要传入工厂类的参数，对于如何创建对象的逻辑不需要关心。
public interface ICar {
void create();
}
public class BMCar implements ICar{
@Override
public void create(){
System.out.println("制造BM车");
}
}
public class ADCar implements ICar {
@Override
public void create() {
System.out.println("制造AD车");
}
}创建一个实现工厂类，所有的对象交由该工厂类创建
public class CarFactory {
public ICar create(ICar car) {
if (car instanceof BMCar) {
return new BMCar();
} else if (car instanceof ADCar) {
return new ADCar();
} else {
return null;
}
}
}
public static void main(String[] args) {
CarFactory carFactory = new CarFactory();
ICar bm = carFactory.create(new BMCar());
bm.create();
ICar ad = carFactory.create(new ADCar());
ad.create();
}上述方式随着业务扩展，就需要修改createAnimal方法中的逻辑代码，不符合开闭原则。
可使用反射技术，即使业务变化扩展，也不需要修改AnimalFactory中的逻辑代码
public class CarFactory {
public ICar create(String className) {
try {
if (!(null == className || "".equals(className))) {
return (ICar) Class.forName(className).newInstance();
}
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
}
public static void main(String[] args) {
CarFactory carFactory = new CarFactory();
ICar bm = carFactory.create("cn.ybzy.demo.BMCar");
bm.create();
}上述方式的缺点是方法参数是字符串，有着不可控的风险。可进一步优化，使用强制类型限制，控制参数传递
public class CarFactory {
public ICar create(Class<? extends ICar> clazz) {
try {
if (!(null == clazz)) {
return clazz.newInstance();
}
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
}
public static void main(String[] args) {
CarFactory carFactory = new CarFactory();
ICar bm = carFactory.create(BMCar.class);
bm.create();
}工厂方法模式是简单工厂模式的衍生，解决了许多简单工厂模式的问题。工厂方法模式属于创建型模式。
工厂模式(Factory Pattern)是Java中最常用的设计模式之一。它提供了一种创建对象的最佳方式。
它定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。
在工厂方法模式中只需要关心所需产品对应的工厂，无须关心创建细节，而且加入新的产品符合开闭原则。
1.创建对象需要大量重复的代码。
2.客户端（应用层）不依赖于产品类实例如何被创建、实现等细节。
3.一个类通过其子类来指定创建哪个对象。
优点：
1.一个调用者想创建一个对象，只需要知道其名称就可以
2.扩展性高，如果想增加一个产品，只需要扩展一个工厂类
3.屏蔽产品的具体实现，调用者只关心产品的接口
缺点：
1.每增加一个产品时，都需要增加一个具体类和对象实现工厂，使系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。
1.抽象产品角色(Product)
工厂方法模式所创建的对象的超类型，也就是产品对象的共同父类或共同拥有的接口。
2.具体产品角色(Concrete Product)
这个角色实现了抽象产品角色所定义的接口。某具体产品有专门的具体工厂创建，它们之间往往一一对应。
3.抽象工厂角色(Creator)
是工厂方法模式的核心，与应用程序无关。任何在模式中创建的对象的工厂类必须实现这个接口。
4.具体工厂角色(Concrete Creator)
这是实现抽象工厂接口的具体工厂类，包含与应用程序密切相关的逻辑，并且受到应用程序调用以创建产品对象。
创建抽象产品角色，工厂类所创建的产品的父类，封装了产品对象的公共方法
public abstract class AbstractCar {
public abstract void run();
}
public class Car extends AbstractCar {
public void run() {
System.out.println("Car run");
}
}
public abstract class ICarFactory {
public abstract <T> T create(Class<T> clazz);
}
创建多个实现抽象工厂接口的具体工厂类。负责实现创建产品的内部逻辑，该工厂类可以被直接调用，创建所需的具体对象。
public class CarFactory extends ICarFactory {
@Override
public <T> T create(Class<T> clazz) {
Car car;
try {
car = (Car) Class.forName(clazz.getName()).getConstructor().newInstance();
} catch (Exception e) {
throw new RuntimeException(e);
}
return (T) car;
}
}通过一个工厂类，对实现了同一接口的一些类进行实例的创建
public static void main(String[] args) {
ICarFactory factory = new CarFactory();
Car car = factory.create(Car.class);
car.run();
}
Car run
