工厂模式 Factory MD

时间  2019-12-10
标签 工厂 模式 factory 繁體版
原文   原文链接
Markdown版本笔记 个人GitHub首页 个人博客 个人微信 个人邮箱
MyAndroidBlogs baiqiantao baiqiantao bqt20094 baiqiantao@sina.com

目录

目录
工厂模式
简单工厂模式 Simple Factory
抽象产品类
具体产品类
工厂类
客户端使用
工厂方法模式 Factory Method
抽象产品类(产品接口)
具体产品类
工厂接口类
具体工厂类
客户端使用
抽象工厂模式 Abstract Factory
产品
产品接口
抽象产品类(产品等级)
具体产品类(产品族)
工厂
工厂接口
抽象工厂类(产生产品等级)
具体工厂类
客户端使用

工厂模式

工厂模式是咱们最经常使用的实例化对象模式了，是用工厂方法代替new操做的一种模式。著名的Jive论坛 ,就大量使用了工厂模式，工厂模式在Java程序系统能够说是随处可见。由于工厂模式就至关于建立实例对象的new，咱们常常要根据类Class生成实例 对象，如A a=new A() 工厂模式也是用来建立实例对象的，因此之后new时就要多个心眼，是否能够考虑使用工厂模式，虽然这样作，可能多作一些工做，但会给你系统带来更大的可扩 展性和尽可能少的修改量。java

简单工厂、工厂方法、抽象工厂的区别git

简单工厂，只有一个产品接口github

  • 定义：专门定义一个类来负责建立其余类的实例，被建立的实例一般具备共同的父类或实现同一接口
  • 优势：客户端能够直接消费产品，而没必要关心具体产品的实现，消除了客户端直接建立产品对象的责任，实现了对责任的分割
  • 局限：工厂类记录了全部同类产品的建立逻辑，一旦不能正常工做，整个系统都会受到影响；当产品种类多、结构复杂的时候，把全部建立工做放进一个工厂中来，会使后期程序的扩展较为困难
  • 简单工厂模式没有抽象工厂类且其工厂类的工厂方法是静态的

工厂方法，既有产品接口也有工厂接口微信

  • 定义：在简单工厂的基础上，为工厂类定义了工厂接口，让其子类决定实例化哪一个产品类
  • 优势：简单工厂是把建立产品的职能都所有放在一个类里面，而工厂方法则是把不一样的产品放在实现了工厂接口的不一样工厂类里面，分割了工厂类的职能。

抽象工厂框架

  • 定义：抽象工厂提供一个固定的接口，用于建立一系列关联或者相依存的对象，而没必要指定其具体类或其建立的细节。
  • 特色：工厂方法用来建立一个产品，它没有分类的概念，而抽象工厂则用于建立一系列产品，因此产品分类成了抽象工厂的重点。

简单工厂模式 Simple Factory

简单工厂模式（Simple Factory Pattern）又叫静态工厂方法模式（Static FactoryMethod Pattern），是经过专门定义一个类来负责建立其余类的实例，被建立的实例一般都具备共同的父类或接口。ide

做用：代替构造函数建立对象 函数

简单工厂模式中包含的角色及其相应的职责以下：性能

  • 工厂角色：这是简单工厂模式的核心，由它负责建立全部的类的内部逻辑。
  • 抽象产品角色：简单工厂模式所建立的全部对象的父类，它负责描述全部实例所共有的公共接口。
  • 具体产品角色：简单工厂所建立的具体实例对象，这些具体的产品每每都拥有共同的父类。

JDK中体现：Integer.valueOf、Class.forName code

抽象产品类

女娲造人案例对象

首先定义人类的总称，能够经过抽象类或接口定义

public interface IHuman {
    public void talk();
}

具体产品类

而后定义你所须要的具体的人种，不一样的产品具备不一样的特性或功能

class WhiteHuman implements IHuman {
    @Override
    public void talk() {
        System.out.println("白色人种会说English");
    }
}
class BlackHuman implements IHuman {
    @Override
    public void talk() {
        System.out.println("黑人能够说话，通常人听不懂");
    }
}
class YellowHuman implements IHuman {
    @Override
    public void talk() {
        System.out.println("黄色人种会说汉语");
    }
}

工厂类

public class HumanFactory {
    public static IHuman createHuman(Class<? extends IHuman> c) { //经过泛型限定了要生产的对象的类型
        //注意，生成产品的方式能够是各类各样的，好比最多见的方式为根据传入的String或int值，构造出不一样的对象
        IHuman human = null;
        try {
            human = (IHuman) Class.forName(c.getName()).newInstance(); //这里是经过反射方式生成的
        } catch (Exception e) {
            System.out.println("构造失败");
        }
        return human;
    }
}

因为简单工厂模式新增产品时须要直接修改工厂类，违反了开放封闭原则。所以可使用反射来建立实例对象，确保可以遵循开放封闭原则。

客户端使用

IHuman yellowHuman = HumanFactory.createHuman(YellowHuman.class);
yellowHuman.talk();

工厂方法模式 Factory Method

定义一个用于建立对象的接口，让子类决定实例化哪一个类。

定义了一个工厂接口，由抽象工厂类的子类决定要实例化的类是抽象产品类的哪个子类。

工厂方法让类的实例化推迟到子类。

角色说明：

  • Product（抽象产品类）：要建立的复杂对象，定义对象的公共接口。
  • ConcreteProduct（具体产品类）：实现Product接口。
  • Factory（抽象工厂类）：该方法返回一个Product类型的对象。
  • ConcreteFactory（具体工厂类）：返回ConcreteProduct实例。

优势

  • 符合开放封闭原则。新增产品时，只需增长相应的具体产品类和相应的工厂子类便可。
  • 符合单一职责原则。每一个具体工厂类只负责建立对应的产品。

缺点

  • 一个具体工厂只能建立一种具体产品，增长新产品时，还需增长相应的工厂类，系统类的个数将成对增长，增长了系统的复杂度和性能开销。
  • 引入的抽象类也会致使类结构的复杂化。

工厂方法模式新增产品时只需新建一个工厂类便可，符合开放封闭原则；而简单工厂模式须要直接修改工厂类，违反了开放封闭原则。

抽象产品类(产品接口)

public interface IWork {
    void doWork();
}

具体产品类

class StudentWork implements IWork {
    @Override
    public void doWork() {
        System.out.println("学生的工做是作做业!");
    }
}
class TeacherWork implements IWork {
    @Override
    public void doWork() {
        System.out.println("老师的工做是审批做业!");
    }
}

工厂接口类

工厂方法是建立一个框架，让【子类】决定要如何实现具体的产品。 

public interface IWorkFactory {
    IWork getWork();
}

具体工厂类

根据不一样的产品，定义不一样的具体工厂类

class StudentWorkFactory implements IWorkFactory {
    @Override
    public IWork getWork() {
        return new StudentWork();//子类决定如何实现具体的产品
    }
}
class TeacherWorkFactory implements IWorkFactory{
    @Override
    public IWork getWork() {
        return new TeacherWork();//子类决定如何实现具体的产品
    }
}

客户端使用

IWorkFactory studentWorkFactory = new StudentWorkFactory();
IWork studentWork = studentWorkFactory.getWork();//使用StudentWorkFactory构建StudentWork
studentWork.doWork();//学生的工做是作做业!

IWorkFactory teacherWorkFactory = new TeacherWorkFactory();
IWork teacherWork = teacherWorkFactory.getWork();//使用TeacherWorkFactory构建TeacherWork
teacherWork.doWork();//老师的工做是审批做业!

抽象工厂模式 Abstract Factory

为建立一组相关或者相互依赖的对象提供一个接口，而无需指定它们的具体类。

工厂方法模式每一个工厂只能建立一种类型的产品，而抽象工厂模式则可以建立多种类型的产品。

例如：硬盘工厂只生产硬盘这种产品，而电脑工厂则组合不一样的硬盘、内存、CPU等生产出电脑来。

角色说明：

  • AbstractProduct（抽象产品类）：定义产品的公共接口。
  • ConcreteProduct（具体产品类）：定义产品的具体对象，实现抽象产品类中的接口。
  • AbstractFactory（抽象工厂类）：定义工厂中用来建立不一样产品的方法。
  • ConcreteFactory（具体工厂类）：实现抽象工厂中定义的建立产品的方法。

应用场景：生产多个产品组合的对象时。
优势：代码解耦，建立实例的工做与使用实例的工做分开，使用者没必要关心类对象如何建立。
缺点：若是增长新的产品，则修改抽象工厂和全部的具体工厂，违反了开放封闭原则

工厂方法模式与抽象工厂模式比较

  • 工厂方法用来建立一个产品，它没有分类的概念，而抽象工厂则用于建立一系列产品，因此产品分类成了抽象工厂的重点。
  • 在工厂方法模式中，具体工厂负责生产具体的产品，每个具体工厂对应一种具体产品，工厂方法具备惟一性；抽象工厂模式则能够提供多个产品对象，而不是单一的产品对象。

产品

产品接口

定义人类的统称

public interface IHuman {
    void talk();
    void sex();//定义性别，注意，这个是用来给人类【分类】的，在抽象工厂中，很重要的一步就是合理的分类
}

抽象产品类(产品等级)

人类的接口定义好，而后根据接口建立两个抽象类，也就是两个【产品等级】

public abstract class AbstractYellowHuman implements IHuman {
    @Override
    public void talk() {
        System.out.println("黄种人会说汉语");
    }
}
public abstract class AbstractWhiteHuman implements IHuman {
    @Override
    public void talk() {
        System.out.println("白色人种会说English");
    }
}

具体产品类(产品族)

而后就是些实现类了

public class YellowFemaleHuman extends AbstractYellowHuman {
    @Override
    public void sex() {
        System.out.println("女性黄种人");
    }
}
public class YellowMaleHuman extends AbstractYellowHuman {
    @Override
    public void sex() {
        System.out.println("男性黄种人");
    }
}
public class WhiteFemaleHuman extends AbstractWhiteHuman {
    @Override
    public void sex() {
        System.out.println("女性白种人");
    }
}
public class WhiteMaleHuman extends AbstractWhiteHuman {
    @Override
    public void sex() {
        System.out.println("男性白种人");
    }
}

工厂

工厂接口

public interface IHumanFactory {
    IHuman createYellowHuman();//制造黄色人种
    IHuman createWhiteHuman();//制造白色人种
}

抽象工厂类(产生产品等级)

这个抽象类的目的就是减小下边实现类的代码量。

public abstract class AbstractHumanFactory implements IHumanFactory {
    protected IHuman createHuman(HumanEnum humanEnum) {
        IHuman human = null; //给定一个性别人种，建立一我的类出来 专业术语是产生产品等级
        try {
            human = (IHuman) Class.forName(humanEnum.getValue()).newInstance();//直接产生一个实例
        } catch (Exception e) {
            e.printStackTrace();
        }
        return human;
    }
}

具体工厂类

男性建立工厂，只建立男性

public class MaleHumanFactory extends AbstractHumanFactory {
    //建立一个男性白种人
    @Override
    public IHuman createWhiteHuman() {
        return super.createHuman(HumanEnum.WhiteMaleHuman);
    }
    //建立一个男性黄种人
    @Override
    public IHuman createYellowHuman() {
        return super.createHuman(HumanEnum.YelloMaleHuman);
    }
}

女性建立工厂，只建立女性

public class FemaleHumanFactory extends AbstractHumanFactory {
    //建立一个女性白种人
    @Override
    public IHuman createWhiteHuman() {
        return super.createHuman(HumanEnum.WhiteFemaleHuman);
    }
    //建立一个女性黄种人\
    @Override
    public IHuman createYellowHuman() {
        return super.createHuman(HumanEnum.YelloFemaleHuman);
    }
}

客户端使用

产品定义好了，工厂也定义好了，万事俱备只欠东风，那咱就开始造人吧，哦，不对，女娲开始造人了：

public class Test {
    //女娲创建起了两条生产线，分别是男性生产线和女性生产线
    public static void main(String[] args) {
        //第一条生产线，男性生产线，能够生产各类各样的男性
        IHumanFactory maleHumanFactory = new MaleHumanFactory();
        IHuman maleYellowHuman = maleHumanFactory.createYellowHuman();//生产黄色的男性
        IHuman maleWhiteHuman = maleHumanFactory.createWhiteHuman();//生产白色的男性

        //第二条生产线，女性生产线，能够生产各类各样的女性
        IHumanFactory femaleHumanFactory = new FemaleHumanFactory();
        IHuman femaleYellowHuman = femaleHumanFactory.createYellowHuman();//生产黄色的女性
        IHuman femaleWhiteHuman = femaleHumanFactory.createWhiteHuman();//生产白色的女性
    }
}

2019-4-6

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程