【java设计模式】【创建模式Creational Pattern】抽象工厂模式Abstract Factory Pattern

  

package com.tn.pattern;

public class Client {
    public static void main(String[] args) {
        AbstractFactory factory=LinuxFactory.getInstance();
        factory.buttonFactory();
        factory.textFactory();
        
        factory=WindowsFactory.getInstance();
        factory.buttonFactory();
        factory.textFactory();
        
        //后期添加一个产品族OtherOs
        factory=OtherOsFactory.getInstance();
        factory.buttonFactory();
        factory.textFactory();
        
        //测试再后期添加的产品等级
        factory.radioFactory();
    }
}
/**
 * 
 * @author 
 *有多少产品等级结构，工厂角色就有多少个工厂方法；
 *有多少个产品族，就有多少个具体产品。
 *本例有Linux和Windows两个产品族，所有两个对应的工厂
 *每个产品族有button和text两个对象，所有每个工厂有创建这两个对象的工厂方法
 */
interface AbstractFactory{
    Button buttonFactory();
    Text textFactory();
    
    //为再后期添加的产品等级Radio添加对应工厂角色的工厂方法
    Radio radioFactory();
}

class LinuxFactory implements AbstractFactory{
    private static LinuxFactory linuxFactory=null;
    public static LinuxFactory getInstance(){
        if(linuxFactory==null)
            linuxFactory=new LinuxFactory();
        return linuxFactory;
    }
    
    private LinuxFactory(){}
    
    @Override
    public Button buttonFactory(){
        return new LinuxButton();
    }
    
    @Override
    public Text textFactory(){
        return new LinuxText();
    }

    //为再后期添加的产品等级Radio添加对应具体工厂角色的工厂方法的实现
    @Override
    public Radio radioFactory() {
        return new LinuxRadio();
    }
}

class WindowsFactory implements AbstractFactory{
    private static WindowsFactory windowsFactory=null;
    
    public static WindowsFactory getInstance(){
        if(windowsFactory==null)
            windowsFactory=new WindowsFactory();
        return windowsFactory;
    }
    
    private WindowsFactory(){}
    
    @Override
    public Button buttonFactory() {
        return new WindowsButton();
    }
    
    @Override
    public Text textFactory() {
        return new WindowsText();
    }

    //为再后期添加的产品等级Radio添加对应具体工厂角色的工厂方法的实现
    @Override
    public Radio radioFactory() {
        return new WindowsRadio();
    }
}

//后期添加一个产品族：OtherOs
class OtherOsFactory implements AbstractFactory{
    private static OtherOsFactory otherOsFactory=null;
    
    public static OtherOsFactory getInstance(){
        if(otherOsFactory==null)
            otherOsFactory=new OtherOsFactory();
        return otherOsFactory;
    }
    
    private OtherOsFactory(){}
    
    @Override
    public Button buttonFactory() {
        return new OtherOsButton();
    }

    @Override
    public Text textFactory() {
        return new OtherOsText();
    }

    //为再后期添加的产品等级Radio添加对应具体工厂角色的工厂方法的实现
    @Override
    public Radio radioFactory() {
        return new OtherOsRadio();
    }
}

interface Button{}

class LinuxButton implements Button{
    public LinuxButton(){
        System.out.println("LinuxButton.LinuxButton()");
    }
}

class WindowsButton implements Button{
    public WindowsButton(){
        System.out.println("WindowsButton.WindowsButton()");
    }
}

//后期添加一个产品族OtherOs对应的产品Button
class OtherOsButton implements Button{
    public OtherOsButton(){
        System.out.println("OtherOsButton.OtherOsButton()");
    }
}

interface Text{}

class LinuxText implements Text{
    public LinuxText(){
        System.out.println("LinuxText.LinuxText()");
    }
}

class WindowsText implements Text{
    public WindowsText(){
        System.out.println("WindowsText.WindowsText()");
    }
}

//后期添加一个产品族OtherOs对应的产品Text
class OtherOsText implements Text{
    public OtherOsText(){
        System.out.println("OtherOsText.OtherOsText()");
    }
}

//再后期添加一个产品等级：Radio
interface Radio{}

//为再后期添加的产品等级Radio添加对应产品族产品
class LinuxRadio implements Radio{
    public LinuxRadio(){
        System.out.println("LinuxRadio.LinuxRadio()");
    }
}

//为再后期添加的产品等级Radio添加对应产品族产品
class WindowsRadio implements Radio{
    public WindowsRadio(){
        System.out.println("WindowsRadio.WindowsRadio()");
    }
}

//为再后期添加的产品等级Radio添加对应产品族产品
class OtherOsRadio implements Radio{
    public OtherOsRadio(){
        System.out.println("OtherOsRadio.OtherOsRadio()");
    }
}