工厂模式

工厂模式

1.简单工厂模式

所谓简单工厂模式就是把产品进行抽象，由多种具体的产品对其进行实现，再有一个返回值为产品的实例工厂，在工厂中进行逻辑判断，根据消费者传入参数的不同返回不同的实例对象，进行业务的实现。

对产品进行抽象（假设产品是汽车）

package com.sj.simplefactory;

public interface Car {

    void name()
}

对产品进行具体的实现（由JiLi和DaZhong两个实例产品）

package com.sj.simplefactory;

public class DaZhongCar implements Car {
    @Override
    public void name() {
        System.out.println("DaZhong");
    }
}


public class JiLiCar implements Car {
    @Override
    public void name() {
        System.out.println("jili");
    }
}

创建具体的实例工厂，进行逻辑判断，返回不同的对象（根据消费者传入参数的不同，返回不同的对象）

package com.sj.simplefactory;

public class CarFactory {
    public static Car getCar(String name){

        if (name==null){
            return null;
        }
        if ("DaZhong".equals(name)){
            return new DaZhongCar();
        }else  if ("jili".equals(name)){
            return new JiLiCar();
        }
        return null;

    }
}

消费者根据传入参数的不同，获得不同的对象

package com.sj.simplefactory;

public class Consumer {

    public static void main(String[] args) {

        Car car = CarFactory.getCar("jili");
        car.name();//JiLi
        Car car1 = CarFactory.getCar("DaZhong");
        car1.name();//Dazhong

    }
}

2 工厂方法模式

因为简单工厂模式不满足开闭原则，就有了工厂方法模式，工厂方法模式不仅对产品进行了抽象，对工厂也进行了抽象，工厂的返回值是抽象的产品，不同的对象由不同的工厂生产，解决了开闭原则问题，但是也使代码变得复杂（接口和类变得更多）。

对产品进行抽象（假设产品是汽车）

package com.sj.methodfactory;

public interface Car {

    void name()
}

对产品进行具体的实现（由JiLi和DaZhong两个实例产品）

package com.sj.methodfactory;

public class DaZhongCar implements Car {
    @Override
    public void name() {
        System.out.println("DaZhong");
    }
}

public class JiLiCar implements Car {
    @Override
    public void name() {
        System.out.println("jili");
    }
}

对工厂进行抽象，定义一个返回值为产品的抽象方法

package com.sj.methodfactory;


public interface Factory {
    Car getCar();
}

根据不同的实例对象创建不同的实例工厂

package com.sj.methodfactory;

public class DaZhongFactory implements Factory {
    @Override
    public Car getCar() {
        return new DaZhongCar();
    }
}


public class JiLiFactory implements Factory {
    @Override
    public Car getCar() {

        return new JiLiCar();
    }
}

创建消费者进行代码的测试

package com.sj.methodfactory;

/**
 * @Author: zhushijie
 * @Date: 2020/7/19
 * @Version: 1.0
 */
public class Consumer {

    public static void main(String[] args) {

        Factory factory = new JiLiFactory();
        Car car = factory.getCar();
        car.name();//JiLi


        Factory factory1 = new DaZhongFactory();
        Car car1 = factory1.getCar();
        car1.name();//DaZhong

    }
}

2 抽象工厂模式

抽象工厂模式就是提供一个接口，用于创建相关或者依赖对象的家族，而不需要明确指定具体类。它允许客户端使用抽象的接口来创建一组相关的产品，而不需要关心实际产出的具体产品是什么。客户就可以从具体的产品中被解耦。它的优点是隔离了具体类的生成，使得客户端不需要知道什么被创建了，而缺点就在于新增新的行为会比较麻烦，因为当添加一个新的产品对象时，需要更改接口及其下的所有子类。

特点：

• 可以在类的内部对产品族中相关联的多等级产品共同管理，而不必专门引入多个新的类来进行管理。
• 当增加一个新的产品族时不需要修改原代码，满足开闭原则。
• 其缺点是：当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。

抽象工厂模式的主要角色 :

• 抽象工厂（Abstract Factory）：提供了创建产品的接口，它包含多个创建产品的方法 new Product()，可以创建多个不同等级的产品。
• 具体工厂（Concrete Factory）：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。
• 抽象产品（Product）：定义了产品的规范，描述了产品的主要功能和特性，抽象工厂模式有多个抽象产品。
• 具体产品（Concrete Product）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间是多对一的关系。

声明抽象产品(以手机和手表为例)

package com.sj.abstractfactory;

public interface Phone {

    void call();

}

package com.sj.abstractfactory;

public interface Watch {

    void look();

}

对产品进行实现(以华为手机 华为手表 小米手机 小米手表分别实现)

package com.sj.abstractfactory;

public class XiaoMiPhone implements Phone {
    @Override
    public void call() {
        System.out.println("用小米手机打电话");
    }
}

package com.sj.abstractfactory;

public class XiaoMiWatch implements Watch {
    @Override
    public void look() {
        System.out.println("用小米手表看时间");
    }
}

package com.sj.abstractfactory;

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

package com.sj.abstractfactory;

public class HuaWeiWatch implements Watch {
    @Override
    public void look() {
        System.out.println("用华为手表看时间");
    }
}

定义抽象工厂，生产抽象产品

package com.sj.abstractfactory;

public interface Factory {

    Phone createPhone();

    Watch createWatch();

}

实现抽象工厂，生产具体产品

package com.sj.abstractfactory;

public class XiaoMiFactory implements Factory {
    @Override
    public Phone createPhone() {
        return new XiaoMiPhone();
    }

    @Override
    public Watch createWatch() {
        return new XiaoMiWatch();
    }
}


package com.sj.abstractfactory;

public class HuaWeiFactory implements Factory {


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

    @Override
    public Watch createWatch() {
        return new HuaWeiWatch();
    }
}

创建消费者，进行测试

package com.sj.abstractfactory;

public class Consumer {

    public static void main(String[] args) {

        Factory xiaoMiFactory= new XiaoMiFactory();
        Factory huaWeiFactory = new HuaWeiFactory();


        //小米工厂生产产品
        Phone xiaoMiFactoryPhone = xiaoMiFactory.createPhone();
        Watch xiaoMiFactoryWatch = xiaoMiFactory.createWatch();
        xiaoMiFactoryPhone.call();//用小米手机打电话
        xiaoMiFactoryWatch.look();//用小米手表看时间


        //华为工厂生产产品
        Phone huaWeiFactoryPhone = huaWeiFactory.createPhone();
        Watch huaWeiFactoryWatch = huaWeiFactory.createWatch();
        huaWeiFactoryPhone.call();//用华为手机打电话
        huaWeiFactoryWatch.look();//用华为手表看时间


    }
}