java基础(3)--工厂模式

一.普通的继承，实现模式

需要在调用时构造不同的子类

import java.util.Random;
public class FTest1 {
    //基础类(接口),玩
    interface BaseService{
        void play();
    }
    //实现1:掷硬币
    static class ServiceImpl1 implements BaseService {
        public void play() {
            int random = new Random().nextInt(2);
            System.out.println("掷硬币：" +  random);
        }
    }
    //实现2:玩骰子
    static class ServiceImpl2 implements BaseService {
        public void play() {
            int random = new Random().nextInt(6);
            System.out.println("玩骰子：" +  random);
        }
    }
    public static void main(String[] args) {
        //调用时根据实现不同来产生不同的子类
        BaseService serviceImpl1 = new ServiceImpl1();
        serviceImpl1.play();
        BaseService serviceImpl2 = new ServiceImpl2();
        serviceImpl2.play();
    }
}

---

二.简单工厂模式
2.1 描述
简单工厂模式是由一个工厂对象根据收到的消息决定要创建哪一个类的对象实例。
2.2 使用场景
工厂类负责创建的对象比较少，客户只需要传入工厂类参数，对于如何创建对象（逻辑）不关心。简单工厂模式很容易违反高内聚低耦合的原则，因此一般只在很简单的情况下使用。
2.3 优点
最大的优点在于工厂类中包含了必要的逻辑，根据客户需要的逻辑动态实例化相关的类。
2.4缺点
1 扩展性差（我想增加一种面条，除了新增一个面条产品类，还需要修改工厂类方法）
2 不同的产品需要不同额外参数的时候 不支持。

package Factory;
import java.util.Random;
public class FTest2 {
    //基础类(接口),玩
    interface BaseService{
        void play();
    }
    //实现1:掷硬币
    static class ServiceImpl1 implements BaseService {
        public void play() {
            int random = new Random().nextInt(2);
            System.out.println("掷硬币：" +  random);
        }
    }
    //实现2:玩骰子
    static class ServiceImpl2 implements BaseService {
        public void play() {
            int random = new Random().nextInt(6);
            System.out.println("玩骰子：" +  random);
        }
    }
    //简单工厂模式:一个工厂，根据传入参数不同实现不同的子类
    static class ServiceFacory{
        public static BaseService getService(String name){
            if(name.equals("硬币")) return new ServiceImpl1();
            else if(name.equals("骰子")) return new ServiceImpl2();
            return null;
        }
    }
    public static void main(String[] args) {
        //调用工厂，传入不同参数，new 不同的子类
        ServiceFacory.getService("硬币").play();
        ServiceFacory.getService("骰子").play();
    }
}

三.工厂方法模式
3.1 描述：
1.提供一个产品类的接口。产品类均要实现这个接口(也可以是abstract类，即抽象产品)。
2.提供一个工厂类的接口。工厂类均要实现这个接口(即抽象工厂)。
3.由工厂实现类创建产品类的实例。工厂实现类应有一个方法，用来实例化产品类。
3.2 场景，优缺点：
可以一定程度上解耦，消费者和产品实现类隔离开，只依赖产品接口(抽象产品)，产品实现类如何改动与消费者完全无关。
可以一定程度增加扩展性，若增加一个产品实现，只需要实现产品接口，修改工厂创建产品的方法，消费者可以无感知（若消费者不关心具体产品是什么的情况）。
可以一定程度增加代码的封装性、可读性。清楚的代码结构，对于消费者来说很少的代码量就可以完成很多工作。
等等。//TODO
另外，抽象工厂才是实际意义的工厂模式，工厂方法只是抽象工厂的一个比较常见的情况。

package Factory;
import java.util.Random;
public class FTest3 {
    //基础类(接口),玩
    interface BaseService{
        void play();
    }
    //实现1:掷硬币
    static class ServiceImpl1 implements BaseService {
        public void play() {
            int random = new Random().nextInt(2);
            System.out.println("掷硬币：" +  random);
        }
    }
    //实现2:玩骰子
    static class ServiceImpl2 implements BaseService {
        public void play() {
            int random = new Random().nextInt(6);
            System.out.println("玩骰子：" +  random);
        }
    }
    //基础类的工厂
    interface BaseServiceFactory{
        BaseService getService();
    }
    //实现1:掷硬币的工厂
    static class ServiceFactory1 implements BaseServiceFactory{

        public BaseService getService() {
            return new ServiceImpl1();
        }
    }
    //实现2:玩骰子的工厂
    static class ServiceFactory2 implements BaseServiceFactory{

        public BaseService getService() {
            return new ServiceImpl2();
        }
    }

    public static void main(String[] args) {
    //调用时只用调用每个实例化每个子类的工厂方类即可，实现了子类和调用的隔离；
    //扩展性上，增加子类时只用增加，子类及其工厂即可。
        BaseServiceFactory baseServiceFactory1 = new ServiceFactory1();
        baseServiceFactory1.getService().play();
        BaseServiceFactory baseServiceFactory2 = new ServiceFactory2();
        baseServiceFactory2.getService().play();
    }
}

四.抽象工厂模式
4.1 描述
抽象工厂是围绕一个超级工厂创建其他工厂，该超级工厂又称为其他工厂的工厂。提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们具体的类。
4.2 使用场景
系统的产品多于一个产品族，而系统只消费某一族的产品。
4.3 优点
当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

package Factory;
import java.util.Random;
public class FTest4 {
    //基础类(接口),人
    interface BaseUser{
        void getName();
    }
    //用户1：小明
    static class User1 implements BaseUser{
        public void getName() {
            System.out.println("小明");
        }
    }
    //用户2：小红
    static class User2 implements BaseUser{
        public void getName() {
            System.out.println("小红");
        }
    }
    /*-------------------------------------------------*/
    //基础类(接口),玩
    interface BaseService{
        void play();
    }
    //实现1:掷硬币
    static class ServiceImpl1 implements BaseService {
        public void play() {
            int random = new Random().nextInt(2);
            System.out.println("掷硬币：" +  random);
        }
    }
    //实现2:玩骰子
    static class ServiceImpl2 implements BaseService {
        public void play() {
            int random = new Random().nextInt(6);
            System.out.println("玩骰子：" +  random);
        }
    }
    /*-------------------------------------------------*/
    //所有基础类的抽象工厂类
     interface AbstractFactory{
        BaseUser getUser();
        BaseService getServie();
    }
    //具体的工厂类：根据场景构造特定的子类，在工厂中，可以自由组合每个基础类的实现
    static class EventFactory1 implements AbstractFactory{
        public BaseUser getUser() {
            return new User1();
        }
        public BaseService getServie() {
            return new ServiceImpl1();
        }
    }
    //具体的工厂类：根据场景构造特定的子类，在工厂中，可以自由组合每个基础类的实现
    static class EventFactory2 implements AbstractFactory{
        public BaseUser getUser() {
            return new User2();
        }
        public BaseService getServie() {
            return new ServiceImpl2();
        }
    }
    /*-------------------------------------------------*/
    //调用时根据场景实例化不同的具体工厂类
    public static void main(String[] args) {
        AbstractFactory abstractFactory1 = new EventFactory1();
        abstractFactory1.getUser().getName();
        abstractFactory1.getServie().play();

        AbstractFactory abstractFactory2 = new EventFactory2();
        abstractFactory2.getUser().getName();
        abstractFactory2.getServie().play();
    }
}

out：

小明
掷硬币：1
小红
玩骰子：1