精华内容
下载资源
问答
  • java简单工厂模式源码实例,可用于java简单工厂模式学习!
  • 主要介绍了Java简单工厂模式定义与用法,结合实例形式分析了java简单工厂模式的相关定义与使用技巧,并给出了原理类图进行总结,需要的朋友可以参考下
  • java简单工厂模式

    2017-02-16 14:47:14
    java 简单工厂模式

    在学习模式过程中,感觉只看书,自己不写完全记不住,此微博只是为了自己学习时理解的东西写下来,一方面学习画UML图。

    本人也只是边学习边写的,有问题的地方,望大神指正。

    首先进入一个简单工厂模式。

    理解:以一个园子为背景,园子中有花、草、树等,还有园丁,客户只需要告知园丁种植何种植物,园丁则会种值出相应的植物。

    UML图:




    对应代码:

    public interface IPlant {
    
    }
    
    public class Flower implements IPlant {
        public Flower(){
            System.out.println("生产出一朵花....");
        }
    }
    

    public class Grass implements IPlant {
        public Grass(){
            System.out.println("生产出一株草....");
        }
    }
    

    public class Tree implements IPlant {
        public Tree(){
            System.out.println("生产出一棵树...");
        }
    }

    public class PlantFactory {
    
        public static IPlant createPlant(int type) {
            IPlant plant = null;
            switch (type){
                case 1 :
                    plant = new Flower();
                    break;
                case 2:
                    plant = new Grass();
                    break;
                case 3:
                    plant = new Tree();
                    break;
                default:
                    throw new CreatePlantTypeUndefinedException("类型未定义");
            }
            return plant;
    
        }
    }

    public class CreatePlantTypeUndefinedException extends RuntimeException{
    
        public CreatePlantTypeUndefinedException(String message){
            super(message);
        }
    }
    

    public class Client {
        public static void main(String[] args) {
    
            IPlant flower = PlantFactory.createPlant(1);
    
            IPlant grass = PlantFactory.createPlant(2);
    
            IPlant tree = PlantFactory.createPlant(3);
    
        }
    }
    


    简单工厂模式差不多就完成了,一下节应该是抽象工厂模式。


    展开全文
  • java工厂模式实例(设计模式)

    千次阅读 2021-01-26 19:20:35
    java工厂模式 开篇声明,此理解为作者自身理解,不一定正确,如有错误请大佬们指正。 工厂模式,在作者看来,从现实生活来说,就是一个工厂,里面有N个车间, 每个车间会生产不同的产品,而租户只需要告诉这个...

    目录

    java工厂模式

    工厂模式其实又分为三种

    1.简单工厂模式:

    简单工厂模式(非静态)

     简单工厂模式(静态):

    2.工厂方法模式:

    3.抽象工厂模式:


    java工厂模式

            开篇声明,此理解为作者自身理解,不一定正确,如有错误请大佬们指正。

    工厂模式,在作者看来,从现实生活来说,就是一个工厂,里面有N个车间,

    每个车间会生产不同的产品,而租户只需要告诉这个工厂的老板我需要一个

    什么产品,老板会去找到对应的车间返回给租户使用。

    画个图理解:

           如果使用java语言来描述则是,对具有相同动作,不同动作执行过程的一

    类方法抽象出一个接口类,然后不同的实现类对接口类中的接口进行不同的

    实现,并且编写一个工厂类,根据传入获取不同的实现类实例返回给调用者,调用者使用得到的实例

    执行具体的方法。画个图(简单的加减乘除做示例,没怎么画过UML图,如果有错误,请见谅):

    TestServiceImpl为业务逻辑实现类,MathFactory为工厂类,MathOperation为算法抽象接口类,

    xxxOpreation为算法具体实现类,Class为java原生类,主要是要使用反射机制,会用到

    工厂模式其实又分为三种

    1.简单工厂模式:

    不提供工厂接口只有工厂,提供实例的接口与实现

    简单工厂模式(非静态)

           就是提供一个接口interface,然后不同的实现类实现interface,再提供一个

    工厂类,在工厂类中通过if条件判断,new出具体的实现类给调用者使用。

    算法抽象接口

    public interface MathOperation {
        double apply(int a, int b);
    }

    算法抽象接口实现 (顺序-加减乘除):

    import com.liu.test.factory.simplefactory.MathOperation;
    
    public class AddOperation implements MathOperation {
        @Override
        public double apply(int a, int b) {
            return (double) a + b;
        }
    }
    import com.liu.test.factory.simplefactory.MathOperation;
    
    public class SubOperation implements MathOperation {
        @Override
        public double apply(int a, int b) {
            return (double) a - b;
        }
    }
    import com.liu.test.factory.simplefactory.MathOperation;
    
    public class MultiplyOperation implements MathOperation {
        @Override
        public double apply(int a, int b) {
            return (double) a * b;
        }
    }
    import com.liu.test.factory.simplefactory.MathOperation;
    
    public class DivideOperation implements MathOperation {
        @Override
        public double apply(int a, int b) {
            return (double) a / b;
        }
    }

     工厂类:

    import com.liu.test.factory.simplefactory.operation.AddOperation;
    import com.liu.test.factory.simplefactory.operation.DivideOperation;
    import com.liu.test.factory.simplefactory.operation.MultiplyOperation;
    import com.liu.test.factory.simplefactory.operation.SubOperation;
    
    public class MatchFactory {
    
        /**
          * 获得具体的操作类型
          * @author kevin
          * @param operator :
          * @return java.util.Optional<com.liu.test.math.MathOperation>
          * @date 2021/1/25 11:36
          */
        public static Optional<MathOperation> getOperation(String operator) {
            MathOperation result = null;
            if("add".equals(operator)){
                result = new AddOperation();
            }else if("sub".equals(operator)){
                result = new SubOperation();
            }else if("multiply".equals(operator)){
                result = new MultiplyOperation();
            }else if("divide".equals(operator)){
                result = new DivideOperation();
            }
            return Optional.ofNullable(result);
        }
    }

    使用类

            MathOperation operation = MathFactory.getOperation(operator).orElseThrow(() ->
                    new IllegalArgumentException("未知的操作"));
            result = operation.apply(first, second);
            return result;

     简单工厂模式(静态):

           就是在第一步的基础之上,将new的动作提出来,放到static块中执行,然后

    将产生的实现类实例存放到静态的map中,用户调用的时候,直接从map中get对应的实例。

    此模式不符合java的闭环原则(对扩展开放,对修改关闭)

    静态只需调整工厂类即可,其他不变

    import com.liu.test.factory.simplefactory.operation.AddOperation;
    import com.liu.test.factory.simplefactory.operation.DivideOperation;
    import com.liu.test.factory.simplefactory.operation.MultiplyOperation;
    import com.liu.test.factory.simplefactory.operation.SubOperation;
    
    import java.lang.reflect.InvocationTargetException;
    import java.util.Optional;
    
    import java.util.HashMap;
    import java.util.Map;
    
    public class MatchFactory {
        static Map<String, MathOperation> operationMap = new HashMap<>();
        static {
            operationMap.put("add", new AddOperation());
            operationMap.put("sub", new SubOperation());
            operationMap.put("multiply", new MultiplyOperation());
            operationMap.put("divide", new DivideOperation());
        }
    
        public static Optional<Operation> getOperation(String operator) {
            return Optional.ofNullable(operationMap.get(operator));
        }
    }

     

    简单工厂模式(反射):

           就是在第一步的基础之上,将new的动作去掉,换成反射的方式实现,将接口实现类统一放

    在一个包中,然后统一命名规范,最后根据传入反射产生实例对象;用户调用的时候,直接传入

    调用类型即可(统一实现类命名规范xxxOperation);只需调整工厂类即可,其他不变:

    import java.lang.reflect.InvocationTargetException;
    import java.util.Optional;
    
    /**
      *
      * <p>Title:工厂类</p >
      * <p>ClassName:MatchFactory</p >
      * @author kevin
      * @date 2021/1/26
      */
    public class MathFactory {
    
        private MathFactory() {
            //do nothing
        }
    
        /**
          * 获得具体的操作类型
          * @author kevin
          * @param operator :
          * @return java.util.Optional<com.liu.test.math.MathOperation>
          * @date 2021/1/26 11:36
          */
        public static Optional<MathOperation> getOperation(String operator) throws ClassNotFoundException,
                IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
            //因为类名首字母大写,所以转换操作类型为类名格式
            String operate = operator.substring(0,1).toUpperCase() + operator.substring(1).toLowerCase();
            Class<?> operation = Class.forName("com.liu.test.math.operation." + operate+"Operation");
            return Optional.of((MathOperation)operation.getDeclaredConstructor().newInstance());
        }
    }

    2.工厂方法模式:

    工厂提供接口与实现,实例提供接口与实现

           为了解决第一种简单工厂模式的缺陷,产生了工厂方法模式,把工厂方法再次进行抽象,

    为不同的实现类,提供不同的工厂,通过实现抽象工厂接口类的方法,实现不同工厂获取

    业务实现类的不同实例,调用的时候,通过判断,使用不同的工厂(在简单工厂模式基础上)

    抽象一个工厂接口:

    import java.util.Optional;
    
    public interface MathFactoryInterface {
    
        Optional<MathOperation> getOperation(String operator) ;
    }

    工厂接口实现(顺序-加减乘除):

    import com.liu.test.factory.simplefactory.MathOperation;
    import com.liu.test.factory.factorymethod.MathFactoryInterface;
    import com.liu.test.factory.simplefactory.operation.AddOperation;
    
    import java.util.Optional;
    
    public class AddFactory implements MathFactoryInterface {
        @Override
        public Optional<MathOperation> getOperation() {
            return Optional.of(new AddOperation());
        }
    }
    import com.liu.test.factory.simplefactory.MathOperation;
    import com.liu.test.factory.factorymethod.MathFactoryInterface;
    import com.liu.test.factory.simplefactory.operation.SubOperation;
    
    import java.util.Optional;
    
    public class SubFactory implements MathFactoryInterface {
        @Override
        public Optional<MathOperation> getOperation() {
            return Optional.of(new SubOperation());
        }
    }
    import com.liu.test.factory.factorymethod.MathFactoryInterface;
    import com.liu.test.factory.factorymethod.operation.MultiplyOperation;
    import com.liu.test.factory.simplefactory.MathOperation;
    
    import java.util.Optional;
    
    public class MultiplyFactory implements MathFactoryInterface {
        @Override
        public Optional<MathOperation> getOperation() {
            return Optional.of(new MultiplyOperation());
        }
    }
    import com.liu.test.factory.factorymethod.MathFactoryInterface;
    import com.liu.test.factory.factorymethod.operation.DivideOperation;
    import com.liu.test.factory.simplefactory.MathOperation;
    
    import java.util.Optional;
    
    public class DivideFactory implements MathFactoryInterface {
        @Override
        public Optional<MathOperation> getOperation() {
            return Optional.of(new DivideOperation());
        }
    }

    将原有的工厂类MathFactory删除,使用类中调整-增加方法:

        /**
          * 工厂方法模式
          * @author kevin
          * @param operator :
          * @return com.liu.test.math.factorymethod.MathFactoryInterface
          * @date 2021/1/26 18:41
          */
        private MathFactoryInterface getFactory(String operator){
            MathFactoryInterface result = null;
            if("add".equals(operator)){
                result = new AddFactory();
            }else if("sub".equals(operator)){
                result = new SubFactory();
            }else if("multiply".equals(operator)){
                result = new MultiplyFactory();
            }else if("divide".equals(operator)){
                result = new DivideFactory();
            }
            return Optional.ofNullable(result).orElseThrow(() -> new IllegalArgumentException("未知的操作"));
        }

    使用类中调整-更改调用方式:

            double result;
            MathFactoryInterface factory = getFactory(operator);
            MathOperation operation = factory.getOperation().orElseThrow(() ->
                    new IllegalArgumentException("未知的操作"));
            result = operation.apply(first, second);
            return String.valueOf(result);

    3.抽象工厂模式:

    提供工厂的接口与实现,提供实例的接口与实现,有不同类型的实例(每个类型下有多个实例)

           就是将操作归类,然后分别提供接口,同类下的具体事物实现同一个接口。然后抽象一个工厂接口,

    按照不同类别,提供不同的待实现工厂方法;再提供具体的工厂实现类,实现抽象的工厂接口,并在不

    同的方法(同一类事物的获取方法)中根据入参返回同类事物中具体的事物,最后给到调用者执行。

    比如,阿里与百度都有开发人员与产品人员:

    首先定义开发人员接口、产品人员接口:

    /**
      *
      * <p>Title:开发人员</p >
      * <p>ClassName:IDeveloper</p >
      * @author kevin
      * @date 2021/1/27
      */
    public interface IDeveloper {
        String work();
        String skill();
    }
    /**
      *
      * <p>Title:产品人员</p >
      * <p>ClassName:IProductor</p >
      * @author kevin
      * @date 2021/1/27
      */
    public interface IProductor {
        String work();
        String skill();
    }

    开发人员接口实现:

    import com.liu.test.factory.abstractfactory.cases.IDeveloper;
    
    public class AliDeveloper implements IDeveloper {
        @Override
        public String work() {
    
            return "我是阿里开发人员,我的工作是:为阿里服务!";
        }
    
        @Override
        public String skill() {
    
            return "我是阿里开发人员,我的技能是:java、python、vue、react、js、c、c++、c#......无所不能!";
        }
    }
    import com.liu.test.factory.abstractfactory.cases.IDeveloper;
    
    public class BaiduDeveloper implements IDeveloper {
        @Override
        public String work() {
    
            return  "我是百度开发人员,我的工作是:为百度服务!";
        }
    
        @Override
        public String skill() {
    
            return  "我是百度开发人员,我的技能是:人工智能、java、python、vue、react、js、c、c++、c#......我也无所不能!";
        }
    }

    产品人员接口实现:

    import com.liu.test.factory.abstractfactory.cases.IProductor;
    
    public class AliProductor implements IProductor {
        @Override
        public String work() {
    
            return  "我是阿里产品,我的工作是:为阿里提供优秀的产品!";
        }
    
        @Override
        public String skill() {
    
            return "我是阿里产品,我的技能是:需求与利益的平衡能力,缜密的逻辑思维和较高的业务理解能力!";
        }
    }
    import com.liu.test.factory.abstractfactory.cases.IProductor;
    
    public class BaiduProductor implements IProductor {
        @Override
        public String work() {
    
            return "我是百度产品,我的工作是:为百度提供优秀的产品!";
        }
    
        @Override
        public String skill() {
    
            return "我是百度产品,我的技能是:需求与利益的平衡能力,缜密的逻辑思维和较高的业务理解能力!";
        }
    }

     

    定义工厂接口:

    import com.liu.test.factory.abstractfactory.cases.IDeveloper;
    import com.liu.test.factory.abstractfactory.cases.IProductor;
    
    import java.lang.reflect.InvocationTargetException;
    
    public interface IFactory {
        IProductor getProductor(String type) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException,
                InvocationTargetException, InstantiationException;
    
        IDeveloper getDeveloper(String type) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException,
                InvocationTargetException, InstantiationException;
    }

    阿里工厂接口实现(反射获得实例):

    import com.liu.test.factory.abstractfactory.IFactory;
    import com.liu.test.factory.abstractfactory.cases.IDeveloper;
    import com.liu.test.factory.abstractfactory.cases.IProductor;
    
    import java.lang.reflect.InvocationTargetException;
    import java.util.Optional;
    
    public class AliFactory implements IFactory {
    
        @Override
        public IProductor getProductor(String type) throws ClassNotFoundException, NoSuchMethodException,
                IllegalAccessException, InvocationTargetException, InstantiationException {
            //因为类名首字母大写,所以转换操作类型为类名格式
            String operate = type.substring(0,1).toUpperCase() + type.substring(1).toLowerCase();
            Class<?> operation = Class.forName("com.liu.test.factory.abstractfactory.cases.impl." + operate + "Productor");
            return Optional.of((IProductor)operation.getDeclaredConstructor().newInstance()).orElseThrow(() ->
                    new IllegalArgumentException("未知的公司"));
        }
    
        @Override
        public IDeveloper getDeveloper(String type) throws ClassNotFoundException, NoSuchMethodException,
                IllegalAccessException, InvocationTargetException, InstantiationException {
            //因为类名首字母大写,所以转换操作类型为类名格式
            String operate = type.substring(0,1).toUpperCase() + type.substring(1).toLowerCase();
            Class<?> operation = Class.forName("com.liu.test.factory.abstractfactory.cases.impl." + operate + "Developer");
            return Optional.of((IDeveloper)operation.getDeclaredConstructor().newInstance()).orElseThrow(() ->
                    new IllegalArgumentException("未知的公司"));
        }
    }

    百度工厂接口实现(反射获得实例):

    import com.liu.test.factory.abstractfactory.IFactory;
    import com.liu.test.factory.abstractfactory.cases.IDeveloper;
    import com.liu.test.factory.abstractfactory.cases.IProductor;
    
    import java.lang.reflect.InvocationTargetException;
    import java.util.Optional;
    
    public class BaiduFactory implements IFactory {
    
        @Override
        public IProductor getProductor(String type) throws ClassNotFoundException, NoSuchMethodException,
                IllegalAccessException, InvocationTargetException, InstantiationException {
            //因为类名首字母大写,所以转换操作类型为类名格式
            String operate = type.substring(0,1).toUpperCase() + type.substring(1).toLowerCase();
            Class<?> operation = Class.forName("com.liu.test.factory.abstractfactory.cases.impl." + operate + "Productor");
            return Optional.of((IProductor)operation.getDeclaredConstructor().newInstance()).orElseThrow(() ->
                    new IllegalArgumentException("未知的公司"));
        }
    
        @Override
        public IDeveloper getDeveloper(String type) throws ClassNotFoundException, NoSuchMethodException,
                IllegalAccessException, InvocationTargetException, InstantiationException {
            //因为类名首字母大写,所以转换操作类型为类名格式
            String operate = type.substring(0,1).toUpperCase() + type.substring(1).toLowerCase();
            Class<?> operation = Class.forName("com.liu.test.factory.abstractfactory.cases.impl." + operate + "Developer");
            return Optional.of((IDeveloper)operation.getDeclaredConstructor().newInstance()).orElseThrow(() ->
                    new IllegalArgumentException("未知的公司"));
        }
    }

    通过调用不同的抽象工厂的实现获得具体的实例,执行方法得到想要的结果。

            String result = "";
            //获得具体的工厂(反射)
            String operate = operator.substring(0,1).toUpperCase() + operator.substring(1).toLowerCase();
            Class<?> operation = Class.forName("com.liu.test.factory.abstractfactory.factory." + operate + "Factory");
            IFactory factory = (IFactory)operation.getDeclaredConstructor().newInstance();
            //通过工厂获得公司开发人员
            IDeveloper developer = factory.getDeveloper(operate);
            result += developer.work() +"\n";
            result += developer.skill() +"\n";
            //通过工厂获得公司产品人员
            IProductor productor = factory.getProductor(operate);
            result += productor.work() +"\n";
            result += productor.skill() +"\n";
            return result;

     

    展开全文
  • 主要介绍了Java设计模式编程中的单例模式和简单工厂模式以及实例,使用设计模式编写代码有利于团队协作时程序的维护,需要的朋友可以参考下
  • 说明:本文是《大话设计模式》的学习记录及结合网上相关信息编写,原书代码例子采用C#编写,本文采用Java稍加改写。...简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例简单工厂模式工厂模式家族...

    说明本文是《大话设计模式》的学习记录及结合网上相关信息编写,原书代码例子采用C#编写,本文采用Java稍加改写。如有不当,欢迎指正,共同进步。


    1.简单工厂模式概述:

          简单工厂模式是属于创建型模式,又叫做静态工厂方法(Static Factory Method)模式,但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式,可以理解为是不同工厂模式的一个特殊实现。


    2.简单工厂模式包含的角色及其职责:

    (1)工厂角色[Creator]:简单工厂模式的核心,它负责实现创建所有实例的内部逻辑。工厂类的创建产品类的方法可以被外界直接调用,创建所需的产品对象。
    (2)抽象产品角色[Product]:简单工厂模式所创建的所有对象的父类,它负责描述所有实例所共有的公共接口。

    (3)具体产品角色[Concrete Product]:简单工厂模式的创建目标,所有创建的对象都是充当这个角色的某个具体类的实现。


    3.简单工厂模式的实现方式及UML类图:

    (1)实现方式:简单工厂模式的实质是由一个工厂类根据传入的参数,动态决定应该创建哪一个产品类(这些产品类继承自一个父类或接口)的实例。

    (2)UML类图:


    4.Java案例代码:

    (1)抽象产品角色:

    package SimpleFactoryModel;
    
    /**
     * 运算类
     */
    public abstract class Operation {
    	private double number1;
    	private double number2;
    	
    	public double getNumber1() {
    		return number1;
    	}
    	public void setNumber1(double number1) {
    		this.number1 = number1;
    	}
    	public double getNumber2() {
    		return number2;
    	}
    	public void setNumber2(double number2) {
    		this.number2 = number2;
    	}
    	
    	public  abstract Double getResult() throws Exception;
    	
    }

    (2)具体产品角色:

    package SimpleFactoryModel;
    
    /**
     * 加法运算类,继承运算类
     */
    public class OperationAdd extends Operation {
    
    	@Override
    	public Double getResult() {
    		//super.getNumber1()+super.getNumber2();
    		return getNumber1()+getNumber2();
    	}
    
    }
    
    
    package SimpleFactoryModel;
    
    /**
     * 减法运算类,继承运算类
     */
    public class OperationSub extends Operation {
    
    	@Override
    	public Double getResult() {
    		//super.getNumber1()+super.getNumber2();
    		return getNumber1()-getNumber2();
    	}
    
    }
    
    
    package SimpleFactoryModel;
    
    /**
     * 乘法运算类,继承运算类
     */
    public class OperationMul extends Operation {
    
    	@Override
    	public Double getResult() {
    		//super.getNumber1()+super.getNumber2();
    		return getNumber1()*getNumber2();
    	}
    
    }
    
    
    package SimpleFactoryModel;
    
    /**
     * 除法运算类,继承运算类
     */
    public class OperationDiv extends Operation {
    
    	@Override
    	public Double getResult() throws Exception {
    		if (getNumber2()==0) {
    			throw new ArithmeticException("除数不能为'0'!");
    		}
    		//super.getNumber1()+super.getNumber2();
    		return getNumber1()/getNumber2();
    	}
    
    }
    
    
    
    

    (3)工厂角色:

    package SimpleFactoryModel;
    
    /**
     * 简单运算工厂类
     */
    public class OperationFactory {
    	public static Operation oper = null;
    
    	public static Operation createOperation(String operator) {
    		//根据传入的运算符生产出相对应的运算对象
    		switch (operator) {
    		case "+":
    			oper=new OperationAdd();
    			break;
    		case "-":
    			oper=new OperationSub();
    			break;
    		case "*":
    			oper=new OperationMul();
    			break;
    		case "/":
    			oper=new OperationDiv();
    			break;
    		default:
    			break;
    		}
    		return oper;
    	}
    }
    

    (4)客户端测试代码:

    package SimpleFactoryModel;
    
    /**
     * 客户端测试代码
     */
    public class Test {
    	public static void main(String[] args) throws Exception {
    		//加法
    		Addpend(1,1);
    		//减法
    		Subtract(1,1);
    		//乘法
    		Multiply(1,1);
    		//除法
    		Divide(1,1);
    	}
    	public static void Addpend(double number1,double number2) throws Exception {
    		String add = "+";
    		Operation Add = OperationFactory.createOperation(add);
    		Add.setNumber1(number1);
    		Add.setNumber2(number2);
    		Double result = Add.getResult();
    		System.out.println("加法:"+result);
    	}
    	
    	public static void Subtract(double number1,double number2) throws Exception {
    		String sub = "-";
    		Operation Sub = OperationFactory.createOperation(sub);
    		Sub.setNumber1(number1);
    		Sub.setNumber2(number2);
    		Double result = Sub.getResult();
    		System.out.println("减法:"+result);
    	}
    	
    	public static void Multiply(double number1,double number2) throws Exception {
    		String mul = "*";
    		Operation Mul = OperationFactory.createOperation(mul);
    		Mul.setNumber1(number1);
    		Mul.setNumber2(number2);
    		Double result = Mul.getResult();
    		System.out.println("乘法:"+result);
    	}
    	
    	public static void Divide(double number1,double number2) throws Exception {
    		String div = "/";
    		Operation Div = OperationFactory.createOperation(div);
    		Div.setNumber1(number1);
    		Div.setNumber2(number2);
    		Double result = Div.getResult();
    		System.out.println("除法:"+result);
    	}
    
    }
     
    
    

    (5)客户端测试代码打印结果:


    5.简单工厂模式的优缺点及使用场景:

    (1)优点:工厂类是整个模式的关键,包含了必要的逻辑判断,根据外界给定的信息,决定究竟应该创建哪个具体类的对象。通过使用工厂类,外界可以从直接创建具体产品对象的尴尬局面摆脱出来,仅仅需要负责“消费”对象就可以了,而不必管这些对象究竟如何创建及如何组织的。明确了各自的职责和权利,有利于整个软件体系结构的优化。


    (2)缺点:由于工厂类集中了所有实例的创建逻辑,违反了高内聚责任分配原则,将全部创建逻辑集中到了一个工厂类中;它所能创建的类只能是事先考虑到的,如果需要添加新的类,则就需要改变工厂类了。当系统中的具体产品类不断增多时候,可能会出现要求工厂类根据不同条件创建不同实例的需求。这种对条件的判断和对具体产品类型的判断交错在一起,很难避免模块功能的蔓延,对系统的维护和扩展非常不利。


    (3)使用场景:①工厂类负责创建的对象比较少;
                            ②客户只知道传入工厂类的参数,对于如何创建对象(逻辑)不关心;

    由于简单工厂很容易违反高内聚责任分配原则,因此我们一般只在很简单的情况下会去应用它。


    展开全文
  • 主要介绍了Java设计模式编程中简单工厂与抽象工厂模式的使用实例,简单工厂与抽象工厂都可以归类于设计模式中的创建型模式,需要的朋友可以参考下
  • Java工厂模式案例

    2019-01-17 16:36:01
    1.简单工厂模式(simple factory)2.工厂方法模式(factory mathoud)3.抽象工厂模式(abstract factory)
  • java设计模式之抽象工厂模式实例----手机工厂,一个简单的例子,有助于理解抽象工厂模式
  • 主要介绍了java设计模式之工厂模式,结合具有实例形式分析了java工厂模式的概念、原理、实现与使用方法,需要的朋友可以参考下
  • Java简单工厂模式和传统模式实现对比,通过简单实例比对两种方式差异,体现传统模式的弊端及工厂模式优势。利于初学者后续接触spring
  • java语言实现工厂方法模式和抽象工厂模式
  • 主要介绍了java 工厂模式实例详解的相关资料,这里举例说明该如何实现工厂模式,需要的朋友可以参考下
  • java-简单工厂模式实例及讲解

    千次阅读 2019-05-15 18:55:40
    简单工厂模式 工厂模式(Factory Pattern)是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。在工厂模式中,我们在创建对象时不会对客户端暴露创建逻辑,并且...

    简单工厂模式

    工厂模式(Factory Pattern)是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。在工厂模式中,我们在创建对象时不会对客户端暴露创建逻辑,并且是通过使用一个共同的接口来指向新创建的对象。

    介绍

    意图:定义一个创建对象的接口或者抽象类,让其子类自己决定实例化哪一个工厂类,工厂模式使其创建过程延迟到子类进行。

    主要解决:主要解决接口选择的问题。

    何时使用:我们明确地计划不同条件下创建不同实例时。

    如何解决:让其子类实现工厂接口,返回的也是一个抽象的产品。

    关键代码:创建过程在其子类执行。

    优点: 1、一个调用者想创建一个对象,只要知道其名称就可以了。 2、扩展性高,如果想增加一个产品,只要扩展一个工厂类  就可以。 3、屏蔽产品的具体实现,调用者只关心产品的接口。

    缺点:每次增加一个产品时,都需要增加一个具体类和对象实现工厂,使得系统中类的个数成倍增加,在一定程度上增加了系统  的复杂度,同时也增加了系统具体类的依赖。这并不是什么好事。

    使用场景: 1、日志记录器:记录可能记录到本地硬盘、系统事件、远程服务器等,用户可以选择记录日志到什么地方。 2、数  据库访问,当用户不知道最后系统采用哪一类数据库,以及数据库可能有变化时。 3、设计一个连接服务器的框架,需要三个协议,"POP3"、"IMAP"、"HTTP",可以把这三个作为产品类,共同实现一个接口。

    注意事项:作为一种创建类模式,在任何需要生成复杂对象的地方,都可以使用工厂方法模式。有一点需要注意的地方就是复杂  对象适合使用工厂模式,而简单对象,特别是只需要通过 new 就可以完成创建的对象,无需使用工厂模式。如果使用工厂模式,就需要引入一个工厂类,会增加系统的复杂度。

     

    实例场景:开发一个类似计算器的JAVA程序。

    1.抽象类或者接口:Operator.java

    abstract class Operator {
    
    	private double number1;
    	private double number2;
    	
           //用于四则运算类进行实现
    	public abstract double getResult();
    	
    	public double getNumber1() {
    		return number1;
    	}
    	public void setNumber1(double number1) {
    		this.number1 = number1;
    	}
    	public double getNumber2() {
    		return number2;
    	}
    	public void setNumber2(double number2) {
    		this.number2 = number2;
    	}
    	
    }
    

        2.实现类(各种运算的处理类)

    /**
     * 加法运算
    **/
    public class OperatorAdd extends Operator {
    
    	@Override
    	public double getResult() {
    		return getNumber1() + getNumber2();
    	}
    
    }
    
    /**
     * 减法运算
    **/
    
    public class OperatorSub extends Operator {
    
    	@Override
    	public double getResult() {
    		return getNumber1() - getNumber2();
    	}
    }
    
    /**
     * 乘法运算
    **/
    public class OperatorMul extends Operator {
    
    	@Override
    	public double getResult() {
    		return getNumber1()*getNumber2();
    	}
    }
    
    /**
     * 除法运算
    **/
    public class OperatorDiv extends Operator {
    
    	@Override
    	public double getResult() {
    		if(getNumber2()==0) {
    			try {
    				throw new Exception("除数不能为0");
    			} catch (Exception e) {
    				e.printStackTrace();
    			}
    		}
    		return getNumber1()/getNumber2();
    	}
    }

       3.创建实例的工厂类:OperatorFactory.java

    public class OperatorFactory {
    	
    	public Operator createOperator(String op) {
    		Operator operator = null;
    		switch(op) {
    			case "+" : operator = new OperatorAdd();break; 
    			case "-" : operator = new OperatorSub();break;
    			case "*" : operator = new OperatorMul();break;
    			case "/" : operator = new OperatorDiv();break;
    		}
    		return operator;
    	}
    }

    4.测试(Junit)

    import org.junit.Test;
    
    public class TestMain {
    	@Test
    	public void test() {
    		OperatorFactory factory = new OperatorFactory();
    		Operator operator = factory.createOperator("*");
    		operator.setNumber1(10.2);
    		operator.setNumber2(5.2);
    		double result = operator.getResult();
    		System.out.println(result);
    	}
    }

     

    当我们有新的运算规则需要添加时,添加新的计算逻辑类以及在工厂类(OperatorFactory)中新增规则就可以。

    展开全文
  • 抽象工厂模式 JAVA设计模式
  • 设计模式之简单工厂模式案例
  • 当系统准备为用户提供某个类的子类的实例,又不想让用户代码和该子类形成耦合时,就可以使用...工厂方法模式的关键是在一个接口或抽象类中定义一个抽象方法,下面我们会具体介绍Java使用设计模式中的工厂方法模式实例解析.
  • 主要介绍了Java设计者模式简单工厂模式解析,介绍了其简介,实例以及优缺点分析,具有一定参考价值,需要的朋友可以了解下。
  • NULL 博文链接:https://tim-fly.iteye.com/blog/1621579
  • 主要介绍了Java工厂模式定义与用法,结合具体实例形式分析了java工厂模式定义、使用相关操作技巧,并总结了类图原理,需要的朋友可以参考下
  • 主要介绍了Java设计模式之抽象工厂模式,结合实例形式分析了抽象工厂模式的概念、功能、定义与使用方法,需要的朋友可以参考下
  • 简单工厂模式java实现例子

    千次阅读 2016-09-26 16:29:36
    1、工厂角色:简单工厂模式的核心,它负责实现创建所有实例的内部逻辑。工厂类的创建产品类的方法可以被外界直接调用,创建所需的产品对象。 2、抽象产品角色:简单工厂模式所创建的所有对象的父类,它负责描述所有...
  • 简单工厂模式工厂模式中家族最简单实用的模式,可以理解为不同工厂模式的一个特殊的实现。...简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。作用介绍简单工厂模式之前通过一个披萨项目...
  • 简单工厂模式的实质是由一个工厂类根据传入的参数,动态决定应该创建哪一个产品类(这些产品类继承自一个父类或接口)的实例。  简单工厂模式的UML图  简单工厂模式代码  学习简单工厂模式的时候我用的是...
  • java三种工厂模式文档+三个实例,里面有个word文档是学习文档 然后配套有三个项目学习
  • 本人大四,根据老师要求写的一份抽象工厂模式的例子。你们下载下来导入myclipse中即可使用。其中在测试Test.java中,你们可以看看运行效果
  • 简单工厂模式实例学习(一)

    千次阅读 2018-05-31 14:59:49
    一、简单工厂模式简单工厂模式最直接的目的就是为了解耦,把对象的创建和使用的过程分开。用工厂方法来代替new操作的一种模式。在工厂模式中,我们在创建对象时不会对客户端暴露创建逻辑,并且是通过使用一个共同的...
  • 主要为大家详细介绍了java设计模式之简单工厂模式简单工厂模式的实质是由一个工厂类根据传入的参数,动态决定应该创建哪一个产品类的实例,感兴趣的小伙伴们可以参考一下
  • 本文实例讲述了javascript设计模式 – 简单工厂模式。分享给大家供大家参考,具体如下: 介绍:简单工厂模式是最常用的一类创建型设计模式。其中简单工厂模式并不属于GoF23个经典设计模式,它通常被作为学习其他工厂...
  • Java代码实现简单工厂模式

    千次阅读 2018-10-05 22:01:32
    模式定义 简单工厂模式(Simple ...简单工厂模式专门定义一个类来负责创建其他类的实例,被创建的实例通常都具有共同的父类。 模式结构 简单工厂模式包含如下角色: Factory:工厂角色 Product:抽象产品角色 C...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 137,388
精华内容 54,955
关键字:

java简单工厂模式实例

java 订阅