简单说明各个工厂模式

简单工厂模式

说明：定义一个工厂类，根据传入的参数不同返回不同的实例
特点：被创建的实例具有共同的父类和接口

代码结构

首先创建接口Phone

public interface Phone {

    public void sayHi();
}

创建两个类

public class HWPhone implements Phone{
    @Override
    public void sayHi() {
        System.out.println("我是HW手机");
    }
}

public class XMPhone implements Phone{
    @Override
    public void sayHi() {
        System.out.println("我是XM手机");
    }
}

创建Phone工厂

public class PhoneFactory {

    public static Phone createPhone(int type) {
        switch (type) {
            case 0: return new HWPhone();
            case 1: return new XMPhone();
            default: return new HWPhone();
        }
    }

    public static void main(String[] args) {
        Phone phone = PhoneFactory.createPhone(1);
        phone.sayHi();
    }
}

main函数中通过传入type的值来确定是返回的实例
简单工厂隐藏了对象创建的细节，客户端只需要告诉工厂需要哪种手机
适用场景：
1.需要创建的对象少
2.客户端不关心对象创建的过程
缺点：违反开闭原则，需要修改工厂类进行扩展。

工厂模式

说明：
一个用于创建对象的接口，让子类决定实例化哪个对象
对类的实例化延迟到了子类中

代码结构

创建接口PhoneFactory

public interface PhoneFactory {

    Phone createPhone();

}

分别创建HWPhoneFactory和XMPhoneFactory并实现PhoneFactory接口

public class HWPhoneFactory implements PhoneFactory{
    @Override
    public Phone createPhone() {
        return new HWPhone();
    }
}

public class XMPhoneFactory implements PhoneFactory{
    @Override
    public Phone createPhone() {
        return new XMPhone();
    }
}

子类实例化对象

public class FactoryMethodDemo {

    public static void main(String[] args) {
        PhoneFactory phoneFactory = new HWPhoneFactory();
        Phone phone = phoneFactory.createPhone();
        phone.sayHi();
    }
}

若需要新增其他Phone工厂，只需要创建新的Phone工厂类并实现Phone接口即可。

优点：
遵循开闭原则
对客户端隐藏对象创建的细节
遵循单一职责原则（每个具体工厂类只负责创建对应的类）
还可以使用子类进行扩展

缺点：
新增子类时会增加系统复杂度
只支持同一类class的创建

抽象工厂模式

提供一个创建一系列相关或相互依赖对象的接口
抽象工厂模式侧重同一产品族
工厂模式侧重同一级别产品

代码结构

创建HeadSet接口

public interface HeadSet {

    void sayHi();
}

创建HWHeadSet和XMHeadSet并实现HeadSet接口

public class HWHeadSet implements HeadSet{
    @Override
    public void sayHi() {
        System.out.println("我是HW耳机");
    }
}

public class HWPhone implements Phone{
    @Override
    public void sayHi() {
        System.out.println("我是HW手机");
    }
}

创建CompanyFactory接口

public interface CompanyFactory {

    Phone createPhone();

    HeadSet createHeadSet();
}

创建HWCompanyFactory和XMCompanyFactory并实现CompanyFactory

public class HWCompanyFactory implements CompanyFactory{
    @Override
    public Phone createPhone() {
        return new HWPhone();
    }

    @Override
    public HeadSet createHeadSet() {
        return new HWHeadSet();
    }
}

public class XMCompanyFactory implements CompanyFactory{
    @Override
    public Phone createPhone() {
        return new XMPhone();
    }

    @Override
    public HeadSet createHeadSet() {
        return new XMHeadSet();
    }
}

创建main方法实例化需要的类

public class AbstractFactoryDemo {

    public static void main(String[] args) {
        CompanyFactory companyFactory = new HWCompanyFactory();
        HeadSet headSet = companyFactory.createHeadSet();
        Phone phone = companyFactory.createPhone();
        headSet.sayHi();
        phone.sayHi();
    }
}

抽象工厂模式解决了只支持能实例化一个类的弊端，可以实例化多个不同的类，但需要新增实例时还是需要修改代码，违反了开闭原则

抽象工厂模式和工厂模式的对比：
工厂方法模式：每个抽象产品派生多个具体产品类，每个抽象工厂类派生多个具体工厂类，每个具体工厂类负责一个具体产品的实例创建

抽象工厂模式：每个抽象产品派生多个具体类产品，每个抽象工厂派生多个具体工厂类，每个具体工厂负责一系列具体产品的实例创建