设计模式——工厂模式

72 阅读 0 评论 48 点赞

我是靠谱客的博主专一小猫咪，最近开发中收集的这篇文章主要介绍设计模式——工厂模式，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

模式名称	定义	简单说明
简单工厂模式	根据传入的参数即可返回所需的对象，而不需要知道具体类的类名	根据提供给它的数据，返回几个可能类中的一个类的实例。通常它返回的类都有一个公共的父类和公共的方法
工厂方法模式	定义一个用于创建对象的接口，让子类决定将哪一个类实例化。工厂方法模式使一个类的实例化延迟到其子类	将某一类对象的创建过程封装在单独的类中，通过引入抽象层的方式来使得对象的创建和使用更为灵活
抽象工厂模式	提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类	在一个类中可以创建多个不同类型的对象，这些对象所对应的类型都源于抽象层，使得系统具有极佳的扩展性和灵活性

1、简单工厂模式

示意图：
在这里插入图片描述
简单工厂模式结构图:

①Factory（工厂角色）：即工厂类，负责实现创建所有实例的内部逻辑；
②Product（抽象产品角色）：抽象产品角色是简单工厂模式所创建的所有对象的父类，负责描述所有实例所共有的公共接口；
③ConcreteProduct（具体产品角色）：具体产品角色是简单工厂模式的创建目标，所有创建的对象都充当这个角色的某个具体类的实例；

简单工厂实例：
某电视机厂专为各知名电视机品牌代工生产各类电视机，当需要海尔电视机时只需要在调用该工厂的工厂方法时传入参数Haier，需要海信电视机时只需要传入参数Hisense，工厂可以根据传入的不同参数返回不同品牌的电视机。

代码：

/**
 * @ClassName TV
 * @Description 抽象产品类 TV （电视机类）
 * @Author lzq
 * @Date 2019/6/3 19:59
 * @Version 1.0
 **/
public interface TV {
    public void play();
}

/**
 * @ClassName HaierTV
 * @Description 具体产品类（海尔电视机类）
 * @Author lzq
 * @Date 2019/6/3 20:00
 * @Version 1.0
 **/
public class HaierTV implements TV{
    @Override
    public void play() {
        System.out.println("海尔电视机播放中...");
    }
}

/**
 * @ClassName Hisense
 * @Description 具体产品类（海信电视机类）
 * @Author lzq
 * @Date 2019/6/3 20:01
 * @Version 1.0
 **/
public class Hisense implements TV{
    @Override
    public void play() {
        System.out.println("海信电视机播放中...");
    }
}

/**
 * @ClassName TVFactory
 * @Description 电视机工厂类
 * @Author lzq
 * @Date 2019/6/3 20:03
 * @Version 1.0
 **/
public class TVFactory {
    public static TV produceTV(String brand) throws Exception {
        if(brand.equalsIgnoreCase("Haier")) {
            System.out.println("海尔电视机生产中...");
            return new HaierTV();
        }else if(brand.equalsIgnoreCase("Hisense")) {
            System.out.println("海信电视机生产中...");
            return new Hisense();
        }else {
            throw new Exception("对不起，暂不能生产该品牌的电视机...");
        }
    }
}

/**
 * @ClassName TestDemo
 * @Description 测试类
 * @Author lzq
 * @Date 2019/6/3 20:06
 * @Version 1.0
 **/
public class TestDemo {
    public static void main(String[] args) throws Exception {
        TV tv;
        String b = "Haier";
        tv = TVFactory.produceTV(b);
        tv.play();
    }
}

运行结果：
在这里插入图片描述

2、工厂方法模式

示意图：
在这里插入图片描述
工厂方法模式结构图：

①Product（抽象产品）：抽象产品是定义产品的接口，是工厂方法模式所创建对象的超类型，也就是产品对象的共同父类或接口；
②ConcreteProduct（具体产品）：具体产品实现了抽象产品接口，某种类型的具体产品有专门的具体工厂创建，它们之间一一对应；
③Factory（抽象工厂）：在抽象工厂类中，声明了工厂方法，用于返回一个产品；
④ConcreteFactory（具体工厂）：是抽象工厂的子类，实现了抽象工厂中定义的工厂方法，并由客户调用，返回一个具体产品类的实例；

实例：和上面是同一个实例，也是生产电视机的工厂
代码：

/**
 * @ClassName TV
 * @Description 抽象产品类（电视机类）
 * @Author lzq
 * @Date 2019/6/3 20:47
 * @Version 1.0
 **/
public interface TV {
    public void play();
}

/**
 * @ClassName HaierTV
 * @Description 具体产品类（海尔电视机类）
 * @Author lzq
 * @Date 2019/6/3 20:48
 * @Version 1.0
 **/
public class HaierTV implements TV{
    @Override
    public void play() {
        System.out.println("海尔电视机播放中...");
    }
}

/**
 * @ClassName HisenseTV
 * @Description 具体产品类（海信电视机类）
 * @Author lzq
 * @Date 2019/6/3 20:49
 * @Version 1.0
 **/
public class HisenseTV implements TV{
    @Override
    public void play() {
        System.out.println("海信电视机播放中...");
    }
}

/**
 * @ClassName TVFactory
 * @Description 抽象工厂类（电视机工厂类）
 * @Author lzq
 * @Date 2019/6/3 20:50
 * @Version 1.0
 **/
public interface TVFactory {
    public TV produceTV();
}

/**
 * @ClassName HaierTVFactory
 * @Description 具体工厂类（海尔电视机厂）
 * @Author lzq
 * @Date 2019/6/3 20:52
 * @Version 1.0
 **/
public class HaierTVFactory implements TVFactory{
    @Override
    public TV produceTV() {
        System.out.println("海尔电视机厂生产海尔电视机...");
        return new HaierTV();
    }
}

/**
 * @ClassName HisenseTVFactory
 * @Description 具体工厂类（生产海信电视机工厂）
 * @Author lzq
 * @Date 2019/6/3 20:53
 * @Version 1.0
 **/
public class HisenseTVFactory implements TVFactory{
    @Override
    public TV produceTV() {
        System.out.println("海信电视机厂生产海信电视机...");
        return new HisenseTV();
    }
}

/**
 * @ClassName TestDemo
 * @Description 测试类
 * @Author lzq
 * @Date 2019/6/3 20:54
 * @Version 1.0
 **/
public class TestDemo {
    public static void main(String[] args) {
        TV tv;
        TVFactory factory;
        factory = new HaierTVFactory();
        tv = factory.produceTV();
        tv.play();
    }
}

运行结果：
在这里插入图片描述

3、抽象工厂模式

抽象工厂模式结构图：
在这里插入图片描述
①AbstractFactory（抽象工厂）：抽象工厂用于声明生成抽象产品的方法，在一个抽象工厂中可以定义一组方法，每一种方法对应一种产品等级结构；
②ConcreteFacotry（具体工厂）：具体工厂实现了抽象工厂声明的生产抽象产品的方法，生产一组产品，这些产品构成一个产品族，每一个产品都位于某个产品等级结构中；
③AbstractProduct（抽象产品）：抽象产品为每种产品声明接口，在抽象产品中定义了产品的抽象业务方法；
④ConcrteteProduct（具体产品）：具体产品定义具体工厂生产的具体产品对象，实现抽象产品接口中定义的业务方法；

实例：还是生产电视机的问题，一个电器工厂可以生产多种类型的电器，如海尔工厂生产海尔电视机、海尔空调；TCL工厂生产TCL电视机，TCL空调等，相同品牌的电器构成一个产品族，而相同的类型的电器构成一个产品等级结构：

代码：

/**
 * @ClassName TV
 * @Description 抽象产品类（电视机类）
 * @Author lzq
 * @Date 2019/6/4 22:35
 * @Version 1.0
 **/
public interface TV {
    public void play();
}

/**
 * @ClassName HaierTV
 * @Description 具体产品类（海尔电视机类）
 * @Author lzq
 * @Date 2019/6/4 22:36
 * @Version 1.0
 **/
public class HaierTV implements TV{
    @Override
    public void play() {
        System.out.println("海尔电视机播放中...");
    }
}

/**
 * @ClassName TCLTV
 * @Description 具体产品类（海尔电视机类）
 * @Author lzq
 * @Date 2019/6/4 22:37
 * @Version 1.0
 **/
public class TCLTV implements TV{
    @Override
    public void play() {
        System.out.println("TCL电视机播放中...");
    }
}

/**
 * @ClassName AirCond
 * @Description 抽象产品类（空调类）
 * @Author lzq
 * @Date 2019/6/4 22:38
 * @Version 1.0
 **/
public interface AirCond {
    public void changeTemperature();
}

/**
 * @ClassName HaierAirCond
 * @Description 具体产品类（海尔空调类）
 * @Author lzq
 * @Date 2019/6/4 22:39
 * @Version 1.0
 **/
public class HaierAirCond implements AirCond{
    @Override
    public void changeTemperature() {
        System.out.println("海尔空调开放中...");
    }
}

/**
 * @ClassName TCLAirCond
 * @Description 具体产品类（TCL空调类）
 * @Author lzq
 * @Date 2019/6/4 22:41
 * @Version 1.0
 **/
public class TCLAirCond implements AirCond{
    @Override
    public void changeTemperature() {
        System.out.println("TCL空调开放中...");
    }
}

/**
 * @ClassName EFacorty
 * @Description 抽象工厂类（电器工厂类）
 * @Author lzq
 * @Date 2019/6/4 22:42
 * @Version 1.0
 **/
public interface EFacorty {
    public TV produceTV();
    public AirCond produceAirCond();
}

/**
 * @ClassName HaierFacotry
 * @Description 具体工厂类（海尔工厂类）
 * @Author lzq
 * @Date 2019/6/4 22:44
 * @Version 1.0
 **/
public class HaierFacotry implements EFacorty{
    @Override
    public TV produceTV() {
        return new HaierTV();
    }

    @Override
    public AirCond produceAirCond() {
        return new HaierAirCond();
    }
}

/**
 * @ClassName TCLFacotry
 * @Description 具体工厂类（TCL工厂类）
 * @Author lzq
 * @Date 2019/6/4 22:45
 * @Version 1.0
 **/
public class TCLFacotry implements EFacorty{
    @Override
    public TV produceTV() {
        return new TCLTV();
    }

    @Override
    public AirCond produceAirCond() {
        return new TCLAirCond();
    }
}

/**
 * @ClassName TestDemo1
 * @Description 测试代码
 * @Author lzq
 * @Date 2019/3/27 18:50
 * @Version 1.0
 **/
public class TestDemo1 {
    public static void main(String[] args) {
        EFacorty facorty;
        TV tv;
        AirCond airCond;
        facorty = new HaierFacotry();
        tv = facorty.produceTV();
        airCond = facorty.produceAirCond();
        tv.play();
        airCond.changeTemperature();
    }
}

运行结果：
在这里插入图片描述