精华内容
下载资源
问答
  • MultitionPattern代理模式细说多例模式多例类场景场景一:场景二:上代码代码代码二 细说多例模式 提示: 博主:章飞 _906285288的博客 博客地址:http://blog.csdn.net/qq_29924041 ## 细说多例模式 结合单例...

    细说多例模式

    提示:
    博主:章飞 _906285288的博客
    博客地址:http://blog.csdn.net/qq_29924041


    ## 细说多例模式

    结合单例模式来说多例模式,单例模式相对来说比较容易理解一点,也就是在整个应用程序运行过程中,这个类的实例永远都是一个,好比如历朝历代,皇帝在大多数情况下都是只有一个,但是往往在程序运行过程中,我可能为了达到复用的效果,需要在一个池子中去选择对应的实例进行使用,这个时候多例模式也就应运而生了。

    所谓多例模式其实也就是类的对象实例是有多个,但是这个多个也要区别于无限个,当然,如果一个类的对象可以有无限个的话,那能不能叫多例呢??这个可能就需要区别多例模式的特点了

    所谓多例(Multiton Pattern)实际上就是单例模式的自然推广,属于对象
    创建类型的模式,多例模式其实就是限制了对象的数量,并且有可能对对象进行重复使用

    特点:
    1:多例可以有多个实例
    2: 多例类必须能够自我创建并管理自己的实例,并且向外界提供自己的实例

    多例类场景

    场景一:

    引用设计模式之禅中的案例,一般情况下,一个王朝的皇帝其实都是只有一个,但是在历史上,大明王朝在土木堡之变中被瓦刺俘虏的皇帝,皇帝突然有两个,一个执政,另外一个则被俘虏了。当俘虏皇帝获救之后,这个时候王朝有两个皇帝。这两个皇帝其实也就对应了两个对象实例,多例模式下的现实场景。

    场景二:

    在java学习过程中,有一个池子的概念一直存在,好比作线程池,数据库连接池,这个池子是用来对线程,或者数据库连接对象进行管理的,第一,限制了池子中的对象数量,第二就是能够在使用过程中达到复用的效果,线程中的线程在执行完毕后,不会被直接回收掉,而会切换成等待状态,等待下一个任务提交,执行。数据库连接池也是如此,数据库操作在连接的时候,如果对数据库操作完毕后,会把资源释放,然后等待下一个数据库操作进行连接。这种设计其实是将对象的应用最大化了,避免了每次连接的时候都需要去创建一个对象。造成对象冗余或者内存升高。

    上代码

    代码一

    package src.com.zzf.designpattern.multitionpattern.demo1;
    
    
    import java.util.ArrayList;
    import java.util.Random;
    
    public class Emperor {
    	private static final int maxNumberOfEmperor = 2;
    	private static ArrayList emperorInfoList = new ArrayList(maxNumberOfEmperor);
    	private static ArrayList emperorList = new ArrayList(maxNumberOfEmperor);
    	
    	private static int countNumofEmperor = 0;
    	
    	static{
    		for(int i = 0; i < maxNumberOfEmperor ; i++){
    			emperorList.add(new Emperor("第"+i+"皇帝"));
    		}
    	}
    	
    	
    	private Emperor(){
    		
    	}
    	
    	private Emperor(String info){
    		emperorInfoList.add(info);
    	}
    	
    	public static Emperor getInstance(int num){
    		countNumofEmperor = num;
    		if (num == 0) {
    			return (Emperor) emperorList.get(0);
    		}else if(num == 1){
    			return (Emperor) emperorList.get(1);
    		}else{
    			System.out.println("error");
    			return null;
    		}
    	}
    	
    	  public static Emperor getInstance(){  
    	        Random random=new Random();  
    	        countNumofEmperor=random.nextInt(maxNumberOfEmperor);  
    	        return (Emperor)emperorList.get(countNumofEmperor);  
    	  }  
    	
    	@Override
    	public String toString() {
    		// TODO Auto-generated method stub
    		return (String) emperorInfoList.get(countNumofEmperor);
    	}
    }
    
    
    package src.com.zzf.designpattern.multitionpattern.demo1;
    
    
    /**
     *多例模式
     *所谓多例(Multiton Pattern)实际上就是单例模式的自然推广,属于对象
     *创建类型的模式,多例模式其实就是限制了对象的数量,并且有可能对对象进行重复使用
     *
     *特点:
     *1:多例可以有多个实例
     *2:多例类必须能够自我创建并管理自己的实例,并且向外界提供自己的实例
     * @author Administrator
     *
     */
    public class MultiPatternTest {
    	public static void main(String[] args) {
    		Emperor mEmperor = Emperor.getInstance(0);
    		System.out.println(mEmperor.toString());
    		mEmperor = Emperor.getInstance(1);
    		System.out.println(mEmperor.toString());
    		mEmperor = Emperor.getInstance(2);
    	}
    }
    

    代码二

    package src.com.zzf.designpattern.multitionpattern.demo2;
    
    import java.util.ArrayList;
    import java.util.Random;
    
    public class SQLConnectionPools {
    	private static int maxNumOfConnection= 8;
    	private static ArrayList<String> connectionInfoList = new ArrayList<>(maxNumOfConnection);
    	private static ArrayList<SQLConnectionPools> connArrayList = new ArrayList<>(maxNumOfConnection);
    	private static int currNumOfConnection =0;
    	
    	private SQLConnectionPools() {
    		// TODO Auto-generated constructor stub
    	}
    	
    	private SQLConnectionPools(String info) {
    		connectionInfoList.add(info);
    	}
    	
    	static{
    		for (int i = 0; i < maxNumOfConnection; i++) {
    			connArrayList.add(new SQLConnectionPools(i+"号连接"));
    		}
    	}
    	
    	public static SQLConnectionPools getInstance() {
    		Random random = new Random();
    		currNumOfConnection = random.nextInt(maxNumOfConnection);
    		return connArrayList.get(currNumOfConnection);
    	}
    	
    	public void connectionInfo() {
    		System.out.println(connectionInfoList.get(currNumOfConnection));
    	}
    	
    }
    
    
    package src.com.zzf.designpattern.multitionpattern.demo2;
    
    public class Client {
    
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		 int userNum=10;  
    	        for(int i=0;i<userNum;i++){  
    	            //用户获取到的连接时随机的  
    	            SQLConnectionPools conn= SQLConnectionPools.getInstance();  
    	            System.out.print("第"+i+"个用户获得的连接是:");  
    	            conn.connectionInfo();  
    	        }  
    	}
    
    }
    
    

    多例模式相对来说也是比较简单,现实生活场景中也有很多场景案例。所以也不过多的赘述,案例也简单的一批。如果我想打造一个属于自己的资源池,达到对象复用的效果,结合状态模式等,可以打造出属于自己的复用池。




    欢迎继续访问,我的博客

    展开全文
  • 多例模式

    万次阅读 多人点赞 2014-08-06 15:32:38
    转载请注明出处!!!... 所有配套代码均在github上:https://github.com/ZHONGHuanGit/DesignPattern   跟着ZHONGHuan学习设计... 所谓的多例模式,实际上就是单例模式(回顾看这里)的自然推广,作为对象的创建模式,

    转载请注明出处!!!http://blog.csdn.net/zhonghuan1992

             所有配套代码均在github上:https://github.com/ZHONGHuanGit/DesignPattern

     

    跟着ZHONGHuan学习设计模式

    多例模式

    介绍:

             所谓的多例模式,实际上就是单例模式(回顾看这里)的自然推广,作为对象的创建模式,多例模式有以下特点:

             1可以有多个实例

             2多例类必须自己创建,管理自己的实例,并向外界提供自己的实例。

     

             从上面的特点中,可以体会多例模式与单例模式的不同。单例模式只允许一个实例的存在。

    单例类图:

    多例类图:

             类图更直观的表示了多例类,该多例类会提供多个实例,实例的数量我们是可以自己控制的,如果数量不多的话,实例就可以当做是类的内部实例变量;如果实例很多,那么可以用数组,或者可变长度的数组来进行存储。下面看有上限的多例类。

     

    有上限多例类:

             有上限的多例类,名字很清楚的说明白了,该类实例数量是有上限的,通常这个上限是由程序员控制的。我们用筛子来举例。

             不知道大家打不打麻将,我想麻将是中国广大群众的一种休闲方式。也许各地的打法会有些许的不同。但一般打麻将都需要置筛子。有时筛子是1个,有时是两个,也有可能是3个。这里假定2个筛子。因为筛子的数量确定是2,所以这是一个上限为2的多例类。

     

    示例程序的类图:

    示例程序代码:

    import java.util.Random;
    
    class Die{
    	private static Die die1=new Die();//筛子1
    	private static Die die2=new Die();//筛子2
    	private Die(){
    		//私有的构造子保证外界无法将此类实例化
    	}
    	//获取筛子方法,类似简单工厂模式,通过tag决定返回哪个筛子
    	public static Die getDie(int tag){
    		if(tag==1)
    			return die1;
    		if(tag==2)
    			return die2;
    		return null;
    	}
    	//掷筛子,返回一个1~6的随机数字。
    	public synchronized int dice(){
    		Random random=new Random();
    		return random.nextInt(6)+1;
    	}
    }
    
    public class Main{
    	private static Die die1,die2;
    	public static void main(String[] args){
    		 die1 = Die.getDie(1);
    		 die2 = Die.getDie(2);
    		 System.out.println("筛子1的值是"+ die1.dice());
    		 System.out.println("筛子2的值是"+ die2.dice());
    	}
    }
    




     

    无上限的多例类:

             顾名思义,就是多例类的实例数量没有上限,笔者暂时没有好的例子,如果你有,请告诉我。

     

     

     

     

     

    展开全文
  • 多例模式之有上限例类

    千次阅读 2015-03-25 08:36:54
    一个实例数目有上限的例类已经把实例的上限当做逻辑的一部分,并建造了例类的内部,这种模式叫做有有上限的多例模式。 比如在每一麻将牌局都需要两个骰子,因此骰子就应当是双态类,这里就以这个系统为例,说明...

    一个实例数目有上限的多例类已经把实例的上限当做逻辑的一部分,并建造了多例类的内部,这种模式叫做有有上限的多例模式。

    比如在每一麻将牌局都需要两个骰子,因此骰子就应当是双态类,这里就以这个系统为例,说明多例模式的结构,骰子的类图如

    图一所示:

    多例类Die(骰子)的源代码如下所示:

    package Multiton;
    
    import java.util.Date;
    import java.util.Random;
    
    public class Die {
    	private static Die die1=new Die();
    	private static Die die2=new Die();
    	
    	/**
    	 * 私有的构造子保证外界无法直接将此类实例化
    	 */
    	private Die(){}
    	
    	/**
    	 * 工厂方法
    	 * @param whichOne
    	 * @return
    	 */
    	public static Die getInstance(int whichOne){
    		if(whichOne==1){
    			return die1;
    		}else{
    			return die2;
    		}
    	}
    	
    	/**
    	 * 掷骰子,返还一个在1~6之间的随机数
    	 * @return
    	 */
    	public synchronized int dice(){
    		Date d=new Date();
    		Random r=new Random(d.getTime());
    		int value=r.nextInt();
    		value=Math.abs(value);
    		value=value%6;
    		value+=1;
    		return value;
    	}
    	
    }
    
    在多例类Die中,使用了饿汉模式创建了两个Die的实例,根据静态工厂方法的参数,工厂方法返还两个实例中的一个,Die()对象的dice()方法

    代表掷骰子,这个方法会返还1~6之间的随机数,相当与骰子的点数,如代码清单如下所示:

    package Multiton;
    
    public class Client {
    	private static Die die1,die2;
    	public static void main(String[] args) {
    		die1=Die.getInstance(1);
    		die2=Die.getInstance(2);
    		die1.dice();
    		die2.dice();
    	}
    }
    
    由于有上限的多例类对实例的数目有上限,因此有上限的多例类在这个上限等于1 时,多例类就回到了单例类,因此,多例类是单例类的推广,

    而单例类是多例类的特殊情况。

    一个有上限的多例类可以使用静态变量存储所有的实例,特别是在实例数目不多的时候,可以使用一个个静态变量存储一个个的实例,在数目

    较多的时候,就需要使用静态聚集来存储这些实例。

    如上,就是多例模式之有上限多例类。

    展开全文
  • 创建型模式--多例模式

    千次阅读 2014-12-28 02:22:03
    多例模式通常被划分为:有上限多例模式、无上限多例模式。 平时我们通过new一个对象的就是无上限多例模式。 什么叫有上限多例模式,其实就是单例模式的推广,创建>1个的实例(有限)。 代码描述: public class ...

    多例模式通常被划分为:有上限多例模式、无上限多例模式。

    平时我们通过new一个对象的就是无上限多例模式。

    什么叫有上限多例模式,其实就是单例模式的推广,创建>1个的实例(有限)。


    代码描述:

    <span style="font-size:18px;">public class Case {
    	//保存有限个类的实例
    	private static ArrayList<Case> caseList=new ArrayList<Case>();
    	//创建实例的个数
    	private static final int MAX_NUM=2;
    	/*
    	 * 在类初试化阶段执行静态初始化快
    	 */
    	static{
    		for(int i=0;i<MAX_NUM;i++){
    			caseList.add(new Case());
    		}
    	}
    	//私有方法
    	private Case(){	
    	}
    	//定义static,类所有
    	public static Case getCase(){
    		Random random=new Random();
    		int count=random.nextInt(MAX_NUM);
    		return caseList.get(count);
    	}
    }</span>

    在上面代码中,通过静态初始化块创建了有限个类的实例,通过geCase()方法随机获取实例。


    如果我们不想通过随机获取实例,而是指定第几个实例的话,可以参看下面的代码


    <span style="font-size:18px;">public class Case {
    	//保存有限个类的实例
    	private static ArrayList<Case> caseList=new ArrayList<Case>();
    	//创建实例的个数
    	private static final int MAX_NUM=2;
    	/*
    	 * 在类初试化阶段执行静态初始化快
    	 */
    	static{
    		for(int i=0;i<MAX_NUM;i++){
    			caseList.add(new Case());
    		}
    	}
    	//私有方法
    	private Case(){	
    	}
    	//定义static,类所有
    	public static Case getCase(final int index){
    		if(index<MAX_NUM&&index>=0){
    			return caseList.get(index);
    		}
    		return null;
    	}
    }</span>


    转载请注明出处:http://blog.csdn.net/hai_qing_xu_kong/article/details/42207289    情绪控_


    展开全文
  • JAVA设计模式-创建模式-多例模式

    千次阅读 2020-07-05 09:06:21
    什么是多例模式?为什么要有多例模式模模式的实现方式鸣谢 为什么要有设计模式? 一个有价值的系统总是会因为需求的变化而变化,可能是原有需求的修改,也可能是新需求的增加。于是可怜的猿们就得修改原来的代码...
  • Java多例模式

    千次阅读 2015-03-26 11:34:50
    多例模式又划分为有上限多例模式和无上限多例模式两种,没上限的多例模式和直接 new 一个对象没什么差别,此处不做记录。 有上限多例模式:实际上是单例模式的推广,如果它的上限是1,那么就成了单例模式了. 多例模式特点...
  • 23种设计模式-多例模式《柒个我》

    万次阅读 2018-08-20 11:59:47
    对于许久不用的东西,容易忘记。百度许久,也未能找到自己所要。 从今日起,有些东西就记载下来,不仅方便自己,希望能帮到他人吧 ...首先明确一点,多例模式是有数量限制的,否则跟直接new没有区别,那就失去了...
  • java常用设计模式之多例模式

    千次阅读 2018-06-18 22:45:34
    多例模式: 说明: 多例模式可以看做事单例模式的一个推广,区别在于,单例模式有且只有一个对象,产生,而多例模式则会产生个我们所需要的对象。使用方法: 1.私有化构造方法,使其在外部无法被调用,构造相应...
  • springboot多例模式的实现

    千次阅读 2019-07-09 14:13:20
    在bean类中加注解@Scope(“proptype”) 发现仍然是单例模式代码如下: service /** * @author Kern * @Title: ExcelTemplateServiceImpl * @ProjectName swms-java * @Description: TODO * @date 2019-7-815:...
  • 1,创建一个对象需要消耗的资源较,例如,访问IO,访问数据库等资源 2,一个应用中需要共享一个对象数据 3,需要生成唯一序列号; 如何编写一个单例模式呢,步骤如下: 1,将该类的构造器私有化,添加private...
  • Java单例模式、多例模式

    千次阅读 2016-03-13 23:06:38
    //单例设计模式有两种形式:饿汉式/懒汉式 class Singleton{ // private volatile static Singleton singleton = null; //懒汉式 private static final Singleton singleton = new Singleton(); //饿汉式 private ...
  • 单例模式多例类【设计模式

    千次阅读 2017-02-28 16:02:29
    多例类:请使用单例模式编写一个程序,然后考虑一下如何对这个程序进行改造,使得系统中某个类的对象可以存在有限个,例如两或三? 法一:最多有max_num种实例,如果调用次数超过,则默认为第max_num种 ...
  • 多例模式应用场景举例

    千次阅读 2014-01-23 22:25:43
    多例模式应用场景举例  并发请求环境下,系统需要为每个客户端的独立请求提供单独服务的资源,但是系统总的开销是有限的,系统在并发量很大时也不可能为所有的并发请求同时提供相应的资源,否则不但系统...
  • 在Spring中,bean可以被定义为两种模式:prototype(多例)和singleton(单例) singleton(单例):只有一个共享的实例存在,所有对这个bean的请求都会返回这个唯一的实例。 prototype(多例):对这个bean的每次...
  • Spring的单例模式和多例模式

    万次阅读 多人点赞 2018-06-03 21:14:17
    在Spring中,bean可以被定义为两种模式:prototype(多例)和singleton(单例) singleton(单例):只有一个共享的实例存在,所有对这个bean的请求都会返回这个唯一的实例。 单例模式分为饿汉模式和懒汉模式: 饿汉...
  • servlet可以采用多例模式,也可以采用单利模式,百度文库有详细解释。 至于线程问题我没大明白你的意思。但在MVC模式下,一个servlet只能处理一个页面的请求,也就不存在线程的情况,仅仅是一个页面对应一个...
  • 单例模式,多例模式及其应用

    千次阅读 2009-02-04 15:40:00
    单例模式: 当整个应用只允许出现一个类实例时,我们经常用到单例模式。比如工具类,国际化服务提供类等等 单例模式分为两种,一种饿汉式:在类加载的时候即完成对象创建,保证始终只有一个对象存在 Class ...
  • Spring配置中默认的是单例模式 singleton 单例模式 单例模式,在spring 中其实是scope(作用范围)参数的缺省设定值, 每个bean定义只生成一个对象实例,每次getBean请求获得的都是此实例。 单例模式分为饿汉模式和...
  • 线程安全的单例模式-以C++代码

    千次阅读 2016-04-15 11:16:34
    本文描述3种场景下的单例模式: 进程体内无线程的单例模式 进程体内线程单例模式 在单个线程体中的单例模式
  • 多例模式是相对单例模式而言的。单例模式有且仅有一个实例,但是多例模式,顾问思义:允许存在有限个实例。 什么叫“有限个实例”? 就是说:有多少实例,我们是知道的,并不是不可以预知的, 如果一个类的构造函数...
  • JAVA设计模式之单例模式

    万次阅读 多人点赞 2014-04-16 06:51:34
     java中单例模式是一种常见的设计模式,单例模式的写法有好几种,这里主要介绍三种:懒汉式单例、饿汉式单例、登记式单例。  单例模式有以下特点:  1、单例类只能有一个实例。  2、单例类必须自己创建自己的...
  • 【设计模式】Java中单例模式Singleton

    万次阅读 多人点赞 2020-12-21 17:02:03
    单例模式,顾名思义就是只有一个实例,并且它自己负责创建自己的对象,这个类提供了一种访问其唯一的对象的方式,可以直接访问,不需要实例化该类的对象。 核心代码:构造方法私有化,private。提供一个静态的公开...
  •  此文于php实现单例模式又略有些拓展,将使用单例模式的设计手法实现一个多例模式。应用场景如下:  因我公司的用户注册后每一个用户拥有一个独享的私人库,于是我们在代码实现的过程中会出来一个进程连接个数
  • 如何保证单例模式线程中的线程安全性  对大数据、分布式、高并发学习必须要有线程的基础。这里讨论一下如何在线程的情况下设计单例模式。在23中设计模式中单例模式是比较常见的,在非线程的情况下写单例...
  • 目前关于设计模式的书很,其中比较好的有GOF那本的中译本,但并不很适合初学者。还有一本是《JAVA与模式》,比较适合初学者使用,在此强烈推荐。但这本书的不足之处是一些地方讲的过于繁琐,很地方只须简单说明...
  • 最近模式识别的课程设计需要我们对BP神经网络进行仿真,经过一个星期的学习,综合网上各类算法,进行优化后得到现在这个仿真代码。 本仿真代码可以自动将数据集分为训练集和数据集,代码中的注释我也尽可能详尽的...
  • java 设计模式之:多例(Multiton)模式

    千次阅读 2006-04-02 16:40:00
    例(Multiton)模式 作为对象的创建模式,多例模式中的例类可以有个实例,而且例类必须自己创建,管理自己的实例,并向外界提供自己的实例。 案例:国际化解决方案实际方案是分层方案,即MVC模式。MVC模式将...
  • 1,在 Project>Options for Target[你的项目名称] 里设置晶振频率为实际单片机晶振频率 下图中红圈内即为晶振频率单位为MHZ 2,选择菜单 Debug>Start/Stop Debug Session 开始调试程序 3,在想测算运行时间的程序...
  • C#程序设计经典300代码

    热门讨论 2015-01-10 18:55:46
    第8章 常用设计模式 第2篇 窗体篇 第10章 窗体的使用 第11章 控件的使用 第12章 组件的使用 第9章 鼠标与键盘 第3篇 应用篇 第13章 线程编程 第14章 文件系统 第15章 注册表技术 第16章 数据库技术 第17...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 474,062
精华内容 189,624
关键字:

多例模式代码