工厂模式讲解

工厂模式

1、工厂模式定义

工厂模式是java中最常用的设计模式之一。这种设计模式属于创建型模式，他提供了一种创建对象的最佳方式
在工厂模式中，我们在创建对象是不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象
通过工厂模式，将创建对象的实例的权利移交工厂，我们不在通过new来创建我们所需的对象，而是通过工厂来获取我们需要的产品。降低了产品和使用这之间的耦合关系

2、工厂模式

//手机标准模范类
public interface Phone {
    void make();
}

//制造小米手机
public class MiPhone implements Phone {

    public MiPhone() {
        this.make();
    }

    @Override
    public void make() {
        System.out.println("生产小米");
    }
}
//制造华为手机
public class HuaWeiPhone implements Phone {

    public HuaWeiPhone() {
        this.make();
    }

    @Override
    public void make() {
        System.out.println("生产华为");
    }
}

2.1简单工厂模式

//生产手机的工厂
public class PhoneFactory{
    public Phone makePhone(String phoneType){
        if (phoneType.equals("HuaWeiPhone")){
            return new HuaWeiPhone();
        }else if (phoneType.equals("MiPhone")){
            return new MiPhone();
        }
        return null;
    }
}

//测试
public class Test{
    public static void main(String[] args) {
        PhoneFactory phoneFactory = new PhoneFactory();
        Phone huaWeiPhone = phoneFactory.makePhone("HuaWeiPhone");
        Phone miPhone = phoneFactory.makePhone("MiPhone");
    }
}

2.2工厂方法模式

/**
 * 定义一个抽象工厂，其定义了产品的生产接口，但不负责具体的产品，将生产任务交给不同的派生类工厂。这样不用通过指
 *定类型来创建对象了。派生类工厂都实现了这个抽象工厂类
 *这种方式相较于简单工厂扩展性更高，在需求增加时完全符合开闭原则和依赖倒置原则
 */

//抽象工厂
public interface AbstractFactory {
    Phone makePhone();
}
//生产华为的工厂
public class HuaWeiPhoneFactory implements AbstractFactory {
    @Override
    public Phone makePhone() {
        return new HuaWeiPhone();
    }
}
//生产小米的工厂
public class MiFactory implements AbstractFactory {
    @Override
    public Phone makePhone() {
        return new MiPhone();
    }
}

2.3抽象工厂

/**
 *抽象工厂模式是工厂方法模式的升级版，后者面向单个产品，而前者面向的的是一个产品族。根据官方定义：为创建一组相
 *关/互相依赖的对象提供一个接口而无需指定它们的具体类。
 *比如一个汽车工厂要生成汽车，而每种汽车都有车门、车轮胎等一系列产品，这意味着每增加一款汽车就需要增加一个新的
 *工厂来提供新产品的实现。这时候就可以使用抽象工厂模式来进行设计。抽象工厂模式适用于一系列产品族。
 */

//增加PC产品的接口
public interface PC {
    void makePC();
}
//生产华为PC
public class HwPC implements PC {
    public HwPC(){
        this.makePC();
    }

    @Override
    public void makePC() {
        System.out.println("HwPC");
    }
}
//生产小米PC
public class MiPC implements PC {
    public MiPC(){
        this.makePC();
    }

    @Override
    public void makePC() {
        System.out.println("MiPC");
    }
}

//在抽象工厂中加入PC的生产的接口
public interface AbstractFactory {
    Phone makePhone();
    PC makePC();
}
//同时实现了抽象工厂的工厂类也要加入生产PC的方法
//小米工厂
public class MiFactory implements AbstractFactory {
    @Override
    public Phone makePhone() {
        return new MiPhone();
    }

    @Override
    public PC makePC() {
        return new MiPC();
    }
}
//华为工厂
public class HuaWeiPhoneFactory implements AbstractFactory {
    @Override
    public Phone makePhone() {
        return new HuaWeiPhone();
    }

    @Override
    public PC makePC() {
        return new HwPC();
    }
}

//测试
public class FactoryTest {
    public static void main(String[] args) {
        MiFactory miFactory = new MiFactory();
        HuaWeiPhoneFactory huaWeiPhoneFactory = new HuaWeiPhoneFactory();
        miFactory.makePhone();
        miFactory.makePC();
        huaWeiPhoneFactory.makePhone();
        huaWeiPhoneFactory.makePC();
    }
}