一.简单工厂模式
简单工厂模式是属于创建型模式，又叫做静态工厂方法（Static Factory Method）模式，但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现
简单理解为如果需要为一个接口new 不同的对象，不需要直接new 对象，而是由工厂类去创建对象，直接调用工厂类的创建方法即可
好处就是调用方不关心创建对象的实现逻辑，直接调用工厂类.create 方法即可，传入不同的参数，工厂类里面通过这个参数，用各种if else 来new 不同的对象，显然这不符合开闭原则，每次新加一个接口的实现类，需要在工厂类里面加一个if判断 ，这个模式适用于 接口的实现类基本固定，或者很少(3个左右)的情况
interface ICar{
void getCar();
}
class SportCar implement ICar {
void getCar(){//跑车 }
}
class JeepCar implement ICar {
void getCar(){//吉普车 }
}
class Facatory{
public ICar getCar(String name)
{
switch (name)
{
case "Sport":
return new SportCar();
case CarType.JeepCarType:
returnnew JeepCar();
case "Jeep":
return new JeepCar ();
}
}
}
main {
Facatory f = new Facatory()；
ICar car1 = f.getCar("Sport");
ICar car2 = f.getCar("Jeep");
}
二.工厂方法模式
此模式是在简单工厂模式基础上扩展，简单工厂模式只有一个工厂实现类，有一个创建方法，内部各种if判断来new对象，二工厂方法则是：有一个工厂的抽象类，里面有一个接口的抽象方法，这个方法和接口的方法一摸一样，都是抽象的，然后由这个工厂的不同工厂实现工厂类去实现这个方法，方法内部就是一个个new 不同工厂业务对应的对象，调用的时候就直接new 不同的实现工厂类即可
interface ICar{
void getCar();
}
class SportCar implement ICar {
void getCar(){//跑车 }
}
class JeepCar implement ICar {
void getCar(){//吉普车 }
}
interface Facatory{//这里也可以写抽象类，然后写公共方法，调用抽象方法，简单就用接口和接口方法理解
ICar getCar();
}
class SportCarFacatory implement Facatory {
ICar getCar(){ return new SportCar ();}
}
class JeepCarFacatory implement Facatory{
ICar getCar(){return new JeepCar () }
}
main{
Facatory f1 = new SportCarFacatory ()；
ICar car1 = f1.getCar();
Facatory f2 = new JeepCarFacatory ()；
ICar car2 = f2.getCar();
}
优点很明显，扩展很麻烦，新加一种类型的车，就新加一个类型的工厂类，不像简单工厂那样去工厂类里面加if判断，缺点就是类太多了，如果有很多类型的车的话
三.抽象工厂
就是不仅仅生产车，还会生产电脑，这样的业务，就是有一个抽象工厂类，里面有不同的抽象方法，产生不同的实现工厂
interface ICar{
void getCar();
}
class SportCar implement ICar {
void getCar(){//跑车 }
}
class JeepCar implement ICar {
void getCar(){//吉普车 }
}
不仅仅只有车子的业务，还有电脑的业务
interface IComputer{
void getComputer();
}
class NoteBookComputer implement IComputer{
void getComputer(){//笔记本 }
}
class PCComputer implement IComputer{
void getComputer(){//台式机}
}
abstract Facatory{//抽象工厂
ICar getCar();
IComputer getComputer();
}
class Facatory1 implement Facatory {//工厂1生产跑车和笔记本
ICar getCar(){ return new SportCar ();}
IComputer getComputer(){return new NoteBookComputer (); }
}
class Facatory1implement Facatory{//工厂2生产吉普车和台式机
ICar getCar(){return new JeepCar ()； }
IComputer getComputer(){return new PCComputer (); }
}
main{
Facatory f1 = new Facatory1 ();
f1.getCar();
f1.getComputer();
Facatory f2 = new Facatory2 ();
f2.getCar();
f2.getComputer();
}
可以看到一个产品可以产生一组业务，而每一组业务由不同的工厂产生，如果再加一个业务，如生产衣服，则需要改很多类的代码，不符合开闭原则
