精华内容
下载资源
问答
  • import java.util.ArrayList;import java.util.List;import java.util.Random;interface Factory{T create();}class Filter extends Part{}class FuelFilter extends Filter{public static class thisFactory implem...

    import java.util.ArrayList;

    import java.util.List;

    import java.util.Random;

    interface Factory{

    T create();

    }

    class Filter extends Part{

    }

    class FuelFilter extends Filter{

    public static class thisFactory implements Factory{

    public FuelFilter create() {

    return new FuelFilter();

    }

    }

    }

    class CabinFilter extends Filter{

    public static class thisFactory implements Factory{

    public CabinFilter create() {

    return new CabinFilter();

    }

    }

    }

    class Part{

    public String toString() {

    return getClass().getSimpleName();

    }

    static List> partFactories =

    new ArrayList>();

    static {

    partFactories.add(new FuelFilter.thisFactory());

    partFactories.add(new CabinFilter.thisFactory());

    }

    public static Random random = new Random(47);

    public static Part createRandom() {

    int n = random.nextInt(partFactories.size());

    return partFactories.get(n).create();

    }

    }

    public class Test {

    public static void main(String[] args) throws Exception {

    for(int i=0;i<2;i++) {

    System.out.println(Part.createRandom());

    }

    }

    }

    展开全文
  • 注册工厂的好处就是类的创建过程由类本身完成 import java.util.ArrayList; import java.util.List; import java.util.Random; interface Factory<T>{ T create(); } class Filter extends Part{ ...

    注册工厂的好处就是类的创建过程由类本身完成

    import java.util.ArrayList;
    import java.util.List;
    import java.util.Random;
    interface Factory<T>{
    	T create();
    }
    
    class Filter extends Part{
    	
    }
    
    class FuelFilter extends Filter{
    	public static class thisFactory implements Factory<FuelFilter>{
    		public FuelFilter create() {
    			return new FuelFilter();
    		}
    	}
    }
    
    class CabinFilter extends Filter{
    	public static class thisFactory implements Factory<CabinFilter>{
    		public CabinFilter create() {
    			return new CabinFilter();
    		}
    	}
    }
    
    
    class Part{
    	public String toString() {
    		return getClass().getSimpleName();
    	}
    	static List<Factory<? extends Part>> partFactories =
    		new ArrayList<Factory<? extends Part>>();
    	static {
    		partFactories.add(new FuelFilter.thisFactory());
    		partFactories.add(new CabinFilter.thisFactory());
    	}
    	public static Random random = new Random(47);
    	public static Part createRandom() {
    		int n = random.nextInt(partFactories.size());
    		return partFactories.get(n).create();
    	}
    }
    
    public class Test {
    	public static void main(String[] args) throws Exception {
    		for(int i=0;i<2;i++) {
    			System.out.println(Part.createRandom());
    		}
    	}
    }
    

      

    转载于:https://www.cnblogs.com/--zz/p/9630040.html

    展开全文
  • Java注册工厂模式案例

    2015-01-09 01:23:13
    public Interface factory{ T create(); } package chapter14.factory;...import java.util.ArrayList; import java.util.List; import java.util.Random; class Part{ public String toString(){ retur
    
    public Interface factory<T>{
        T create();
    }
    
    package chapter14.factory;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Random;
    
    class Part{
    	public String toString(){
    		return getClass().getSimpleName();
    	}
    	static List<Factory<? extends Part>> partFactory = 
    			new ArrayList<Factory<? extends Part>>();
    	static{
    		partFactory.add(new FuelFillter.Factory());
    		partFactory.add(new OilFillter.Factory());
    		partFactory.add(new CabinFillter.Factory());
    		partFactory.add(new AxBlet.Factory());
    		partFactory.add(new BxBlet.Factory());
    	}
    	public static Random rand = new Random(47);
    	public static Part createRandom(){
    		int n = rand.nextInt(partFactory.size());
    		return partFactory.get(n).create();
    	}
    }
    class Fillter extends Part{}
    class FuelFillter extends Fillter{
    	public static class Factory 
    	implements chapter14.factory.Factory<FuelFillter>{
    		public FuelFillter create(){ return new FuelFillter();}
    	}
    }
    class AirFillter extends Fillter{
    	public static class Factory 
    	implements chapter14.factory.Factory<AirFillter>{
    		public AirFillter create(){ return new AirFillter();}
    	}
    }
    class CabinFillter extends Fillter{
    	public static class Factory 
    	implements chapter14.factory.Factory<CabinFillter>{
    		public CabinFillter create(){ return new CabinFillter();}
    	}
    }
    class OilFillter extends Fillter{
    	public static class Factory implements chapter14.factory.Factory<OilFillter>{
    		@Override
    		public OilFillter create() {
    			// TODO Auto-generated method stub
    			return new OilFillter();
    		}
    	}
    }
    class Blet extends Part{}
    class AxBlet extends Part{
    	public static class Factory 
    	implements chapter14.factory.Factory<AxBlet>{
    		@Override
    		public AxBlet create() {
    			return new AxBlet();
    		}
    		
    	}
    }
    class BxBlet extends Part{
    	public static class Factory 
    	implements chapter14.factory.Factory<BxBlet>{
    		@Override
    		public BxBlet create() {
    			return new BxBlet();
    		}
    		
    	}
    }
    
    public class RegisteredFactory {
    	public static void main(String[] args){
    		for(int i=0;i<10;i++){
    			System.out.println(Part.createRandom());
    		}
    	}
    }
    
     
    

    展开全文
  • Thingking in Java 注册工厂

    千次阅读 2013-06-06 17:19:08
    生成Pete继承结构中的对象存在着一个问题,即每次向该继承结构添加新的Pet类型时,必须将其添加为LiteralPetCreator.java中的项。如果在系统中已经存在了继承结构的常规的基础,然后在其上要添加更多的类,那么就有...

    生成Pete继承结构中的对象存在着一个问题,即每次向该继承结构添加新的Pet类型时,必须将其添加为LiteralPetCreator.java中的项。如果在系统中已经存在了继承结构的常规的基础,然后在其上要添加更多的类,那么就有可能会出现问题。

     

       您可能会考虑在每个子类中添加静态初始化器,以使得该初始化器可以将它的类添加到某个List中。

     

       遗憾的是,静态初始化器只有在类首先被加载的情况下才能被调用,因此您就碰上了“先有鸡还是先有蛋”的问题:生成器在其列表中不包含这个类,因此它永远不能创建这个类的对象,而这个类也就不能被加载并置于这个列表中。

     

       这主要是因为,您被强制要求自己去手工创建这个列表(除非您想编写一个工具,它可以全面搜索和分析源代码,然后创建和编译这个列表)。

     

       因此,您最佳的做法是,将这个列表置于一个位于中心的、位置明显的地方,而我们感兴趣的继承结构的基类可能就是这个最佳位置。

     

       这里我们需要做的其他修改就是使用工厂方法设计模式,将对象的创建工作交给类自己去完成。工厂方法可以被多态地调用,从而为您创建恰当类型的对象。

     

       在下面这个非常简单的版本中,工厂方法就是Factory接口中的create()方法:

     

       //: typeinfo/factory/Factory.java
       package typeinfo.factory;
       public interface Factory<T> { T create(); } ///:~

     

       泛型参数T使得create*()可以在每种Factory实现中返回不同的类型。这也充分利用了协变返回类型。

     

       在下面的示例中,基类Part包含一个工厂对象的列表。对于应这个由createRandom()方法产生的类型,它们的工厂都被添加到了partFactories List中,从而被注册到了基类中:

     

       //: typeinfo/RegisteredFactories.java
       // Registering Class Factories in the base class.

       import typeinfo.factory.*;
       import java.util.*;

       class Part {
         public String toString() {
           return getClass().getSimpleName();
         }
         static List<Factory<? extends Part>> partFactories =
           new ArrayList<Factory<? extends Part>>(); 
         static {
           // Collections.addAll() gives an "unchecked generic
           // array creation ... for varargs parameter" warning.

           partFactories.add(new FuelFilter.Factory());
           partFactories.add(new AirFilter.Factory());
           partFactories.add(new CabinAirFilter.Factory());
           partFactories.add(new OilFilter.Factory());
           partFactories.add(new FanBelt.Factory());
           partFactories.add(new PowerSteeringBelt.Factory());
           partFactories.add(new GeneratorBelt.Factory());
         }
         private static Random rand = new Random(47);
         public static Part createRandom() {
           int n = rand.nextInt(partFactories.size());
           return partFactories.get(n).create();
         }
       } 

       class Filter extends Part {}

       class FuelFilter extends Filter {
         // Create a Class Factory for each specific type:
         public static class Factory
         implements typeinfo.factory.Factory<FuelFilter> {
           public FuelFilter create() { return new FuelFilter(); }
         }
       }

       class AirFilter extends Filter {
         public static class Factory
         implements typeinfo.factory.Factory<AirFilter> {
           public AirFilter create() { return new AirFilter(); }
         }
       } 

       class CabinAirFilter extends Filter {
         public static class Factory
         implements typeinfo.factory.Factory<CabinAirFilter> {
           public CabinAirFilter create() {
             return new CabinAirFilter();
           }
         }
       }

       class OilFilter extends Filter {
         public static class Factory
         implements typeinfo.factory.Factory<OilFilter> {
           public OilFilter create() { return new OilFilter(); }
         }
       } 

       class Belt extends Part {}

       class FanBelt extends Belt {
         public static class Factory
         implements typeinfo.factory.Factory<FanBelt> {
           public FanBelt create() { return new FanBelt(); }
         }
       }

       class GeneratorBelt extends Belt {
         public static class Factory
         implements typeinfo.factory.Factory<GeneratorBelt> {
           public GeneratorBelt create() {
             return new GeneratorBelt();
           }
         }
       } 

       class PowerSteeringBelt extends Belt {
         public static class Factory
         implements typeinfo.factory.Factory<PowerSteeringBelt> {
           public PowerSteeringBelt create() {
             return new PowerSteeringBelt();
           }
         }
       } 

       public class RegisteredFactories {
         public static void main(String[] args) {
           for(int i = 0; i < 10; i++)
             System.out.println(Part.createRandom());
         }
       }

        /* 输出:
       GeneratorBelt
       CabinAirFilter
       GeneratorBelt
       AirFilter
       PowerSteeringBelt
       CabinAirFilter
       FuelFilter
       PowerSteeringBelt
       PowerSteeringBelt
       FuelFilter
       *///:~

     

       并非所有在继承结构中的类都应该被实例化,在本例中,Filter和Belt只是分类标识,因此您不应该创建它们的实例,而只应该创建它们的子类的实例。

     

       如果某个类应该由createRandom()方法创建,那么它就包含一个内部Factory类。如上所示,重用名字Factory的唯一方式就是限定typeinfo.factory.Factory。

     

       尽管您可以使用Collections.addAll()来向列表中添加工厂,但是这样做编译器就会表达它的不满,抛出一条有关“创建泛型数组”的警告,因此我们转而使用add()。createRandom()方法从partFactories中随机地选取一个工厂对象,然后调用其Create()方法,从而产生一个新的Part。

    展开全文
  • 工厂模式代码其实很简单,道理也很简单,其实它的宗旨就是为了减少代码的的重复,以及后期业务逻辑变化,只需要改变很少的代码量如果创建对象的过程都很复杂,需要一定的代码量,而且很多地方都要用到,那么就会有很多的...
  • package ...import java.util.ArrayList;import java.util.Random;/** factory interface* */interface Factory {public T create();}public class RegisterFactory {public static void main(String[...
  • 我只是在学习java,我遇到了一些问题.这里我们有简单的工厂模式:public class SomeFactory {...public static void registerProduct(String name, Class extends IProduct > f)}public SomeProduct implements ...
  • //工厂方法可以被多态地调用,从而为你创建恰当类型的对象。 public interface Factory<T> { //泛型参数T使得create(可以在每种Factory实现中返回不同的类型。 T create(); } import java.util.ArrayList; ...
  • Java设计模式:注册工厂

    千次阅读 2018-06-02 19:34:40
    注册工厂:静态初始化器只有在类首次被加载的时候才能被调用,因此碰上了先有鸡还是先有蛋的问题:生成器在其列表中不包含这个类,因此不能创建这个类的对象,而这个类也就不能被加载并置于这个列表中。 使用工厂...
  • java实现的注册工厂模式

    千次阅读 2012-02-07 22:08:24
    package com.eric.reflect; import java.util.ArrayList; import java.util.Random; /* * factory interface * */ interface Factory { public T create(); } public class RegisterFactory { public static
  • 注册工厂是一种很常用的框架书写方法,它适合于快速创建相同类型的对象。举个栗子比如一个家具工厂,有沙发、椅子、茶几等等,正常的编程模式是这样的://创建class 沙发{}class 椅子{}class 茶几{}//使用new 沙发()...
  • Java程序员的日常 —— 注册工厂的妙用 注册工厂是一种很常用的框架书写方法,它适合于快速创建相同类型的对象。 举个栗子 比如一个家具工厂,有沙发、椅子、茶几等等,正常的编程模式是这样的...
  • Factory.java package com.test.class_obj; public interface Factory { T create(); } RegisteredFactories.java package com.test.class_obj; import java.util.ArrayList; import java.util.List; impo
  • 一、定义抽象工厂模式是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂工厂。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。在抽象工厂模式中,接口是负责创建一个相关对象的工厂...
  • 向方法形参注入数据注解描述修饰位置将方法的返回对象注册到Spring容器方法@Bean(name="xx")将方法的返回对象注册到Spring容器, 并赋予注册名方法2. @Bean基本使用方法返回值对象 注入 成员变量2.1 按类型注入Dao类:...
  • 工厂模式(Factory Pattern)是 Java 中最常用的设计模式之一。它的主要作用就是用来生产对象,使得创建对象的时候不再需要通过new关键字来实现,降低了代码之间的耦合性。下面就以一些简单的代码来浅析工厂模式,...
  • 注册工厂模式

    2019-09-29 14:20:29
    一个继承结构,我们需要获取所有的子类 转载于:https://www.cnblogs.com/Booker808-java/p/8415560.html
  • java Swing 界面 写的购书商城系统,实现了商品的增删改减,会员的添加,注册,登录,购买,删除订单,还利用了反射实现抽象工厂配置文件调用数据库。练手写的,比较急,很多没注释,重复代码块,将就一下,实现了...
  • 承上:实战java设计模式(二)简单工厂模式 目录1 介绍2 例子2.1 手机接口2.2 手机类实现2.3 工厂父类2.4 工厂实现2.5 测试主类3 例子升华4 总结4.1 核心角色4.2 核心代码结构 1 介绍 回顾简单工厂模式,存在的问题...
  • 我注意到jaxb编译器xjc生成的ObjectFactory类.我读了一些关于它的目的.我想知道什么是创建jaxb对象的正确方法,因为我的目的...编辑:添加示例:我需要创建IpAddress的实例这是工厂方法:public IpAddress createIpA...
  • 大概介绍了JavaRMI框架的基础实现,服务器端Server类一开始就预先向RMI表中注册了一定数量的远程服务,被动地等待客户端Client类通过远程访问获得服务器端对应的远程对象的存根。请详看文章“Java RMI 框架(远程...
  • MyBatis是一个优秀的持久层框架,它对jdbc的操作数据库的过程进行封装,使开发者只需要关注 SQL 本身,而不需要花费精力去处理例如注册驱动、创建connection、创建statement、手动设置参数、结果集检索等jdbc繁杂的...
  • 在上面的一段代码中一共用了三种模式,除了工厂模式外,还有Singleton单态模式,以及proxy模式,proxy模式主要用来授权用户对forum的访问,因为访问forum有两种人:一个是注册用户 一个是游客guest,那么那么相应的权限就不...

空空如也

空空如也

1 2 3 4 5 ... 17
收藏数 337
精华内容 134
热门标签
关键字:

java注册工厂

java 订阅