java 工厂模式

• 简单工厂模式 又称静态工厂模式

• • 产品接口
  • 产品的具体实现
  • 工厂类（通过不同的标志 生产不同的产品）

public class SimpleFactory
{
    public static void main(String[] args)
    {
        Factory.produce("A");
        Factory.produce("B");
    }
}

// =======================产品============================

interface Product
{

}
class ProductA implements Product
{
    public ProductA()
    {
        System.out.println("产品A");
    }

}
class ProductB implements Product
{
    public ProductB()
    {
        System.out.println("产品B");
    }

}

// ==================工厂==========================

class Factory
{
    public static Product produce(String type)
    {
        if (type.equals("A"))
            return new ProductA();
        else if (type.equals("B"))
            return new ProductB();
        else
            return null;
    }
}

• 工厂方法模式

• • 产品接口（单个）
  • 产品实现类
  • 工厂接口（单个）
  • 工厂实现类（有多个工厂实现类，但每个工厂实现类只能生产单个产品）

public class FactoryMethod
{
    public static void main(String[] args)
    {
        Factory factoryA = new FactoryA();
        factoryA.produce();
        Factory factoryB = new FactoryB();
        factoryB.produce();
    }
}

// =======================产品============================
interface Product
{
}

class ProductA implements Product
{
    public ProductA()
    {
        System.out.println("产品A");
    }
}

class ProductB implements Product
{
    public ProductB()
    {
        System.out.println("产品B");
    }
}

// ======================工厂==============================

interface Factory
{
    public Product produce();
}

class FactoryA implements Factory
{
    @Override
    public ProductA produce()
    {
        return new ProductA();
    }
}

class FactoryB implements Factory
{
    @Override
    public ProductB produce()
    {
        return new ProductB();
    }
}

• 抽象工厂模式

• • 产品接口（可以有多个产品接口）
  • 产品实现类
  • 工厂接口（只有一个）
  • 工厂实现类（有多个工厂实现类，且每个实现类可以生产多种产品）

public class AbstractFactory
{
    public static void main(String[] args)
    {
        Factory unixFactory = new UnixFactory();
        Button unixBtn = unixFactory.createButton();
        unixBtn.click();
        Text unicText = unixFactory.createText();
        unicText.write();

        Factory windowsFactory = new WindowsFactory();
        Button windowsBtn = windowsFactory.createButton();
        windowsBtn.click();
        Text windowsText = windowsFactory.createText();
        windowsText.write();

    }

}

// ======================产品Button=================

interface Button
{
    public void click();
}

class UnixButton implements Button
{
    @Override
    public void click()
    {
        System.out.println("unix button clicked!");
    }
}

class WindowsButton implements Button
{
    public void click()
    {
        System.out.println("windows button clicked!");
    }
}

// ======================产品Text=================

interface Text
{
    public void write();
}

class UnixText implements Text
{
    @Override
    public void write()
    {
        System.out.println("unix Text writed!");
    }
}

class WindowsText implements Text
{
    @Override
    public void write()
    {
        System.out.println("windows Text writed!");
    }
}

// ===========================工厂类========================

interface Factory
{
    public Button createButton();

    public Text createText();
}

class UnixFactory implements Factory
{
    @Override
    public Button createButton()
    {
        return new UnixButton();
    }

    @Override
    public Text createText()
    {
        return new UnixText();
    }
}

class WindowsFactory implements Factory
{
    @Override
    public Button createButton()
    {
        return new WindowsButton();
    }

    @Override
    public Text createText()
    {
        return new WindowsText();
    }
}

• 区别

工厂方法模式：

一个抽象产品类，可以派生出多个具体产品类。   

一个抽象工厂类，可以派生出多个具体工厂类。   

每个具体工厂类只能创建一个具体产品类的实例。

抽象工厂模式：

多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。   

一个抽象工厂类，可以派生出多个具体工厂类。   

每个具体工厂类可以创建多个具体产品类的实例。   

区别：

工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。   

工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。

两者皆可。