精华内容
下载资源
问答
  • java简单工厂与抽象工厂对比
    2019-05-07 00:08:33

    简单工厂:

    1、理解spring bean工厂基本上就理解了spring ioc了。
    2、学东西先理脉络,再研究细节。
    3、在实际工作中要把设计模式综合运用。
    4、车的产生过程由自己确定,不由师父创建。
    5、工厂就是生产产品,是靠自己生产产品,不是靠new;在里面可以做各种判断后再new车。
    6、工厂里面用单利还是多例可以自己选择。
    7、要替换方便就必须用多态,就要用父类和子类。
    8、控制生成类型和生成过程

    抽象工厂:

    1、在jdk里面有很多getInstance()基本上都是静态的工厂方法。
    2、在jdk里面有很多各种各样的Factory就是产生factory的工厂。
    3、这个人不单开车,还拿的武器,还吃着苹果,这个人手里控制的产品很多。
    4、问题是:控制系列产品的替换。
    4、如果把1系列产品换车2系列产品,只需要换1系列产品的工厂换成2系列产品的工厂就可以,没必要替换所以的。
    5、东西都new一遍,可以在配置文件里面修改一个地方就可以,换皮肤的功能类似抽象工厂,抽象工厂生产了。
    6、一系列产品,可以批量换掉一系列产品,只需要换掉工厂。

    抽象工厂和简单点工厂对比:

    1、简单工厂来说是可以在产品这个维度扩展,在普通工厂里面产生产品系列,会很麻烦,产生不同的产品就要产生对应的工厂,导致工厂泛滥问题。
    2、抽象工厂的问题:能换产品系列,但是能产生新的产品品种吗?修改的地方太多。
    3、既能在产品系列和产品品种方面有好的解决方案:
    比如:
    spring bean工厂,new什么东西由配置文件来决定。

    学习方法:

    应用驱动学习

    更多相关内容
  • 主要介绍了Java设计模式编程中简单工厂与抽象工厂模式的使用实例,简单工厂与抽象工厂都可以归类于设计模式中的创建型模式,需要的朋友可以参考下
  • 主要介绍了Java简单工厂模式定义与用法,结合实例形式分析了java简单工厂模式的相关定义与使用技巧,并给出了原理类图进行总结,需要的朋友可以参考下
  • java工厂模式
  • java简单工厂模式源码实例,可用于java简单工厂模式学习!
  • Java简单工厂模式

    2021-01-20 03:47:44
    简单工厂模式 SimpleFactory,适用于业务相对较简单地情况,少扯闲话,先上code:  ~~ ICar.java ~~ 抽象产品角色接口 /**  * @author VerpHen  * @date 2013年9月10日 上午9:36:19  */ package org....
  • 本文主要介绍了JAVA简单工厂模式(从现实生活角度理解代码原理)的相关知识。具有很好的参考价值。下面跟着小编一起来看下吧
  • 从设计模式的类型上来说,简单工厂模式是属于创建型模式,又叫做静态工厂方法(Static Factory Method)模式,但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂...
  • JAVA简单工厂模式四则运算计算器
  • Java简单工厂模式和传统模式实现对比,通过简单实例比对两种方式差异,体现传统模式的弊端及工厂模式优势。利于初学者后续接触spring
  • Java实现简单工厂模式

    千次阅读 2022-02-17 14:30:13
    - 工厂类中创建实例的方法是静态的,所以简单工厂模式也叫静态工厂模式 - 根据传入参数的不同来获取不同的实例,不关注内部实现。 缺点: - 新增或修改创建过程需要修改静态方法内部逻辑,违背开闭原则; - 工厂类...

    什么是简单工厂模式

    定义一个工厂类,该类提供一个静态方法,该方法会根据传入的参数的不同来创建不同的实例。

    特点和优点:

    • 工厂类中创建实例的方法是静态的,所以简单工厂模式也叫静态工厂模式
    • 根据传入参数的不同来获取不同的实例,不关注内部实现。

    缺点:

    • 新增或修改创建过程需要修改静态方法内部逻辑,违背开闭原则;
    • 工厂类集成了创建实例的所有逻辑,职责过重,异常后会影响整个模块,另外内部逻辑过于复杂,扩展性差;
    • 工厂类使用静态方法,造成工厂角色无法被继承。

    下面以车厂造车模型来实现简单工厂模式。

    创建抽象类

    简单工厂模式中会有一个抽象类,其他实例需要继承该类,来保证静态方法创建的实例是同一类型。

    public abstract class Car {
        public abstract void run();
    }
    

    创建宝马车子类

    public class BMWCar extends Car {
    
        private String name;
    
        public BMWCar(String name) {
            this.name = name;
        }
    
        @Override
        public void run() {
            System.out.println(this.name);
        }
    }
    

    创建玛莎拉蒂车子类

    public class MaseratiCar extends Car {
    
        private String name;
    
        public MaseratiCar(String name) {
            this.name = name;
        }
    
        @Override
        public void run() {
            System.out.println(this.name);
        }
    }
    

    创建车工厂类

    public class CarFactory {
    
        public static Car createCar(String brand) {
            Car car = null;
            switch (brand) {
                case "maserati": // 玛莎拉蒂
                    car = new MaseratiCar(brand);
                    break;
                case "bmw": // 宝马
                    car = new BMWCar(brand);
                    break;
            }
            return car;
        }
    }
    

    测试

    public class MainActivity extends AppCompatActivity {
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            // 创造宝马车
            Car car1 = CarFactory.createCar("bmw");
            car1.run();
            // 创造玛莎拉蒂车
            Car car2 = CarFactory.createCar("maserati");
            car2.run();
        }
    
    }
    

    结果:

    System.out: bmw
    System.out: maserati
    

    开源库示例

    1、log4j中使用简单工厂模式

    // 使用
    Log logger = LogFactory.getLog(KeyboardController.class);
    
    // 静态工厂方法
    public static Log getLog(Class clazz) throws LogConfigurationException {
        return getFactory().getInstance(clazz);
    }
    
    // 根据类名创建实例
    public Log getInstance(Class clazz) throws LogConfigurationException {
        return getInstance(clazz.getName());
    }
    
    // 根据类名创建
    public Log getInstance(String name) throws LogConfigurationException {
        Log instance = (Log) instances.get(name);
        if (instance == null) {
            instance = newInstance(name);
            instances.put(name, instance);
        }
        return instance;
    }
    

    2、PatternLocker项目

    github上九宫格组件

    使用简单工厂创建每一个格子,不过是kotlin代码:

    object CellFactory {
    
        fun buildCells(width: Int, height: Int): List<CellBean> {
            val result = ArrayList<CellBean>()
            val pWidth = width / 8f
            val pHeight = height / 8f
    
            for (i in 0..8) {
                result.add(CellBean(i,
                        i % 3,
                        i / 3,
                        (i % 3 * 3 + 1) * pWidth,
                        (i / 3 * 3 + 1) * pHeight,
                        pWidth))
            }
    
            Logger.d("CellFactory", "result = $result")
    
            return result
        }
    }
    

    3、Android中BitmapFactory

    BitmapFactory.Options decodeOptions = new BitmapFactory.Options();
    

    以上就是简单工厂模式的使用和示例,可见简单工厂模式在日常开发中还是很常见的。如果你的程序满足简单工厂模式的应用场景,可以使用该模式来提高代码质量。

    上面源码可以查看工程34-android-factory

    个人公众号,喜欢的可以关注一下:
    在这里插入图片描述

    展开全文
  • Java简单工厂模式实战.pdf
  • 工厂模式概要 理解:用factory模式代替使用new创建对象,实现了创建者和调用者的分离,方便维护对象。 实现方式:是面向接口编程 主要遵循:开闭原则,对类可以扩展,但是不允许对类修改。 这原则核心思想,宁愿多...

    一. 工厂模式概要

    1. 理解:用factory模式代替使用new创建对象,实现了创建者和调用者的分离,方便维护对象。
    2. 实现方式:是面向接口编程
    3. 主要遵循:开闭原则,对类可以扩展,但是不允许对类修改。
      这原则核心思想,宁愿多创建几个类,也不要去修改已经写好的类,但如果是系统逻辑的错误,可以修改类。

    面向对象设计基本原则

    原则说明
    开闭原则软件实体应该是可扩展的,而不可修改的
    里 氏 替 换 原 则 \color {red}{里氏替换原则} 子类必须能够替换其基类,保证继承复用的基础
    依赖倒转原则依赖于抽象,高层模块不依赖于底层模块,二者都同依赖于抽象
    单一职责一个类,只做一件事并且做好
    接口隔离原则使用多个小的专门的接口,而不要使用一个大的总接口
    迪米特法则如果两个类之间无须直接通信,那么就不应当发生直接的相互调用,可以通过第三方转发该调用
    模式说明
    简单工厂模式用来生产同一等级结构中的任意产品。(对于增加新的产品,需要修改已有代码)(违反开闭原则)
    工厂模式用来生产同一等级结构中的固定产品。(支持增加任意产品)
    抽象工厂用来生产不同产品族的全部产品。(对于增加新的产品,无能为力;支持增加产品族)

    二.简单工厂模式

    创建意图就是,把对类的创建初始化全都交给一个工厂来执行,而用户不需要去关心创建的过程是什么样的,只用告诉工厂我想要什么就行了。违背了设计模式的开闭原则,如果你要增加其他产品,就必须对工厂进行改建。
    例如我开了奔驰公司想要生产A系列的车和B系列的车,首先定义接口,创建两种车的类,和工厂类,就可以生产车了。
    类图:
    在这里插入图片描述
    实现代码:

    interface car {
        public  void run();
    }
    
    class carA implements car {
    
        public void run(){
    
            System.out.println("carA 时速100km");
        }
    }
    
    class carB implements car {
        public void run(){
            System.out.println("carB 时速200km");
        }
    
    }
    //如果生产C系列的车
    class carC implements car {   
    
        public void run(){
            System.out.println("carC 时速300km");
        }
    
    }
    
    class Factory {
        public car createCar(String name)
        {
            if (name.equalsIgnoreCase("carA")) {
                return new carA();
            }
            else if (name.equalsIgnoreCase("carB")) {
                return new carB();
            }
            return null;
        }
    }
    
    class SimpleFactoryClient{
        public static void main(String[] args) {
            Factory factory = new Factory();
            car car1= factory.createCar("carA"); //给个名,工厂就生产
            car1.run();
            car car2= factory.createCar("carB");
            car2.run();
            car car3= factory.createCar("carC");
            car3.run();
        }
    }
    

    如果改天想生产C系列的车carC,就得先造carC的类,但是要想完成对carC的生产,此时只能去修改工厂类,在里面添加一个新的方法,制造carC,但是不符合开闭原则。
    在这里插入图片描述

    三. 工厂模式

    • 解决简单工厂方法模式的缺点:使用工厂方法模式为每一种产品生成一个对应的工厂。
    • 工厂方法模式的核心思想:讨论的仍然是如何构建同一类型产品(都实现同一个接口)的问题,只不过每个工厂只生产一种特定的产品。
    • 优势:是当以后需要增加新的产品时,直接新增加一个对应的工厂就可以了,而不是去修改原有的工厂
      奔驰厂商优化生产线类图:
      在这里插入图片描述
      实现
    interface car {
        public  void run();
    }
    
    class carA implements car {
    
        public void run(){
    
            System.out.println("carA 时速100km");
        }
    }
    
    class carB implements car {
        public void run(){
            System.out.println("carB 时速200km");
        }
    
    }
    //如果生产C系列的车
    class carC implements car {   
    
        public void run(){
            System.out.println("carC 时速300km");
        }
    
    }
    
    interface CarFactory {
        public  car creatCar();
    }
    class  CarAFactory implements CarFactory {
        public  car creatCar(){
            return new carA();
        };
    };
    class  CarBFactory implements CarFactory {
        public  car creatCar(){
            return new carB();
        };
    };
    class  CarCFactory implements CarFactory {   //生产新车了
        public  car creatCar(){
            return new carC();
        };
    };
    
    
    public class FactoryClient {
        public static void main(String[] args) {
    
            car car1 =new CarAFactory().creatCar(); 
            car car2= new CarBFactory().creatCar();
            car car3= new CarCFactory().creatCar();
            car1.run();
            car2.run();
            car3.run();
    
        }
    }
    

    优缺点

    • 优点:不直接在客户端创建具体产品的实例,降低了耦合性。
    • 缺点:每增加一种产品就要相应的增加一个工厂类,比较繁琐。

    技术要点总结

    • 构建的都是同一类型的对象,即实现相同的接口
    • 每一类对象对应一个工厂

    欠的有一天不得不补回来 (| _ |
    参考

    展开全文
  • java简单工厂设计模式实现计算器

    万次阅读 多人点赞 2017-10-20 18:00:59
    本文使用java简单工厂设计模式实现简单计算器。 一、项目工程如下: 二、Operation类是计算器的父类: package 计算器; /** * 计算器的父类 * @author Administrator * */ public abstract class ...

    本文使用java的简单工厂设计模式实现简单计算器。

    一、项目工程如下:


    二、Operation类是计算器的父类:

    package 计算器;
    /**
     * 计算器的父类
     * @author Administrator
     *
     */
    public abstract class Operation {
    	private double x;
    	private double y;
    	public abstract double getResult();
    	public double getX() {
    		return x;
    	}
    	public void setX(double x) {
    		this.x = x;
    	}
    	public double getY() {
    		return y;
    	}
    	public void setY(double y) {
    		this.y = y;
    	}
    }
    
    三、Add类:

    package 计算器;
    /**
     * 加
     * @author Administrator
     *
     */
    public class Add extends Operation{
    	@Override
    	public double getResult() {
    		return getX()+getY();
    	}
    }
    
    四、Sub:
    package 计算器;
    /**
     * 减
     * @author Administrator
     *
     */
    public class Sub extends Operation{
    	@Override
    	public double getResult() {
    		return getX()-getY();
    	}
    }
    
    五、Mul
    package 计算器;
    /**
     * 乘
     * @author Administrator
     *
     */
    public class Mul extends Operation{
    	@Override
    	public double getResult() {
    		return getX()*getY();
    	}
    }
    
    六、Div
    package 计算器;
    /**
     * 除
     * @author Administrator
     *
     */
    public class Div extends Operation{
    	@Override
    	public double getResult() {
    		if (getY()==0) {
    			System.out.println("除数不能为0");
    			return -1;
    		}else{
    			return getX()/getY();
    		}
    	}
    }
    
    七、工厂类:

    package 计算器;
    
    public class OptionerFactory {
    	public static Operation creatOperation(String oper){
    		Operation operation=null;
    		switch (oper) {
    		case "+":
    			operation=new Add();
    			break;
    		case "-":
    			operation=new Sub();
    			break;
    		case "*":
    			operation=new Mul();
    			break;
    		case "/":
    			operation=new Div();
    			break;
    		}
    		return operation;
    	}
    }
    
    八、测试类:

    package 计算器;
    
    import java.util.Scanner;
    
    public class TestMain {
    	public static void main(String[] args) {
    		@SuppressWarnings("resource")
    		Scanner scanner=new Scanner(System.in);
    		System.out.println("输入第一个数");
    		double x=scanner.nextInt();
    		System.out.println("输入操作符");
    		String oper=scanner.next();
    		System.out.println("输入第二个数");
    		double y=scanner.nextInt();
    		Operation operation = OptionerFactory.creatOperation(oper);
    		operation.setX(x);
    		operation.setY(y);
    		double result = operation.getResult();
    		System.out.println("结果:"+result);
    	}
    }

    九、架构图:





    展开全文
  • 下载完成后直接用ide开发工具打开即可!
  • 这是代码,介绍请查看以下博客地址: http://www.cnblogs.com/homg/p/3548110.html代码乱码请使用utf-8编码。
  • 主要介绍了java 工厂模式的讲解及优缺点的介绍的相关资料, 简单工厂模式,又称为静态工厂方法(Static Factory Method)模式,它属于类创建型模式,需要的朋友可以参考下
  • java 三种工厂模式(简单工厂+工厂方法+抽象工厂)

    万次阅读 多人点赞 2019-06-04 10:51:15
    一、简单工厂模式 概述   简单工厂模式:定义一个工厂类,它可以根据参数的不同返回不同类的 实例,被创建的实例通常都具有共同的父类。因为在简单工厂模式中用于创建实例的方法是静态(static)方法,因此简单工厂...
  • 工厂模式将目的将创建对象的具体过程屏蔽隔离起来,从而达到更高的灵活性,工厂模式可以分为三类:简单工厂模式、工厂方法模式、抽象工厂模式;简单工厂模式的核心是定义一个创建对象的接口,将对象的创建和本身的...
  • JAVA简单工厂创立性模式介绍,包含简单工厂工厂方法,抽象工厂。举例说明让您更好理解!
  • 简单工厂模式又称为静态工厂模式:定义一个工厂类,他可以根据参数的不同返回不同类的实例,被创建的实例通常都具有相同的父类。虽然不属于23中设计模式其一,但是经常会被使用。 /**Product抽象产品角色*/ public...
  • 简单工厂设计模式案例实现
  • 主要介绍了Java设计模式之工厂模式,结合实例形式分析了简单工厂工厂方法、抽象工厂等相关功能、实现与使用方法,需要的朋友可以参考下
  • 简单工厂模式 工厂方法模式 抽象工厂模式 面向对象设计的基本原则: OCP(开闭原则,Open-Closed Principle):一个软件的实体应当对扩展开放,对修改关闭。 DIP(依赖倒转原则,Dependence Inversion Principle):...
  • 那么思博今天就来为大家详细介绍一下Java简单工厂模式(Simple Factory)。从定义上看,简单工厂模式(Simple Factory Pattern):定义一个工厂类,它可以根据参数的不同返回不同类的实例,被创建的实例通常都具有共同的...
  • Java工厂模式案例

    2019-01-17 16:36:01
    1.简单工厂模式(simple factory)2.工厂方法模式(factory mathoud)3.抽象工厂模式(abstract factory)
  • 简单工厂工厂方法进行分析,UML类图解析,以及针对源码剖析
  • 正在学习设计模式,为练习用就用简单工厂模式实现了个简单的四则运算器,很简单,第一次上传东西,初学或者要学设计模式的可以下来看看~~
  • 简单工厂模式是工厂模式中家族最简单实用的模式,可以理解为不同工厂模式的一个特殊的实现。值得注意的是:简单工厂模式并不属于23种设计模式之一。但是它是抽象工厂模式、工厂模式的基础,并且也有广泛的应用。概念...
  • 简单工厂Java

    万次阅读 多人点赞 2018-06-10 14:59:16
    简单工厂不是一个标准的设计模式,但是因其常用,简单而又神奇,故把它放到设计模式中。一:接口的回顾1:Java中接口的概念在Java中接口是一种特殊的抽象类,根一般的抽象类相比,接口里面的所有方法都是抽象方法,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 220,755
精华内容 88,302
关键字:

java简单工厂

java 订阅