创建型模式——工厂模式

• 工厂模式

– 实现了创建者和调用者的分离
– 详细分类

• 简单工厂模式
• 工厂方法模式
• 抽象工厂模式

• 面想对象设计的基本原则

– OCP（开闭原则 Open-Closed Principle）:一个软件的实体应当对扩展开放，对修改关闭。
– DIP（依赖倒转原则 Dependence Inversion Principle）：要针对接口编程，不要针对实现编程。
– LoD（迪米特法则 Law of Demeter）：只与你直接的朋友通信，而避免和陌生人通信。

• 简单工厂模式

• 要点

– 简单工厂也叫静态工厂模式，不修改代码是无法扩展的。不完全满足OCP。

Phone.java

public interface Phone {

    void call();
}

IPhone.java

public class Iphone implements Phone{

    @Override
    public void call() {
        System.out.println("苹果手机打电话..");
    }
}

Huawei.java

public class Huawei implements Phone{
    @Override
    public void call() {
        System.out.println("华为手机打电话...");
    }
}

PhoneFactory.java

public class PhoneFactory {

    public static Phone createPhone(String brand) {
        if ("Iphone".equals(brand)) {
            return new Iphone();
        }else if ("Huawei".equals(brand)){
            return new Huawei();
        }else {
            return null;
        }
    }
}

Test.java

public class Test {

    public static void main(String[] args) {
        Phone phone = PhoneFactory.createPhone("Iphone");
        Phone phone1 = PhoneFactory.createPhone("Huawei");
        phone.call();
        phone1.call();
    }
}

工厂方法模式

• 要点
  – 避免工厂模式的缺点
  – 简单工厂模式只有一个工厂，工厂方法模式有一组实现了相同接口的工厂类。

Phone

public interface Phone {

    void call();
}

Iphone

public class Iphone implements Phone{

    @Override
    public void call() {
        System.out.println("苹果手机打电话..");
    }
}

Huawei

public class Huawei implements Phone{
    @Override
    public void call() {
        System.out.println("华为手机打电话...");
    }
}

PhoneFactoryMethod

public interface PhoneFactoryMethod {
    Phone createPhone();
}

IphoneFactory

public class IphoneFactory implements PhoneFactoryMethod {

    @Override
    public Phone createPhone() {
        return new Iphone();
    }
}

HuaweiFactory

public class HuaweiFactory implements PhoneFactoryMethod {

    @Override
    public Phone createPhone() {
        return new Huawei();
    }
}

• 抽象工厂模式

– 用来生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持增加产品族）
– 抽象工厂模式是工厂方法模式的升级版本，再有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。

Screen

public interface Screen {
    void show();
}

HighScreen

public class HighScreen implements Screen {
    @Override
    public void show() {
        System.out.println("高端屏幕好大气0.0");
    }
}

LowScreen

public class LowScreen implements Screen {

    @Override
    public void show() {
        System.out.println("低端屏幕不太爽0_0");
    }
}

Battery

public interface Battery {
    void capacity();
}

HighBattery

public class HighBattery implements Battery{

    @Override
    public void capacity() {
        System.out.println("高端电池容量大0.0");
    }
}

LowBattery

public class LowBattery implements Battery {

    @Override
    public void capacity() {
        System.out.println("低端电池容量小0_0");
    }
}

PhoneFactory

public interface PhoneFactory {
    Screen createScreen();
    Battery createBattery();
}

HighPhoneFactory

public class HighPhoneFactory implements PhoneFactory {
    @Override
    public Screen createScreen() {

        return new HighScreen();
    }

    @Override
    public Battery createBattery() {

        return new HighBattery();
    }
}

LowPhoneFactory

public class LowPhoneFactory implements PhoneFactory {
    @Override
    public Screen createScreen() {
        return new LowScreen();
    }

    @Override
    public Battery createBattery() {
        return new LowBattery();
    }
}

Test

public class Test {

    public static void main(String[] args) {
        PhoneFactory factory = new HighPhoneFactory();
        Screen screen = factory.createScreen();
        Battery battery = factory.createBattery();

        screen.show();
        battery.capacity();
    }
}