设计模式二之工厂模式

工厂模式可以分为

简单工厂模式（也叫静态工厂模式），工厂方法模式，抽象工厂模式

1，不使用任何工厂模式，直接调用类的构造函数创建实例，缺点是耦合度太高

/**
不使用工厂模式，直接调用类的构造函数
*/
public interface Car {
    void make();
}
public class Benz implements Car{
    public Benz() {
        make();
    }
    @Override
    public void make() {
        System.out.println("make Benz");
    }
}
public class Bmw implements Car{
    public Bmw() {
        make();
    }
    @Override
    public void make() {
        System.out.println("make Bmw");
    }
}
public class Client {
    public static void main(String[] args) {
        new Benz();
        new Bmw();
    }
}

2.使用简单工厂模式（静态工厂模式），就是将创建实例的过程交给工厂，只需要告诉工厂需要什么产品，就可以得到对应的实例了。缺点是，如果需要添加新的产品，那工厂类的代码就需要跟着更改。

public interface Car {
    void make();
}
public class Benz implements Car{
    public Benz() {
        make();
    }
    @Override
    public void make() {
        System.out.println("make Benz");
    }
}
public class Bmw implements Car{
    public Bmw() {
        make();
    }
    @Override
    public void make() {
        System.out.println("make Bmw");
    }
}
public class SimpleFactory {
    public static void make(String band){
        if ("Benz".equals(band)){
            new Benz();
        }else if ("Bmw".equals(band)){
            new Bmw();
        }
    }
}
public class Client {
    public static void main(String[] args) {
        SimpleFactory.make("Benz");
        SimpleFactory.make("Bmw");
    }
}

3.工厂方法模式，就是在工厂层面也抽象一层。缺点是，如果增加了新的产品，也必须跟着增加新的工厂类。

public interface Car {
    void make();
}
public class Benz implements Car{
    public Benz() {
        make();
    }
    @Override
    public void make() {
        System.out.println("make Benz");
    }
}
public class Bmw implements Car{
    public Bmw() {
        make();
    }
    @Override
    public void make() {
        System.out.println("make Bmw");
    }
}
public interface FactoryMethod {
    void make();
}
public class BenzFactory implements FactoryMethod{
    @Override
    public void make() {
        new Benz();
    }
}
public class BwmFactory implements FactoryMethod{
    @Override
    public void make() {
        new Bmw();
    }
}
public class Client {
    public static void main(String[] args) {
        FactoryMethod f = new BenzFactory();
        f.make();
        f = new BwmFactory();
        f.make();
    }
}

4.抽象工厂模式，简单的理解就是，一个具体生产对象的工厂，可以生产多种产品。而上面的工厂方法，一次只能生产一种产品。也可以理解成工厂方法和简单工厂的结合，首先是在工厂层面进行抽象，生产产品的过程由具体的工厂完成，其次，每个具体的工厂可以根据需求生产不同的产品。

public interface Car {
    void make();
}
public interface Bike {
    void make();
}
public class Benz implements Car{
    public Benz() {
        make();
    }
    @Override
    public void make() {
        System.out.println("make Benz");
    }
}
public class Bmw implements Car{
    public Bmw() {
        make();
    }
    @Override
    public void make() {
        System.out.println("make Bmw");
    }
}
public class BenzBike implements Bike{
    public BenzBike() {
        make();
    }
    @Override
    public void make() {
        System.out.println("make BenzBike");
    }
}
public class BmwBike implements Bike{
    public BmwBike() {
        make();
    }
    @Override
    public void make() {
        System.out.println("make BmwBike");
    }
}
public interface AbsFactory {
    void make();
    void makeBike();
}
public class BenzFactory implements AbsFactory{
    @Override
    public void make() {
        new Benz();
    }
    @Override
    public void makeBike() {
        new BenzBike();
    }
}
public class BwmFactory implements AbsFactory{
    @Override
    public void make() {
        new Bmw();
    }
    @Override
    public void makeBike() {
        new BmwBike();
    }
}
public class Client {
    public static void main(String[] args) {
        AbsFactory a = new BenzFactory();
        a.make();
        a.makeBike();
        a = new BwmFactory();
        a.make();
        a.makeBike();
    }
}