精华内容
下载资源
问答
  • java工厂设计模式

    2019-03-21 19:44:43
    本例子主要说明java设计模式---工厂设计,主要基础知识为接口与接口的实现
  • java工厂设计模式之简单工厂实例以及介绍,程序已经运行过能正常跑通
  • java工厂设计模式讲解+例子,三种工厂模式的讲解,简单工厂、工厂方法、抽象工厂
  • java工厂设计模式.doc

    2009-04-07 13:09:19
    java工厂设计模式,非常详细的介绍了工厂设计模式,里面有很多例子,讲解深入浅出。
  • 例题简单的阐述了Java工厂模式的概念,有利于读者更好地了解Java工厂模式
  • Java工厂设计模式论文

    千次阅读 2008-01-07 12:15:00
    Java工厂设计模式论文 一. 程序设计目标 我们组写了个简单的水果生产程序,描述农场种植水果的过程,旨在通过此次设计更进一步了解工程设计模式,加强编程的结构化能力

     

     

     

     

     

     

     

     

     

     

     

     

     

    Java工厂设计模式论文

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

    一.  程序设计目标

     

        我们组写了个简单的水果生产程序,描述农场种植水果的过程,旨在通过此次设计更进一步了解工程设计模式,加强编程的结构化能力。

        开发环境:JDK1.5

    开发工具:JBuilder 2006

     

    二.程序设计介绍

     

    1.程序结构

       我们组为一个水果公司写了个简单的生产程序,该公司专门向市场销售各类水果。我们为程序建立了一个名为farm的工程,程序结构比较简单,总共有7个类,并且都放在一个默认的包中。其层次结构可从下图体现出来:

    对各个类的说明:

     

    Fruit类:水果接口,实现水果方法

    Apple类:苹果类,实现Fruit接口

    Grape类:葡萄类,实现Fruit接口

    Strawberry类:草莓类,实现Fruit接口

    FruitGardener类:园丁类,可种植各种水果

    BadFruitException类:要种植的水果不在公司经营的水果范围之内,抛出种植异常

    PlantFruit类:实现main()方法

     

    2.程序设计步骤

    在这个系统里需要描述下列的水果:

    葡萄 Grape

    草莓 Strawberry

    苹果 Apple

    水果与其他的植物有很大的不同,就是水果最终是可以采摘食用的。那么一个自然的

    作法就是建立一个各种水果都适用的接口,以便与农场里的其他植物区分开。如下图所示。

     

    水果接口规定出所有的水果必须实现的接口,包括任何水果类必须具备的方法:种植plant(),生长grow()以及收获harvest()。接口Fruit 的类图如下所示。

    这个水果接口的源代码如下所示。

     

    代码清单1:接口Fruit 的源代码

    public interface Fruit {

    // 生长

      void grow();

     

    //收获

      void harvest();

     

    //种植

      void plant();

    }描述苹果的Apple 类的源代码的类图如下所示。

     

    Apple 类是水果类的一种,因此它实现了水果接口所声明的所有方法。另外,由于苹果是多年生植物,因此多出一个treeAge 性质,描述苹果树的树龄。下面是这个苹果类的源代码。

     

    代码清单2:类Apple 的源代码

    public class Apple

        implements Fruit {

      private int treeAge;

    //生长

      public void grow() {

        log("Apple is growing...");

      }

     

    // 收获

      public void harvest() {

        log("Apple has been harvested.");

      }

     

    //种植

      public void plant() {

        log("Apple has been planted.");

      }

     

    // 辅助方法

      public static void log(String msg) {

        System.out.println(msg);

      }

     

    //树龄的取值方法

      public int getTreeAge() {

        return treeAge;

      }

     

    // 树龄的赋值方法

      public void setTreeAge(int treeAge) {

        this.treeAge = treeAge;

      }

    }

    同样,Grape 类是水果类的一种,也实现了Fruit 接口所声明的所有的方法。但由于葡萄分有籽和无籽两种,因此,比通常的水果多出一个seedless 性质,如下图所示。

    葡萄类的源代码如下所示。可以看出,Grape 类同样实现了水果接口,从而是水果类型的一种子类型。

     

    代码清单3:类Grape 的源代码

    public class Grape

        implements Fruit {

      private boolean seedless;

    //生长

      public void grow() {

        log("Grape is growing...");

      }

     

    //收获

      public void harvest() {

        log("Grape has been harvested.");

      }

     

    //种植

      public void plant() {

        log("Grape has been planted.");

      }

     

    //辅助方法

      public static void log(String msg) {

        System.out.println(msg);

      }

     

    // 有无籽的取值方法

      public boolean getSeedless() {

        return seedless;

      }

     

    //有无籽的赋值方法

      public void setSeedless(boolean seedless) {

        this.seedless = seedless;

      }

    }

    下图所示是Strawberry 类的类图。

    Strawberry 类实现了Fruit 接口,因此,也是水果类型的子类型,其源代码如下所示。

     

    代码清单4:类Strawberry 的源代码

    public class Strawberry

        implements Fruit {

    //生长

      public void grow() {

        log("Strawberry is growing...");

      }

     

    //收获

      public void harvest() {

        log("Strawberry has been harvested.");

      }

     

    //种植

      public void plant() {

        log("Strawberry has been planted.");

      }

     

    //辅助方法

      public static void log(String msg) {

        System.out.println(msg);

      }

    }

    农场的园丁也是系统的一部分,自然要由一个合适的类来代表。这个类就FruitGardener 类,其结构由下面的类图描述。

    FruitGardener 类会根据客户端的要求,创建出不同的水果对象,比如苹果(Apple),葡萄(Grape)或草莓(Strawberry)的实例。而如果接到不合法的要求,FruitGardener 类会抛出BadFruitException 异常,如下图所示。

    园丁类的源代码如下所示。

     

    代码清单5FruitGardener 类的源代码

    public class FruitGardener {

    //静态工厂方法

      public static Fruit factory(String which) throws BadFruitException {

        if (which.equalsIgnoreCase("apple")) {

          return new Apple();

        }

        else if (which.equalsIgnoreCase("strawberry")) {

          return new Strawberry();

        }

        else if (which.equalsIgnoreCase("grape")) {

          return new Grape();

        }

        else {

          throw new BadFruitException("Bad fruit request");

        }

      }

    }

     

    可以看出,园丁类提供了一个静态工厂方法。在客户端的调用下,这个方法创建客户端所需要的水果对象。如果客户端的请求是系统所不支持的,工厂方法就会抛出一个BadFruitException 异常。这个异常类的源代码如下所示。

     

    代码清单6BadFruitException 类的源代码

     

    public class BadFruitException

        extends Exception {

      public BadFruitException(String msg) {

        super(msg);

      }

    }

     

    在使用时,客户端只需调用FruitGardener 的静态方法factory()即可。请见下面的示意性客户端源代码。

     

    代码清单7:实现种植即Main()的实现

    public class PlantFruit {

      public PlantFruit() {

      }

     

      public static void main(String[] args) {

        PlantFruit plantfruit = new PlantFruit();

        try {

          //种植葡萄

          FruitGardener.factory("grape").plant();

          FruitGardener.factory("grape").grow();

          FruitGardener.factory("grape").harvest();

          System.out.println("==================================");

         

          //种植苹果

          FruitGardener.factory("apple").plant();

          FruitGardener.factory("apple").grow();

          FruitGardener.factory("apple").harvest();

          System.out.println("==================================");

         

          //种植草莓

          FruitGardener.factory("strawberry").plant();

          FruitGardener.factory("strawberry").grow();

          FruitGardener.factory("strawberry").harvest();

          System.out.println("==================================");

        }

        catch (BadFruitException e) {

        }

      }

    }

    到此为止,我们的简单程序已经设计完成,我们可以通过创建FruitGardener对象来完成水果的种植,无论你要种什么,只需调用对象中的factory()方法。输出结果如下:

     

     

    三.简单工厂模式的定义

     

    简单工厂模式是类的创建模式,又叫做静态工厂方法(Static Factory Method)模式。简单工厂模式是由一个工厂对象决定创建出那一种产品类的实例。

     

    四.简单工厂模式的结构

     

    简单工厂模式是类的创建模式,这个模式的一般性结构如下图所示。

    角色与结构

    简单工厂模式就是由一个工厂类可以根据传入的参量决定创建出哪一种产品类的实例。下图所示为以一个示意性的实现为例说明简单工厂模式的结构。

    从上图可以看出,简单工厂模式涉及到工厂角色、抽象产品角色以及具体产品角色等

    三个角色:

    1工厂类(Creator)角色:担任这个角色的是工厂方法模式的核心,含有与应用紧

    密相关的商业逻辑。工厂类在客户端的直接调用下创建产品对象,它往往由一个

    具体Java 类实现。

    2抽象产品(Product)角色:担任这个角色的类是工厂方法模式所创建的对象的父

    类,或它们共同拥有的接口。抽象产品角色可以用一个Java 接口或者Java 抽象类

    实现。

    3具体产品(Concrete Product)角色:工厂方法模式所创建的任何对象都是这个角

    色的实例,具体产品角色由一个具体Java 类实现。

     

    工厂类的示意性源代码如下所示。可以看出,这个工厂方法创建了一个新的具体产品的实例并返还给调用者。

     

    代码清单8Creator 类的源代码

    public class Creator

    {

    //静态工厂方法

    public static Product factory()

    {

    return new ConcreteProduct();

    }

    }

    抽象产品角色的主要目的是给所有的具体产品类提供一个共同的类型,在最简单的情况下,可以简化为一个标识接口。所谓标识接口,就是没有声明任何方法的空接口。

     

    代码清单9:抽象角色Product 接口的源代码

    public interface Product

    {

    }

     

    具体产品类的示意性源代码如下。

     

    代码清单10:具体产品角色ConcreteProduct 类的源代码

    public class ConcreteProduct implements Product

    {

    public ConcreteProduct(){}

    }

     

    虽然在这个简单的示意性实现里面只给出了一个具体产品类,但是在实际应用中一般都会遇到多个具体产品类的情况。

     

    五.简单工厂模式的实现

     

    1.多层次的产品结构

    在真实的系统中,产品可以形成复杂的等级结构,比如下图所示的树状结构上就有多个抽象产品类和具体产品类。

     

    这个时候,简单工厂模式采取的是以不变应万变的策略,一律使用同一个工厂类。如下图所示。

     

     

     

    图中从Factory 类到各个Product 类的虚线代表创建(依赖)关系;从Client 到其他类的联线是一般依赖关系。这样做的好处是设计简单,产品类的等级结构不会反映到工厂类中来,从而产品类的等级结构的变化也就不会影响到工厂类。但是这样做的缺点是,增加新的产品必将导致工厂类的修改。

     

    2. 使用Java 接口或者Java 抽象类

    如果模式所产生的具体产品类彼此之间没有共同的商业逻辑,那么抽象产品角色可以由一个Java 接口扮演;相反,如果这些具体产品类彼此之间确有共同的商业逻辑,那么这些公有的逻辑就应当移到抽象角色里面,这就意味着抽象角色应当由一个抽象类扮演。在一个类型的等级结构里面,共同的代码应当尽量向上移动,以达到共享的目的,如下图所示。

     

    六.模式的优点和缺点

     

    1. 模式的优点

    模式的核心是工厂类。这个类含有必要的判断逻辑,可以决定在什么时候创建哪一个产品类的实例。而客户端则可以免除直接创建产品对象的责任,而仅仅负责“消费”产品。简单工厂模式通过这种做法实现了对责任的分割。

    2. 模式的缺点

    正如同在本章前面所讨论的,当产品类有复杂的多层次等级结构时,工厂类只有它自

    己。以不变应万变,就是模式的缺点。这个工厂类集中了所有的产品创建逻辑,形成一个无所不知的全能类,有人把这种类叫做上帝类(God Class)。如果这个全能类代表的是农场的一个具体园丁的话,那么这个园丁就需要对所有的产品负责,成了农场的关键人物,他什么时候不能正常工作了,整个农场都要受到影响。将这么多的逻辑集中放在一个类里面的另外一个缺点是,当产品类有不同的接口种类时,工厂类需要判断在什么时候创建某种产品。这种对时机的判断和对哪一种具体产品的判断逻辑混合在一起,使得系统在将来进行功能扩展时较为困难。这一缺点在工厂方法模式中得到克服。

    由于简单工厂模式使用静态方法作为工厂方法,而静态方法无法由子类继承,因此,工厂角色无法形成基于继承的等级结构。这一缺点会在工厂方法模式中得到克服。

     

    七.个人体会  

         设计模式实际上是良好的OO思想的一种提炼。每一种设计模式后面都体现了一种良好的OO思路,这些思路对于解决软件中常见的“change”问题有很大的适应性,而每种模式又有自己独特的解决思路,带有一定的通用性。而组合各种模式又可以解决许多常见问题。不可否认的是,还存在一些未经总结的设计模式。实际上,你自己也可以总结一些模式出来。无论怎样,设计模式仍然是面向对象,它不是新东西,也没有必要言必称设计模式似乎不懂设计模式就落伍了,但给OO的开发者提供一个言简意赅的沟通桥梁。

    设计模式告诉了我们什么是好的OO思想,思考如何更好的应用OO的思想虽然还是那几个耳熟能详的术语:封装、继承、组合、多态。

    设计模式首先是对传统的OO使用方法的矫正:如针对接口编程而不是实现;优先使用组合,而不是继承。其次是在原来理解上的突破:封装是对变化而言的,不仅仅是属性和方法的集合。类不仅是现实事物的抽象,同时它还具有责任。更有创新:依赖式注入。

    模式不是万能的,也并不总能完美地解决问题,因此每种模式都包括了影响的信息。在应用模式之前,我们必须先分析问题的情境,并评估模式的影响,再决定是否采用模式,采用哪一种模式。也就是说,理解、分析模式,和实现模式一样重要

    八.建议

       (1)使用更加通俗易懂的语言解释设计模式,并用完整的代码实例辅以说明。代码的演示时间应延长点,好让学生看清,看懂代码。

        (2)在学生需要的时候给学生补充一点java知识,有些同学专注于其他语言,对于java也不太懂,听起课来一头雾水,这时候来点知识补充还是必要的。

     
    展开全文
  • java工厂设计模式(适合新人)

    千次阅读 2020-01-11 13:47:21
    个人理解:工厂设计模式可以理解为一个接口的集合,将许多接口封装在一个类里面,无论使用那个接口都得调用这个封装类。 比如:现在有一个汽车工厂,里面制造很多品牌的汽车,你想要一辆宝马车,你直接给工厂说“给...

    设计模式最常用的就是单例和工厂模式,单例的话主要是面试中会经常遇到,而工厂实际应用比较多,面试出现的几率也不小,话不多说,开始今天的课程。

    1,什么是工厂设计模式

    个人理解:工厂设计模式可以理解为一个接口的集合,将许多接口封装在一个类里面,无论使用那个接口都得调用这个封装类。
    比如:现在有一个汽车工厂,里面制造很多品牌的汽车,你想要一辆宝马车,你直接给工厂说“给我一辆宝马”,然后工厂就会给你一亮宝马,如果你要奔驰,你就说“给我一辆奔驰”,工厂就会给你一辆奔驰。

    2,为什么使用工厂设计模式

    要理解一个概念,工厂设计模式是一般底层程序员几乎用不到得东西,它一般都是架构这一块才用,它只要的目的就是方便隔离代码,也就是说身份的隔离,将架构师与普通程序员隔离开来。
    普通程序员只需要调用人家写好的封装类就行了。

    3,工厂设计模式案例

    1. 创建两个车,宝马和奔驰;
    package gongchang;
    
    public class baoma implements car{
    
    	@Override
    	public void run() {
    		System.out.println("这是一辆宝马!");
    	}
    	
    }
    
    package gongchang;
    
    public class benchi implements car{
    
    	@Override
    	public void run() {
    		System.out.println("这是一辆奔驰车!");
    
    		
    	}
    
    }
    
    1. 它们都实现了car这个类;
    package gongchang;
    
    public interface car {
    	//run方法表示启动的意思。
          public void run();
    }
    
    
    1. 设计一个工厂类
    package gongchang;
    
    public class gongchang {
    	 //这是一个汽车工厂
    	 public static car getcar(String carname){
    		car c = null;
    		if(carname == "宝马"){
    			c = new baoma();
    		}else if(carname == "奔驰"){
    			c = new benchi();
    		}
    		
    		return c;
    	}
    
    }
    
    1. 测试工厂类
    package gongchang;
    
    public class test {
    
    	public static void main(String[] args) {
    	
    		car c1 = gongchang.getcar("宝马");
    		car c2 = gongchang.getcar("奔驰");
    		c1.run();
    		c2.run();
    	}
    
    }
    
    展开全文
  • Java工厂设计模式——最容易理解版

    千次阅读 2016-09-18 16:59:07
    为什么要用工厂设计模式?  工厂设计模式就是用来帮助你new对象的。为什么不直接new对象,而是通过工厂模式呢?避免直接对对象进行创建,而且把所有的对象都集中起来管理,也可以在不改动应用程序的基础上直接添加...

    为什么要用工厂设计模式?

          工厂设计模式就是用来帮助你new对象的。为什么不直接new对象,而是通过工厂模式呢?避免直接对对象进行创建,而且把所有的对象都集中起来管理,也可以在不改动应用程序的基础上直接添加对象,便于对象的维护。

     

    工厂模式的种类:

        1、简单工厂
     

        场景:用户需要机器来生产布,但因为布有不同种类,所以需要不同的机器。工厂负责把这些机器生产出来。

        分析:对于机器来说,有一个共同的功能,就是work,这是接口;RedMachine只能生产红色的布,BlueMachine只能生产蓝色的布。

    //机器共同的方法work
    public interface Machine{
    	void work();
    }

     

    //RedMachine
    public class RedMachine implements Machine<span style="font-family: Arial, Helvetica, sans-serif;">{</span>
           @Override
    	public void work() {
    		System.out.println("red cloth");
    		
    	}
    }

     

    //BlueMachine
    public class BlueMachine implements Machine{
           @Override
    	public void work() {
    		System.out.println("blue cloth");
    		
    	}
    }

     

    /**
     * 普通工厂
     *
     */
    public class MachineFactory {
    	public Machine produce(String types){
    		if("red".equals(types)){
    			return new RedMachine();
    		}else{
    			return new BlueMachine();
    		}
    	}
    }


        2、工厂方法

     

        现在工厂只有固定的生产方法,如果工厂还有其他的一些方法,比如维修,因此,对工厂构造方法进行抽象。

        

    public interface FactoryMethod{
            Machine produce();
            Machine repair();
    }

     

    public class MachineFactory implements FactoryMethod{
            
           @override
    	public Machine produce(String types){
    		if("red".equals(types)){
    			return new RedMachine();
    		}else{
    			return new BlueMachine();
    		}
    	}
    
           @override
           public Machine repair(){
                   return null;
           }
    }


         3、 抽象工厂模式

     

         工厂方法模式还是只能够制造织布机器,但是有可能生产汽车,生产武器,所以工厂的抽象类提供创建一系列的对象的接口。

        

    //抽象工厂类
    public interface AbstractFactory {
        Vehicle createVehicle();
        Weapon createWeapon();
        Food createFood();
    }
    
    //具体工厂类,其中Food,Vehicle,Weapon是抽象类,
    public class DefaultFactory implements AbstractFactory{
        @Override
        public Food createFood() {
            return new Apple();
        }
        @Override
        public Vehicle createVehicle() {
            return new Car();
        }
        @Override
        public Weapon createWeapon() {
            return new AK47();
        }
    }

    总结:

    (1)简单工厂模式是由一个具体的类去创建其他类的实例,父类是相同的,父类是具体的。 
    (2)工厂方法模式是有一个抽象的父类定义公共接口,子类负责生成具体的对象,这样做的目的是将类的实例化操作延迟到子类中完成。 
    (3)抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口,而无须指定他们具体的类。它针对的是有多个产品的等级结构。而工厂方法模式针对的是一个产品的等级结构。

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

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

    千次阅读 2019-04-08 15:09:29
    总体的目录结构如下 1.基础工厂类 public interface ... * 工厂类的本质是帮助判断对应的实例,将这种判断放在工厂当中,那么就节省了让操作类自己来进行操作的性能判断,这是使用多态来解决父类和子类之间的...

    总体的目录结构如下
    在这里插入图片描述

    1.基础工厂类

    public interface BaseFactory {
    
    }
    

    2.拓展工厂类

    public class OperationFactoryimplements BaseFactory{
    
        /**
         * 工厂类的本质是帮助判断对应的实例,将这种判断放在工厂当中,那么就节省了让操作类自己来进行操作的性能判断,这是使用多态来解决父类和子类之间的差异
         *
         * @param operation
         * @return
         */
        public static Operation createOperation(String operation) {
    
            Operation oper =null;
    
            switch (operation) {
    
                case "+":
    
                    oper =new OperationAddServiceImpl();
    
                    break;
    
                case "-":
    
                    oper =new OperationSubServiceImpl();
    
                    break;
    
                case "*":
    
                    oper =new OperationMulServiceimpl();
    
                    break;
    
                case "/":
    
                    oper =new OperationDivServiceImpl();
    
                    break;
    
            }
    
            return oper;
    
        }
    
    }
    

    3.基础操作类

    public class Operation {
    
        protected DoublenumberA;
    
        protected DoublenumberB;
    
        public Double getNumberA() {
    
            return numberA;
    
        }
    
        public void setNumberA(Double numberA) {
    
            this.numberA = numberA;
    
        }
    
        public Double getNumberB() {
    
            return numberB;
    
        }
    
        public void setNumberB(Double numberB) {
    
            this.numberB = numberB;
    
        }
    
        /**
         * 子类当中复写了当前方法,所以会优先使用子类的方法,这就是一种多态的用法
         *
         * @return
         */
    
        public Double getResult() {
    
            Double result =0D;
    
            return result;
    
        }
    
    }
    

    4.加法Service

    public interface OperationAddService {
    
        /**
         * 两个数相加
         *
         * @return
         */
        Double getResult();
    
    }
    

    5.除法Service

    public interface OperationDivService {
    
        /**
         * 两数相除得到的结果
         *
         * @return
         */
        Double getResult();
    
    }
    

    6.乘法Service

    public interface OperationMulService {
    
        /**
         * 两个数相乘的结果
         *
         * @return
         */
        Double getResult();
    
    }
    

    7.减法Service

    public interface OperationSubService {
    
        /**
         * 两个数的减法
         *
         * @return
         */
        Double getResult();
    
    }
    

    8.加法ServiceImpl

    public class OperationAddServiceImplextends Operationimplements OperationAddService {
    
        @Override
    
        public Double getResult() {
    
            Double result =0D;
    
            result =numberA +numberB ;
    
            return result;
    
        }
    
    }
    

    9.除法ServiceImpl

    public class OperationDivServiceImplextends Operationimplements OperationDivService {
    
        @Override
    
        public Double getResult() {
    
            Double result =0D;
    
            if (numberB ==0){
    
                throw new LogicalException("除数不能为0");
    
            }
    
            result =numberA /numberB ;
    
            return result;
    
        }
    
    }
    

    10.减法ServiceImpl

    public class OperationSubServiceImplextends Operationimplements OperationSubService {
    
        @Override
    
        public Double getResult() {
    
            Double result =0D;
    
            result =numberA -numberB ;
    
            return result;
    
        }
    
    }
    

    11.Controller层

    @Controller
    public class OperationController {
    
        @Autowired
    
        OperationServiceoperationService;
    
        @RequestMapping("/index")
    
        public String index(){
    
            return "login";
    
        }
    
        @RequestMapping("/calculate")
    
        public String operation(Model model, Double numberA , Double numberB , String operation){
    
            Operation oper;
    
            oper = OperationFactory.createOperation(operation);
    
            oper.setNumberA(numberA);
    
            oper.setNumberB(numberB);
    
            model.addAttribute("result",oper.getResult());
    
            return "login";
    
        }
    
    }
    

    12.使用freemarker来作为前端展示

    <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
    
    <html>
    
    <head>
    
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    
        <title>页面</title>
    
    <body>
    
    <form action="/calculate" method="post" >
    
        numberA:<input type="text" size="30" name="numberA"><br>
    
        numberB:<input type="text" size="30" name="numberB"><br>
    
        <select class="form-control" name="operation" id="state">
    
            <option value="+">+</option>
    
            <option value="-">-</option>
    
            <option value="*">*</option>
    
            <option value="/">/</option>
    
        </select><input type="submit" value="comfirm"><br>
    
        结果:<input type="text" value="${(result)!""}" readonly>
    
    </form>
    
    </body>
    
    </html>
    
    展开全文
  • JAVA设计模式之单例模式

    万次阅读 多人点赞 2014-04-16 06:51:34
     java中单例模式是一种常见的设计模式,单例模式的写法有好几种,这里主要介绍三种:懒汉式单例、饿汉式单例、登记式单例。  单例模式有以下特点:  1、单例类只能有一个实例。  2、单例类必须自己创建自己的...
  • 主要介绍了Java设计模式——工厂设计模式详解,具有一定参考价值,需要的朋友可以了解下。
  • 设计模式 - 创建型模式 - 抽象工厂模式(Java

    万次阅读 多人点赞 2019-02-02 15:16:02
    单独看 CPU 工厂和主板工厂,它们分别是前面我们说的工厂模式。这种方式也容易扩展,因为要给电脑加硬盘的话,只需要加一个 HardDiskFactory 和相应的实现即可,不需要修改现有的工厂。 但是,这种方式有一个问题,...
  • 主要为大家详细介绍了java设计模式之工厂方法模式,什么是java工厂方法模式,感兴趣的小伙伴们可以参考一下
  • java设计模式工厂模式java设计模式工厂模式java设计模式工厂模式java设计模式工厂模式java设计模式工厂模式java设计模式工厂模式java设计模式工厂模式java设计模式工厂模式java设计模式工厂模式...
  • Java设计模式——工厂设计模式

    千次阅读 2018-05-21 17:59:06
    我们都知道面向对象编程有三大特征:封装,集成和多态,那我们如何在实际开发中去灵活运用它呢,今天我给大家聊一聊简单工厂设计模式。简单工厂设计模式的一个核心思想就是高内聚,低耦合,使具体的业务逻辑实现功能...
  • 主要为大家详细介绍了Java设计模式工厂模式,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • java,设计模式中的一种,工厂设计模式
  • 创建者模式中的工厂模式
  • 当系统准备为用户提供某个类的子类的实例,又不想让用户代码和该子类形成耦合时,就可以使用...工厂方法模式的关键是在一个接口或抽象类中定义一个抽象方法,下面我们会具体介绍Java使用设计模式中的工厂方法模式实例解析.
  • Java设计模式之简单工厂设计模式

    千次阅读 2016-05-14 08:51:47
    简单工厂设计模式工厂设计模式家族中最简单实用的模式 我们还是通过例子进行说明 实例场景:假设就是一个工厂生产phone和tv,他们都有一个共同的方法working(),于是我们定义了一个统一的接口Work,让其子类实现该...
  • 主要介绍了Java设计模式之工厂方法模式,较为详细的分析了Java工厂模式的功能、定义并给出了实例代码加以总结分析,需要的朋友可以参考下
  • 主要介绍了Java设计模式编程中的工厂方法模式和抽象工厂模式,设计模式的建立有利于团队协作时代码的共同维护,需要的朋友可以参考下
  • Java设计模式-工厂模式

    千次阅读 2021-08-06 09:27:36
    Java设计模式-工厂模式 什么是工厂模式? 工厂模式(Factory Pattern)是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。 在工厂模式中,我们在创建对象时不会...
  • 主要介绍了java设计模式之工厂模式,结合具有实例形式分析了java工厂模式的概念、原理、实现与使用方法,需要的朋友可以参考下
  • 主要介绍了java设计模式学习之工厂方法模式,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 设计模式: Java中的工厂设计模式

    千次阅读 2018-08-22 23:22:26
    工厂设计模式(Factory Design Pattern)属于创建模式之一,工厂设计模式在JDK,Spring,Stuts被广泛使用 当一个类或者接口有多个子类,并且基于输入返回特定的子类,此时会使用工厂设计模式。这种模式负责从客户端到...
  • 主要介绍了Java设计模式之工厂模式(Factory模式)介绍,本文讲解了为何使用工厂模式、工厂方法、抽象工厂、Java工厂模式举例等内容,需要的朋友可以参考下
  • Java常见设计模式总结

    万次阅读 多人点赞 2021-09-18 17:18:54
    设计模式是一套经过反复使用的代码设计经验,目的是为了重用代码、让代码更容易被他人理解、保证代码可靠性。设计模式于己于人于系统都是多赢的,它使得代码编写真正工程化,它是软件工程的基石,如同大厦的一块块...
  • 主要介绍了Java设计模式编程之工厂方法模式的使用,工厂方法模式属于设计模式中三种工厂模式中的一种,需要的朋友可以参考下

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 156,561
精华内容 62,624
关键字:

java工厂的设计模式

java 订阅