工厂模式学习心得

最新推荐文章于 2021-08-17 01:07:48 发布
最新推荐文章于 2021-08-17 01:07:48 发布
阅读量788 收藏 1
点赞数
文章标签： python java 设计模式
原文链接：https://my.oschina.net/kakakaka/blog/325537
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

工厂模式是一种创建型设计模式，它的目的是负责实例化大量有共同接口的类，而且也不需要事先知道需要实例的类是什么。由子类来决定实例化哪一个类。

工厂模式分为三种：

1.简单工厂模式。

2.工厂方法模式。

3.抽象工厂方法模式。


简单工厂模式

简单工厂模式一般包括以下几个角色：

1.工厂: 由一个具体的类实现，内部含有一定的逻辑判断。

2.抽象产品: 由一个接口或者抽象类实现，使具体产品得到扩展。

3.具体产品: 有一个具体的类实现，为工厂最终生成的实例化对象。

简单工厂模式的核心思想就是：有一个专门的类来负责创建实例的过程。


package Factorys;

//抽象产品
interface abstractProduct{
    public void doSomething();
}


//具体产品A
class ProductA implements abstractProduct{
    public void doSomething(){
        System.out.println("I am A");
    }
}


//具体产品B
class ProductB implements abstractProduct{
    public void doSomething(){
        System.out.println("I am B");
    }
}

//工厂
class Factory{
    public static abstractProduct createProduct(String type) throws InstantiationException, IllegalAccessException, ClassNotFoundException{
        if(type != null){
            //使用反射机制生成实例。
            return (abstractProduct) Class.forName(type).newInstance();
        }
        return null;
    }
}

//结果输出
public class simpleFactoryPattern {
    public static void main(String args[]) throws InstantiationException, IllegalAccessException, ClassNotFoundException{
        Factory.createProduct("Factorys.ProductA").doSomething();
        Factory.createProduct("Factorys.ProductB").doSomething();
    }
}

输出结果

I am A
I am B

如果具体产品之间含有相同的逻辑，那么我们可以使用一个抽象类来抽象出它们，如果没有，那么我们则用一个接口来扮演这个抽象类，它们也可以一层层的抽象下去，不断的扩展开来。工厂的作用是来实例化各种类对象。只需要根据客户端传入的参数再利用反射机制进行生产即可。

但是考虑一个问题，如果不同的产品的构造条件不同，需要加载的配置信息都不同，那么一个工厂类可以满足需求么，即使在工厂类里面加入大量的逻辑判断语句，来完成不同产品需要的不同的构造条件。当产品种类非常多的时候，那么大量逻辑条件的混杂在一起。可想而知代码会变的多么的可怕。


工厂方法模式

工厂方法模式一般包括以下几个角色：

1.抽象工厂: 由一个接口或者抽象类实现，使具体工厂可以得到扩展，并满足不同产品的需求。

2.工厂: 由一个具体的类实现，内部含有一定的逻辑判断。

3.抽象产品: 由一个接口或者抽象类实现，使具体产品得到扩展。

4.具体产品: 由一个具体的类实现，为工厂最终生成的实例化对象。

工厂方法模式是简单工厂模式的延伸，它继承了简单工厂模式的优点，同时还弥补了简单工厂模式的不足。当一个工厂不能满足需求的时候，当然就需要更多的工厂啦。

package Factorys;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

//抽象工厂
interface abstractFactory{
}

//具体工厂A
class FactoryA implements abstractFactory{
    public static abstractProduct createProduct(String type) throws InstantiationException, IllegalAccessException, ClassNotFoundException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException{
        if(type != null){
            //使用反射机制生成实例。
            Class c = Class.forName(type);
            //使用Constructor 调用带参构造函数
            Constructor constructor=c.getDeclaredConstructor(new Class[]{String.class});
            constructor.setAccessible(true);
            return (abstractProduct) constructor.newInstance(new Object[]{"AAAAAA, "});
        }
        return null;
    }
}

//具体工厂B
class FactoryB implements abstractFactory{
    public static abstractProduct createProduct(String type) throws InstantiationException, IllegalAccessException, ClassNotFoundException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException{
        if(type != null){
            //使用反射机制生成实例。
            Class c = Class.forName(type);
            //使用Constructor 调用带参构造函数
            Constructor constructor=c.getDeclaredConstructor(new Class[]{String.class});
            constructor.setAccessible(true);
            return (abstractProduct) constructor.newInstance(new Object[]{"BBBBBB, "});
        }
        return null;
    }
}

//抽象产品
interface abstractProduct{
  public void doSomething();
}


//具体产品A
class ProductA implements abstractProduct{
    private String string;
    private ProductA(String string){
        this.string = string;
    }
    public void doSomething(){
        System.out.println(string + "I am A");
    }
}


//具体产品B
class ProductB implements abstractProduct{
        private String string;
        private ProductB(String string){
            this.string = string;
        }
        public void doSomething(){
            System.out.println(string + "I am B");
        }
}


public class factoryMethodPattern {
        public static void main(String args[]) throws InstantiationException, IllegalAccessException, ClassNotFoundException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException{
            FactoryA.createProduct("Factorys.ProductA").doSomething();
            FactoryB.createProduct("Factorys.ProductB").doSomething();
            
        }
}

输出结果

AAAAAA, I am A
BBBBBB, I am B

在工厂方法模式中，我们定义了一个抽象工厂类作为核心取代了简单工厂模式中的单个具体实现类。我们可以扩展出不同的工厂来配置出需求不同的产品，满足不同的产品。当然，过多的产品时，我们不需要为每一个都配置一个工厂实现类，可以结合简单工厂模式，为构造信息相同的一类产品分配一个工厂类即可。

抽象工厂模式

抽象工厂模式一般包括以下几个角色（和工厂方法模式的角色基本相同）：

1.抽象工厂: 由一个接口或者抽象类实现，使具体工厂可以得到扩展，并满足不同产品的需求。

2.工厂: 由一个具体的类实现，内部含有一定的逻辑判断。

3.抽象产品: 由一个接口或者抽象类实现，使具体产品得到扩展。

4.具体产品: 由一个具体的类实现，为工厂最终生成的实例化对象。

抽象工厂模式主要解决的问题是，存在一批相关的产品，它们属于同一个集合，但是它们的构造函数却不相同，我们希望它们能够在一个工厂中生产出来，而不是为这一批产品中的每一个产品分配一个工厂。将这样一批的产品称为产品族。

package Factorys;


import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;


//抽象产品族A
interface abstractProductA{
    public void doSomething();
}
    
//产品族A具体产品A1
class ProductA1 implements abstractProductA{
        private String string;
        private ProductA1(String string){
        this.string = string;
        }
        
        public void doSomething(){
            System.out.println(string + "I am A1");
        }
}

//产品族A具体产品A2
class ProductA2 implements abstractProductA{
        private String string;
        private ProductA2(String string){
        this.string = string;
        }
        
        public void doSomething(){
            System.out.println(string + "I am A2");
        }
}

//抽象产品族B
interface abstractProductB{
        public void doSomething();
}
    
//产品族B具体产品B1
class ProductB1 implements abstractProductB{
        private String string;
        private ProductB1(String string){
                this.string = string;
        }
        public void doSomething(){
                System.out.println(string + "I am B1");
        }
}
    
//产品族B具体产品B2
class ProductB2 implements abstractProductB{
        private String string;
        private ProductB2(String string){
                this.string = string;
        }
        public void doSomething(){
                System.out.println(string + "I am B2");
        }
}
        
interface AbstractFactory {   
} 

class FactoryA implements AbstractFactory{
        public static abstractProductA createProductA1(String type) throws InstantiationException, IllegalAccessException, ClassNotFoundException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException{
                if(type != null){
                        //使用反射机制生成实例。
                        Class c = Class.forName(type);
                        //使用Constructor 调用带参构造函数
                        Constructor constructor=c.getDeclaredConstructor(new Class[]{String.class});
                        constructor.setAccessible(true);
                        return (abstractProductA) constructor.newInstance(new Object[]{"A产品族, "});
                }
                return null;
        }
        
        public static abstractProductA createProductA2(String type) throws InstantiationException, IllegalAccessException, ClassNotFoundException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException{
            if(type != null){
                    //使用反射机制生成实例。
                    Class c = Class.forName(type);
                    //使用Constructor 调用带参构造函数
                    Constructor constructor=c.getDeclaredConstructor(new Class[]{String.class});
                    constructor.setAccessible(true);
                    return (abstractProductA) constructor.newInstance(new Object[]{"A产品族, "});
            }
            return null;
    }
}


class FactoryB implements AbstractFactory{
        public static abstractProductB createProductB1(String type) throws InstantiationException, IllegalAccessException, ClassNotFoundException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException{
                if(type != null){
                        //使用反射机制生成实例。
                        Class c = Class.forName(type);
                        //使用Constructor 调用带参构造函数
                        Constructor constructor=c.getDeclaredConstructor(new Class[]{String.class});
                        constructor.setAccessible(true);
                        return (abstractProductB) constructor.newInstance(new Object[]{"B产品族, "});
                }
                return null;
        }
        
        public static abstractProductB createProductB2(String type) throws InstantiationException, IllegalAccessException, ClassNotFoundException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException{
            if(type != null){
                    //使用反射机制生成实例。
                    Class c = Class.forName(type);
                    //使用Constructor 调用带参构造函数
                    Constructor constructor=c.getDeclaredConstructor(new Class[]{String.class});
                    constructor.setAccessible(true);
                    return (abstractProductB) constructor.newInstance(new Object[]{"B产品族, "});
            }
            return null;
        }
}



public class abstractFactoryPattern {
    
        public static void main(String args[]) throws InstantiationException, IllegalAccessException, ClassNotFoundException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException{
                FactoryA.createProductA1("Factorys.ProductA1").doSomething();
                FactoryA.createProductA2("Factorys.ProductA2").doSomething();
                FactoryB.createProductB1("Factorys.ProductB1").doSomething();
                FactoryB.createProductB2("Factorys.ProductB2").doSomething();
        }
        
}

输出结果

A产品族, I am A1
A产品族, I am A2
B产品族, I am B1
B产品族, I am B2

抽象工厂模式只需要为每一个产品族分配一个工厂，然后再在每一个工厂中定义不同产品的生产方式。在只有一个产品族的情况下，抽象工厂模式实际上退化到工厂方法模式。而再只需要一个工厂的情况下，工厂方法模式即为简单工厂模式


转载于:https://my.oschina.net/kakakaka/blog/325537

weixin_33743661
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
简单工厂模式
java_xxxx的博客
10-22 559
简单工厂模式，所谓工厂，就是生产东西的。而我们编程中的生产当然是new了，生产的东西当然是一个个类了。即，简单工厂，到底是谁实例化谁，将来会不会增加实例化的对象，应该考虑用一个单独的类来做这个创造实例的过程。这就是工厂。 模式定义 简单工厂模式(Simple Factory Pattern)：又称为静态工厂方法(Static Factory Method)模式，它属于类创建型模式。在简单工厂模式中...
java设计模式学习小结：简单工厂
个人学习、工作笔记
10-11 236
简单工厂 接口用来封装隔离具体的实现，目标是不让客户端知道封装体内部的具体实现。 简单工厂的位置位于封装体内，它和接口以及具体的实现在一起，算是封装体内部的一个类，所以简单工厂是知道具体实现的。 简单工厂封装对象的范围，建议控制在一个独立的组件级别或者一个模块级别，否则这个工厂会显得职责不明。 简单工厂命名建议： 类名建议为“模块名称+Factory”。比如，用户模块的工厂就称为：UserFactory。 方法名通常为“get+接口名称“或者是”create+接口名称“。比如有一个接口名称为UserEbi
工厂模式总结
Jarvis666的博客
12-06 174
工厂模式总结：             工程模式分为简单工厂，工厂方法，抽象工厂。按照我的理解就是三者在实现上就是逐渐把功能进行抽象。              怎么理解呢，可以这么想，1.我们用简单工厂要实现生产冰激凌，就将冰激凌口味进行抽象，抽象成口味接口，并增加口味方法供实现，增加变更口味只需实现接口就可以实现，工厂就普通类，只需列出各个方法返回不同冰激凌口味实例即可，由冰激凌实例进行口...
java学习总结 1（关于我对工厂模式的理解）
qq_43876243的博客
04-27 112
今天学了设计模式，对于工厂模式有了更深的理解。 工厂模式，有三种，简单工厂模式，工厂方法模式，抽象工厂模式。 简单工厂模式， 就是用一个工厂类管理所有需要使用的对象。使用的时候，不用自己new 对象，直接使用工厂提供的方法创建。 如果新增了一个类，就必须在工厂类代码里面修改，违反开闭原则。 工厂方法模式，定义一个工厂接口，每当新出现一个类，就新写一个方法，返回这个类的实例，这个工厂只生产一种组件。 如果工厂里的组件或者产品过多，就会出现好多小工厂，导致代码庞大的情况。 抽象工厂模式， 创建工厂的工厂。 定义
工厂模式--学习总结
weixin_56702673的博客
08-17 200
工厂模式--学习总结什么是工厂模式代码实现 什么是工厂模式 工厂模式是java中最常用的设计模式之一，在工厂模式中，创建对象时不会对客户端暴露创建逻辑，并且只是通过一个共同的接口来指向新创建的对象。 代码实现 以人去餐馆吃午饭为例 1.传统的实现方式 public class FastFood { //第一种食物 public void service() { System.out.println("麻婆豆腐...."); } } public class MiXian
javascript 模式设计之工厂模式学习心得
10-29
接口的实现，从而使不同子类可以被同等的对待,恰当的使用工厂模式,但不要拘泥与形式,理解本质。
OBE工程教育模式学习心得.doc
12-20
OBE工程教育模式学习心得.doc
设计模式学习心得（研磨设计模式）
07-28
这篇“设计模式学习心得（研磨设计模式）”博客及其相关的PDF文档，为我们提供了一个深入理解和应用设计模式的宝贵资源。以下将针对单例模式、工厂方法模式、策略模式、命令模式和桥接模式进行详细讲解。 1. **单例...
1物联网学习心得.docx
06-23
物联网技术学习心得 "物联网技术"的核心和基础仍然是"互联网技术"，是在互联网技术基础上的延伸和扩展的一种网络技术；其用户端延伸和扩展到了任何物品和物品之间，进行信息交换和通讯。因此，物联网技术的定义是：...
3-1、Java 简单工厂模式心得
众纳百川的博客
05-26 256
情景需求是这样的：首先有一个人的接口，当不同的角色的人做不同角色的事；比如同样是工作，IT则是通过电脑工作，而仓库管理员则是通过汽车工作。对于新手来说通常会先定义一个" 人" 的 接口，然后去定例化，再调用方法，不是说这种不可以，但代码量会变多，并且看起来冗余，维护不方便；如下所示 //----------------------定义一个人接口 interface Person{ public void work(); } //-------------------职业为IT 继承 人 接口 cl
工厂模式学习总结
江川的博客
03-19 1128
目录 工厂模式 引言 定义 工厂模式结构图 实例 实例描述 代码实现 工厂模式扩展 静态工厂方法（简单工厂模式） 总结 模式优点 模式缺点 工厂模式 引言 在面向对象的编程中，创建一个对象（实例化）主要使用new关键字，工厂模式将类的使用和创建解耦。用户要使用一个类的时候，无需关心该类的具体创建过程，甚至无需知道该类类名，只需要通过工厂类返回需要的实例。就...
简单工厂模式学习总结
long的博客
06-06 920
简单工厂模式 【作用】：将对象的创建与使用分离（单一职责原则） 【实现】：定义一个工厂类，根据不同参数返回不同类的实例，被创建的实例有共同父类 结构图 Factory(工厂角色)：工厂角色即工厂类，它是简单工厂模式的核心，负责实现创建所有产 品实例的内部逻辑 Product (抽象产品角色)：它是工厂类所创建的所有对象的父类，封装了各种产品对象的 公有方法. ConcreteProduct
简单工厂模式,工厂方法模式与抽象工厂模式学习总结
晓风残月龙
01-01 2164
一、概念及类图1、简单工厂模式(静态工厂模式) 在简单工厂模式中,工厂类可以根据参数的不同返回不同的类的实例。 2、工厂方法模式(多态模式) 工厂方法模式的核心是抽象工厂类Factory,各种具体工厂类继承抽象工厂类并实现在抽象工厂类中定义的工厂方法,从而让客户只关心抽象产品和抽象工厂,不用管具体返回的是哪一种具体产品,也不用关心它是如何被具体工厂创建的。 3、抽象工厂模式 该模式
工厂方法模式（实现加总结）
lkkk的博客
05-14 623
工厂方法模式（Factory Method）: 定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类 如果没有看过简单工厂模式的话可以花一点点时间了解一下简单工厂模式 在简单工厂模式中说过，既然简单工厂类对分支耦合，那么我们就要把它拆开，根据依赖倒置原则，我们根据工厂类抽象出一个接口，所有的工厂都要实现这个接口。 下面是工厂方法模式的UML图 可以看到，与简...
设计模式的心得
超胆孤侠
11-04 1199
文章目录前言两个原则开闭原则 前言 以前学习js的时候了解过设计模式，觉得是很神奇的事情，就好比武侠小说中的各种招式，可以拿来对付代码中的各种问题 最近又看教程和书籍重新温习了一遍，脑海中很清晰的有了关于设计模式的印象 感觉现在写代码，无招胜有招，在不知不觉中就会把设计模式运用到代码当中 两个原则 各个设计模式都有两个不变的基本原则 对容易变化的进行抽象 对复杂的逻辑进行封装 开闭原则 ...
简单工厂模式总结
贺天远 廊坊师范学院信息技术提高班十五期
05-02 374
工厂模式，说简单点就是用工厂的思维模式建造软件。 工厂的定义：就是各类产品的制造场所； 所以工厂主要分为产品和工厂本身两部分； 所以我就将简单工厂模式在我看来分为三步走； 第一步确定工厂模型的总父类 第一步就是确定我们的产品的总的类别，在日常生活中每个工厂都是有特定功能的，而他们的功能从大的方面都归属一个类。比如服装加工厂，机械加工厂，食品加工厂等等。从这些工厂中都可以抽象出一个总类。服装加工厂抽...
dsp学习心得体会.pdf
07-10
“DSP学习心得体会.pdf”主要探讨了数字信号处理器（DSP）的学习总结，包括DSP的基本概念、结构特点以及32位C28x DSP芯片的详细介绍。 1. DSP基础 数字信号处理器是一种专门用于数字信号处理的微处理器，它在通信、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值