工廠模式可以分為

簡單工廠模式（也叫靜態工廠模式），工廠方法模式，抽象工廠模式

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();
    }
}