设计模式-工厂模式

简单工厂模式

1）简单工厂模式的设计方案：定义一个可以实例化Phone对象的类，封建创建对象的代码。

2）看示例代码
手机标准类Phone:

public interface Phone {
    void make();
}

小米产品手机：

public class MiPhone implements Phone {
    public MiPhone() {
        this.make();
    }
    @Override
    public void make() {
        // TODO Auto-generated method stub
        System.out.println("make xiaomi phone!");
    }
}

苹果产品手机：

public class IPhone implements Phone {
    public IPhone() {
        this.make();
    }
    @Override
    public void make() {
        // TODO Auto-generated method stub
        System.out.println("make iphone!");
    }
}

PhoneFactory类：手机代工厂

public class PhoneFactory {
    public Phone makePhone(String phoneType) {
        if(phoneType.equalsIgnoreCase("MiPhone")){
            return new MiPhone();
        }
        else if(phoneType.equalsIgnoreCase("iPhone")) {
            return new IPhone();
        }
        return null;
    }
}

客户生产产品：

public class Client {
    public static void main(String[] arg) {
        PhoneFactory factory = new PhoneFactory();
        Phone miPhone = factory.makePhone("MiPhone");                   
        IPhone iPhone = (IPhone)factory.makePhone("iPhone");
    }
}

工厂方法模式

工厂方法模式相比于简单工厂模式是将具体的产品抽象到产品工厂

AbstractFactory类：生产不同产品的工厂的抽象类

public interface AbstractFactory {
    Phone makePhone();
}

MiPhoneFactory类：生产小米手机的工厂

public class MiPhoneFactory implements AbstractFactory{
    @Override
    public Phone makePhone() {
        return new MiPhone();
    }
}

IPhoneFactory类：生产苹果手机的工厂

public class IPhoneFactory implements AbstractFactory {
    @Override
    public Phone makePhone() {
        return new IPhone();
    }
}

Client类调用：

public class Client {
    public static void main(String[] args) {
         AbstractFactory miFactory = new MiPhoneFactory();
         AbstractFactory appleFactory = new IphoneFactory();
         miFactory.makePhone();            // make xiaomi phone!
         appleFactory.makePhone();        // make iphone!
    }
}

抽象工厂方法

抽象工厂是在工厂方法的模式上增加了一层抽象的产品，增加可扩展能力

PC类：定义PC产品的接口(AbstractPC)

public interface PC {
    void make();
}

MiPC类：定义小米电脑产品(MIPC)

public class MiPC implements PC {
    public MiPC() {
        this.make();
    }
    @Override
    public void make() {
        // TODO Auto-generated method stub
        System.out.println("make xiaomi PC!");
    }
}

MAC类：定义苹果电脑产品(MAC)

public class MAC implements PC {
    public MAC() {
        this.make();
    }
    @Override
    public void make() {
        // TODO Auto-generated method stub
        System.out.println("make MAC!");
    }
}

下面需要修改工厂相关的类的定义：

AbstractFactory类：增加PC产品制造接口

public interface AbstractFactory {
    Phone makePhone();
    PC makePC();
}

MiPhoneFactory类：增加小米PC的制造

public class MiPhoneFactory implements AbstractFactory{
    @Override
    public Phone makePhone() {
        return new MiPhone();
    }
    @Override
    public PC makePC() {
        return new MiPC();
    }
}

IPhoneFactory类：增加苹果PC的制造

public class IPhoneFactory implements AbstractFactory {
    @Override
    public Phone makePhone() {
        return new IPhone();
    }
    @Override
    public PC makePC() {
        return new MAC();
    }
}

演示：

public class Client {
    public static void main(String[] arg) {
        AbstractFactory miFactory = new MiPhoneFactory();
        AbstractFactory appleFactory = new IPhoneFactory();
        miFactory.makePhone();            // make xiaomi phone!
        miFactory.makePC();                // make xiaomi PC!
        appleFactory.makePhone();        // make iphone!
        appleFactory.makePC();            // make MAC!
    }
}