设计模式——工厂模式（代码分析）

代码分析可结合另一篇逻辑分析图配合工厂模式逻辑分析图

简单工厂

组成：
1）工厂
2）抽象产品
3）产品

 //1)工厂
 public class Factory {
    //可以在工厂类中添加任何你所需要的逻辑
    public static Product create(String str)
    {
        //生成ProductA
        if(str.equalsIgnoreCase("ProductA"))
        {
            return new ProductA();
        }
        else
            //生成ProductB
            if(str.equalsIgnoreCase("ProductB"))
            {
                return new ProductB();
            }
        return null;
    }
}
//2)抽象产品
public interface  Product { //声明类所需继承的共同接口，也可以是抽象类
    
}
 
//3)产品A
class ProductA implements Product {
    public ProductA() {
        System.out.println("ProductA");
    }
}
 //3)产品B
class ProductB implements Product {
    public ProductB() {
        System.out.println("ProductB");
    }
}
//测试
 public class test {
    public static void main(String[] args) {
        Factory.create("productA");
        Factory.create("ProductB");
    }
}

普通工厂

组成：
1）抽象工厂
2）具体工厂
3）抽象产品
4）具体产品

 //	1）抽象工厂
public abstract class VehicleFactory {
    abstract Moveable create();
}
//2）具体工厂
public class PlaneFactory extends VehicleFactory{
    public Moveable create() {
        return new Plane();
    }
}
//2）具体工厂
public class BroomFactory extends VehicleFactory{
    public Moveable create() {
        return new Broom();
    }
}
//3）抽象产品
public interface Moveable {
    void run();
}
//	4）具体产品
public class Plane implements Moveable {
    @Override
    public void run() {
        System.out.println("plane....");
    }
}
//	4）具体产品
public class Broom implements Moveable {
    @Override
    public void run() {
        System.out.println("broom.....");
    }
}
//测试
 public class Test {
    public static void main(String[] args) {
        VehicleFactory factory = new PlaneFactory ();
        Moveable m = factory.create();
        m.run();
    }
}

抽象工厂

组成：
1）抽象工厂
2）具体工厂
3）抽象产品
4）具体产品
区别：
在普通工厂的基础上,由于产品A和产品B的种类细化需要将产品分类更细分为1系列和2系列，所以产品A分为A-1和A-2，产品B分为B-1和B-2。A系列产品需要一个抽象类，B系列产品需要一个抽象类。两个抽象类在抽象工厂中声明。工厂方法模式只生产一个等级的产品，而抽象工厂模式可生产多个等级的产品。

//1）抽象工厂
interface Factory {
    public Product createProduct();
    public Gift createGift();

}
//2）具体工厂
class FactoryA implements Factory {
    @Override
    public Product createProduct(){
        return new ProductA();
    }
    @Override
    public Gift createGift(){
        return new GiftA();
    }
}
//2）具体工厂
class FactoryB implements Factory {
    @Override
    public Product createProduct(){
        return new ProductB();
    }
    @Override
    public Gift createGift(){
        return new GiftB();
    }
}
//3）抽象产品
interface Product{}
//3）抽象产品
interface Gift {} 

//	4）具体产品
class ProductA implements Product {
    public ProductA() {
        System.out.println("ProductA");
    }
}
//	4）具体产品
class ProductB implements Product {
    public ProductB() {
        System.out.println("ProductB");
    }
}
//	4）具体产品
class GiftA implements Gift {
    public GiftA(){
        System.out.println("GiftA");
    }
}
//	4）具体产品
class GiftB implements Gift {
    public GiftB(){
        System.out.println("GiftB");
    }
}
//测试
 public class test{
    public static void main(String[] args) {
        Factory factory = new FactoryA();
        factory.createGift();
        factory.createProduct();
    }
}