静态工厂

静态工厂也叫简单工厂，类图如下

产品类：

public interface Product {
    public void print();
}
public class ConcreteProduct implements Product {
    @Override
    public void print() {
        System.out.println(this.getClass().getName());
    }
}

工厂类：

public class Creator {
    public static Product getConcreteProduct() {
        return new ConcreteProduct();
    }
    public static void main(String[] args) {
        Product product = Creator.getConcreteProduct();
        System.out.println(product);
    }
}

其实最常见的静态工厂就是单立模式，只不过工厂类和产品类是一个类而已

工厂方法

工厂方法的核心是将工厂和产品都进行了抽象，然后具体的工厂对应具体的产品
工厂方法类图：

图中产品1有工厂1生成，产品2由工厂2生成
产品类：

public interface Product {
    public void print();
}
public class ConcreteProduct1 implements Product {
    @Override
    public void print() {
        System.out.println(this.getClass().getName());
    }
}
public class ConcreteProduct2 implements Product {
    @Override
    public void print() {
        System.out.println(this.getClass().getName());
    }
}

工厂类：

public class Product1Factory implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProduct1();
    }
}
public class Product2Factory implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProduct2();
    }
}

使用类：

public static void main(String[] args) {
        Factory factory1= new Product1Factory();
        Product product1 = factory1.createProduct();
        product1.print();
        Factory factory2= new Product2Factory();
        Product product2 = factory2.createProduct();
        product2.print();
    }

抽象工厂

抽象工厂是在工厂方法的基础上进行产品的多样化

每一个工厂都需要创建产品1和产品2两种产品
产品类：

public interface Product1 {
    public void print1();
}
public class ConcreteProduct11 implements Product1 {
    @Override
    public void print1() {
        System.out.println("print1:" + this.getClass().getName());
    }
}
public class ConcreteProduct12 implements Product1 {
    @Override
    public void print1() {
        System.out.println("print1:" + this.getClass().getName());
    }
}

public interface Product2 {
    public void print2();
}
public class ConcreteProduct21 implements Product2 {
    @Override
    public void print2() {
        System.out.println("print2:" + this.getClass().getName());
    }
}
public class ConcreteProduct22 implements Product2 {
    @Override
    public void print2() {
        System.out.println("print2:" + this.getClass().getName());
    }
}

工厂类：
每一个工厂都需要创建两种产品

public interface Factory {
    public Product1 createProduct1();

    public Product2 createProduct2();
}
public class ProductFactory11 implements Factory {
    @Override
    public Product1 createProduct1() {
        return new ConcreteProduct11();
    }

    @Override
    public Product2 createProduct2() {
        return new ConcreteProduct21();
    }
}
public class ProductFactory12 implements Factory {
    @Override
    public Product1 createProduct1() {
        return new ConcreteProduct12();
    }

    @Override
    public Product2 createProduct2() {
        return new ConcreteProduct22();
    }
}

使用类：
分别创建两套产品，还可以将使用类封装起来，直接获取产品组合

public static void main(String[] args) {
        //第一大类产品创建
        Factory factory1= new ProductFactory11();
        Product1 product11 = factory1.createProduct1();
        Product2 product21 = factory1.createProduct2();
        product11.print1();
        product21.print2();

        //第二大类产品创建
        Factory factory2= new ProductFactory12();
        Product1 product12 = factory2.createProduct1();
        Product2 product22 = factory2.createProduct2();
        product12.print1();
        product22.print2();
    }

抽象工厂类太多，如果不是有系列产品需要创建，不建议使用抽象工厂