【51】java设计模式-工厂设计模式剖析

工厂设计设计模式的分类：

工厂模式在《Java与模式》中分为三类：

1）简单工厂模式（Simple Factory）：不利于产生系列产品；

2）工厂方法模式（Factory Method）：又称为多形性工厂；

3）抽象工厂模式（Abstract Factory）：又称为工具箱，产生产品族，但不利于产生新的产品；

这三种模式从上到下逐步抽象，并且更具一般性。

GOF在《设计模式》一书中将工厂模式分为两类：工厂方法模式（Factory Method）与抽象工厂模式（Abstract Factory）。将简单工厂模式（Simple Factory）看为工厂方法模式的一种特例，两者归为一类。

举例：

1）还没有工厂时代：假如还没有工业革命，如果一个客户要一款宝马车,一般的做法是客户去创建一款宝马车，然后拿来用。

2）简单工厂模式：后来出现工业革命。用户不用去创建宝马车。因为客户有一个工厂来帮他创建宝马.想要什么车，这个工厂就可以建。比如想要320i系列车。工厂就创建这个系列的车。即工厂可以创建产品。

3）工厂方法模式时代：为了满足客户，宝马车系列越来越多，如320i，523i,30li等系列一个工厂无法创建所有的宝马系列。于是由单独分出来多个具体的工厂。每个具体工厂创建一种系列。即具体工厂类只能创建一个具体产品。但是宝马工厂还是个抽象。你需要指定某个具体的工厂才能生产车出来。

4）抽象工厂模式时代：随着客户的要求越来越高，宝马车必须配置空调。于是这个工厂开始生产宝马车和需要的空调。

最终是客户只要对宝马的销售员说：我要523i空调车，销售员就直接给他523i空调车了。而不用自己去创建523i空调车宝马车.

这就是工厂模式。

区别：

工厂方法模式：

一个抽象产品类，可以派生出多个具体产品类。

一个抽象工厂类，可以派生出多个具体工厂类。

每个具体工厂类只能创建一个具体产品类的实例。

抽象工厂模式：

多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。

一个抽象工厂类，可以派生出多个具体工厂类。

每个具体工厂类可以创建多个具体产品类的实例。

区别：

工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。

工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。

两者皆可。

简单工厂模式

public class BMW320 {
    public BMW320(){
        System.out.println("制造-->BMW320");
    }
}  

public class BMW523 {
    public BMW523(){
        System.out.println("制造-->BMW523");
    }
}  

public class Customer {
    public static void main(String[] args) {
        BMW320 bmw320 = new BMW320();
        BMW523 bmw523 = new BMW523();
    }
}

把创建宝马的操作细节都放到了工厂里面去,客户直接使用工厂的创建工厂方法,传入想要的宝马车型号就行了,而不必去知道创建的细节.这就是工业革命了：简单工厂模式

产品类：

[java] view plain copy print?在CODE上查看代码片派生到我的代码片
abstract class BMW {
    public BMW(){  

    }
}  

public class BMW320 extends BMW {
    public BMW320() {
        System.out.println("制造-->BMW320");
    }
}
public class BMW523 extends BMW{
    public BMW523(){
        System.out.println("制造-->BMW523");
    }
}
工厂类：

[java] view plain copy print?在CODE上查看代码片派生到我的代码片
public class Factory {
    public BMW createBMW(int type) {
        switch (type) {  

        case 320:
            return new BMW320();  

        case 523:
            return new BMW523();  

        default:
            break;
        }
        return null;
    }
}  

客户类：

[java] view plain copy print?在CODE上查看代码片派生到我的代码片
public class Customer {
    public static void main(String[] args) {
        Factory factory = new Factory();
        BMW bmw320 = factory.createBMW(320);
        BMW bmw523 = factory.createBMW(523);
    }
}

它的组成：

1) 工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑，用来创建产品

2) 抽象产品角色：它一般是具体产品继承的父类或者实现的接口。

3) 具体产品角色：工厂类所创建的对象就是此角色的实例。在Java中由一个具体类实现。

当有新的车加入时，需要更新代码也实现对新车的支持。这就违反了开闭原则（Open-Close Principle）。可以利用反射（Reflection）解决该问题。

使用反射实现扩展性：

“`

public class CarFactory2 {

private static final Logger LOG = LoggerFactory.getLogger(CarFactory2.class);

public static Car newCar() {

Car car = null;

String name = null;

try {

XMLConfiguration config = new XMLConfiguration(“car.xml”);

name = config.getString(“factory2.class”);

} catch (ConfigurationException ex) {

LOG.error(“Parsing xml configuration file failed”, ex);

}

try {
  car = (Car)Class.forName(name).newInstance();
  LOG.info("Created car class name is {}", name);
} catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
  LOG.error("Instantiate car {} failed", name);
}
return car;

}

}

从上面代码中可以看到，之后如果需要引入新的Car，只需要在配置文件中指定该Car的完整类名（包括package名），CarFactory2即可通过反射将其实例化。实现了对扩展的开放，同时保证了对修改的关闭。熟悉Spring的读者应该会想到Spring IoC的实现。

简单工厂模式优点：
---------

1.工厂类是整个简单工厂模式的关键所在。它包含必要的判断逻辑，能够根据外界给定的信息（配置，或者参数），决定究竟应该创建哪个具体类的对象。用户在使用时可以直接根据工厂类去创建所需的实例，而无需了解这些对象是如何创建以及如何组织的。有利于整个软件体系结构的优化。
2.通过引入配置文件和反射，可以在不修改任何客户端代码的情况下更换和增加新的具体产品类，在一定程度上提高了系统的灵活性（如CarFactory2）。
3.客户端无须知道所创建的具体产品类的类名，只需要知道具体产品类所对应的参数即可，对于一些复杂的类名，通过简单工厂模式可以减少使用者的记忆量（如CarFactory3）。

简单工厂模式缺点：
---------

1.由于工厂类集中了所有实例的创建逻辑，这就直接导致一旦这个工厂出了问题，所有的客户端都会受到牵连。
2.由于简单工厂模式的产品是基于一个共同的抽象类或者接口，这样一来，产品的种类增加的时候，即有不同的产品接口或者抽象类的时候，工厂类就需要判断何时创建何种接口的产品，这就和创建何种种类的产品相互混淆在了一起，违背了单一职责原则，导致系统丧失灵活性和可维护性。
3.正如上文提到的，一般情况下（如CarFactory1），简单工厂模式违背了“开放-关闭原则”，因为当我们新增加一个产品的时候必须修改工厂类，相应的工厂类就需要重新编译一遍。但这一点可以利用反射（CarFactory3在本质上也是利用反射）在一定程度上解决（如CarFactory2）。
使用反射可以使简单工厂在一定条件下满足“开放-关闭原则”，但这仅限于产品类的构造及初始化相同的场景。对于各产品实例化或者初始化不同的场景，很难利用反射满足“开放-关闭”原则。
4.简单工厂模式由于使用了静态工厂方法，造成工厂角色无法形成基于继承的等级结构。这一点笔者持保留态度，因为继承不是目的，如果没有这样的需求，这一点完全不算缺点，例如JDBC的DriverManager。

工厂方法模式 ：
==
 工厂方法模式去掉了简单工厂模式中工厂方法的静态属性，使得它可以被子类继承。这样在简单工厂模式里集中在工厂方法上的压力可以由工厂方法模式里不同的工厂子类来分担。 

工厂方法模式组成：
---------

 1)抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。
 2)具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。
 3)抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。
 4)具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。
       工厂方法模式使用继承自抽象工厂角色的多个子类来代替简单工厂模式中的“上帝类”。正如上面所说，这样便分担了对象承受的压力；而且这样使得结构变得灵活 起来——当有新的产品产生时，只要按照抽象产品角色、抽象工厂角色提供的合同来生成，那么就可以被客户使用，而不必去修改任何已有 的代码。可以看出工厂角色的结构也是符合开闭原则的！

产品类：

[java] view plain copy print?在CODE上查看代码片派生到我的代码片

abstract class BMW {

public BMW(){

}

}

public class BMW320 extends BMW {

public BMW320() {

System.out.println(“制造–>BMW320”);

}

}

public class BMW523 extends BMW{

public BMW523(){

System.out.println(“制造–>BMW523”);

}

}

创建工厂类：

[java] view plain copy print?在CODE上查看代码片派生到我的代码片

interface FactoryBMW {

BMW createBMW();

}

public class FactoryBMW320 implements FactoryBMW{

@Override
public BMW320 createBMW() {  

    return new BMW320();
}

}

public class FactoryBMW523 implements FactoryBMW {

@Override

public BMW523 createBMW() {

    return new BMW523();
}

}

客户类：

[java] view plain copy print?在CODE上查看代码片派生到我的代码片

public class Customer {

public static void main(String[] args) {

FactoryBMW320 factoryBMW320 = new FactoryBMW320();

BMW320 bmw320 = factoryBMW320.createBMW();

    FactoryBMW523 factoryBMW523 = new FactoryBMW523();
    BMW523 bmw523 = factoryBMW523.createBMW();
}

}


抽象工厂模式：
==
当每个抽象产品都有多于一个的具体子类的时候（空调有型号A和B两种，发动机也有型号A和B两种），工厂角色怎么知道实例化哪一个子类呢？比如每个抽象产品角色都有两个具体产品（产品空调有两个具体产品空调A和空调B）。抽象工厂模式提供两个具体工厂角色（宝马320系列工厂和宝马230系列工厂），分别对应于这两个具体产品角色，每一个具体工厂角色只负责某一个产品角色的实例化。每一个具体工厂类只负责创建抽象产品的某一个具体子类的实例。
## 抽象工厂模式代码 ##

产品类：

[java] view plain copy print?在CODE上查看代码片派生到我的代码片

//发动机以及型号

public interface Engine {

}

public class EngineA extends Engine{

public EngineA(){

System.out.println(“制造–>EngineA”);

}

}

public class EngineBextends Engine{

public EngineB(){

System.out.println(“制造–>EngineB”);

}

}

//空调以及型号

public interface Aircondition {

}

public class AirconditionA extends Aircondition{

public AirconditionA(){

System.out.println(“制造–>AirconditionA”);

}

}

public class AirconditionB extends Aircondition{

public AirconditionB(){

System.out.println(“制造–>AirconditionB”);

}

}

创建工厂类：

[java] view plain copy print?在CODE上查看代码片派生到我的代码片

//创建工厂的接口

public interface AbstractFactory {

//制造发动机

public Engine createEngine();

//制造空调

public Aircondition createAircondition();

}

//为宝马320系列生产配件

public class FactoryBMW320 implements AbstractFactory{

@Override
public Engine createEngine() {
    return new EngineA();
}
@Override
public Aircondition createAircondition() {
    return new AirconditionA();
}

}

//宝马523系列

public class FactoryBMW523 implements AbstractFactory {

 @Override
public Engine createEngine() {
    return new EngineB();
}
@Override
public Aircondition createAircondition() {
    return new AirconditionB();
}

}

客户:

[java] view plain copy print?在CODE上查看代码片派生到我的代码片

public class Customer {

public static void main(String[] args){

//生产宝马320系列配件

FactoryBMW320 factoryBMW320 = new FactoryBMW320();

factoryBMW320.createEngine();

factoryBMW320.createAircondition();

    //生产宝马523系列配件
    FactoryBMW523 factoryBMW523 = new FactoryBMW523();
    factoryBMW320.createEngine();
    factoryBMW320.createAircondition();
}

}

“`

欢迎入群：

公众号IT面试题汇总讨论群

如果扫描不进去，加我微信（rdst6029930）拉你。

扫我微信二维码加我

欢迎关注《IT面试题汇总》微信订阅号。每天推送经典面试题和面试心得技巧，都是干货！

微信订阅号二维码如下：

参考：

http://www.jasongj.com/design_pattern/simple_factory/

http://blog.csdn.net/jason0539/article/details/23020989

http://blog.csdn.net/jason0539/article/details/44976775

时间： 2024-10-30 03:33:39

【51】java设计模式-工厂设计模式剖析的相关文章

java设计模式----工厂设计模式

目录   1.面向对象设计的基本原则 2.简单工厂模式 3.工厂方法模式 4.抽象工厂模式   工厂设计模式的核心本质: 1.实例化对象,用工厂方法代替new操作. 2.将选择实现类.创建对象统一管理和控制.从而将调用者跟我们的实现类解耦. 一.面向对象设计的基本原则 1.OCP(开闭原则,Open-Closed Principle):一个软件的实体应当对扩展开放,对修改关闭. 2.DIP(依赖倒转原则,Dependence Inversion Principle):要针对接口编程不要针对实现编

php设计模式-工厂设计模式

概念: 工厂设计模式提供获取某个对象的新实例的一个接口,同时使调用代码避免确定实际实例化基类步骤. 很多高级模式都是依赖于工厂模式. 原文地址:https://www.cnblogs.com/sjhsszl/p/8729217.html

java--面向对象--设计模式--工厂模式

今天第一次接触Java的工厂设计模式,我可是闻名已久啊. 看下面: Java代码   interface Fruit { public void eat(); } class Apple implements Fruit { public void eat() { System.out.println("吃苹果"); } } class Orange implements Fruit { public void eat() { System.out.println("吃桔子&

接口和工厂设计模式

接口又是怎么一回事呢 ?接口就是一组规范 ,是在定义一种标准 .这说起来真的挺别扭的 ,我是这么理解的 ,当我们的抽象类全是抽象方法时 ,我们就可以定义接口了 ,那为什么不能继续用抽象类来表示而要定义一个接口呢 ?由于 Java 本身有单继承的局限 ,而接口是可以多实现的 .所以我就额外定义一个 interface 来表示哪些全是抽象方法的类 .相比于抽象类 ,我们可以感受出 Java 设计的初衷 ,抽象类是作为模板使用 ,对部分方法进行抽象 ,而接口更多的是对行为或是方法的抽象 . 那接口用什

设计模式Java之工厂方法。

1,工厂方法: 使用一个工厂的方法来创建产品. 1 package WHP; 2 //产品依赖于抽象 3 public interface IRunable { 4 public void Run(); 5 } 1 package WHP; 2 //具体实现 3 public class Car implements IRunable { 4 public void Run(){ 5 System.out.println("Car running."); 6 } 7 } 1 packa

Java 工厂设计模式

//使用new关键字创建对象的缺点是耦合度太高,工厂设计模式利用Java的反射机制来实例化对象降低了这种耦合度 package cn.buaa; import java.util.Date; interface Fruit{  public void eat(); } class Apple implements Fruit{  @Override  public void eat() {   System.out.println("吃苹果");     } } class Orang

JAVA学习笔记-----设计模式之工厂模式

1.设计模式---------->工厂模式: Sender.java package me.ele.mytest; public interface Sender {    public void send(); } 2.MailSend package me.ele.mytest; public class MailSend implements Sender {     @Override     public  void send()     {         System.out.pr

Java代码实现设计模式之工厂模式

工厂设计模式:为了解耦合,把对象的创建者与对象的使用者分开. 生活中:批量生产产品 Java中:批量生产对象 分工: 把生产(创建)对象与使用对象分开了,解耦合 1.简单工厂模式 优点:代码比较简洁 缺点:如果增加新的产品类型,需要修改工厂类 违反了面向对象的一个开发原则:对扩展开放,对修改关闭 2.工厂方法模式 (1)为了生产对象与使用对象分开 (2)如果增加新产品,就不需要修改原来的工厂类 优点:遵循了增加新产品,不修改原来的类的原则, 缺点:类太多了 示例:简单工厂模式 class Sim

java设计模式之工厂设计模式（Factory）

设计模式根据使用类型可以分为三种:1. 创建模式: Factory (工厂模式). Singleton (单态). Builder ( (建造者模式). Prototype ( (原型模式).工厂方法模式. 2. 结构模式: Flyweight ( (共享模式). Bridge ( (桥模式). Decorator ( (装饰模式). Composite ( (组合模式). Adapter (适配器模式). Proxy ( (代理模式). Facade ( (外观模式). 3. 行为模式: It