研磨设计模式之单例模式-1(转)

最新推荐文章于 2024-08-13 16:16:10 发布
最新推荐文章于 2024-08-13 16:16:10 发布
阅读量78 收藏
点赞数
分类专栏： 设计模式 文章标签： 设计模式 数据结构 Blog
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/seaizon/article/details/83700233
版权

单例模式（Singleton）

 

1  场景问题

1.1  读取配置文件的内容

        考虑这样一个应用，读取配置文件的内容。
        很多应用项目，都有与应用相关的配置文件，这些配置文件多是由项目开发人员自定义的，在里面定义一些应用需要的参数数据。当然在实际的项目中，这种配置文 件多采用xml格式的。也有采用properties格式的，毕竟使用Java来读取properties格式的配置文件比较简单。
        现在要读取配置文件的内容，该如何实现呢？


1.2  不用模式的解决方案

        有些朋友会想，要读取配置文件的内容，这也不是个什么困难的事情，直接读取文件的内容，然后把文件内容存放在相应的数据对象里面就可以了。真的这么简单吗？先实现看看吧。
        为了示例简单，假设系统是采用的properties格式的配置文件。
（1）那么直接使用Java来读取配置文件，示例代码如下：

Java代码
  1. /**  
  2.  * 读取应用配置文件  
  3.  */   
  4. public   class  AppConfig {  
  5.     /**  
  6.      * 用来存放配置文件中参数A的值  
  7.      */   
  8.     private  String parameterA;  
  9.     /**  
  10.      * 用来存放配置文件中参数B的值  
  11.      */   
  12.     private  String parameterB;    
  13.   
  14.     public  String getParameterA() {  
  15.         return  parameterA;  
  16.     }  
  17.     public  String getParameterB() {  
  18.         return  parameterB;  
  19.     }  
  20.     /**  
  21.      * 构造方法  
  22.      */   
  23.     public  AppConfig(){  
  24.         //调用读取配置文件的方法   
  25.         readConfig();  
  26.     }  
  27.     /**  
  28.      * 读取配置文件，把配置文件中的内容读出来设置到属性上  
  29.      */   
  30.     private   void  readConfig(){  
  31.         Properties p = new  Properties();   
  32.         InputStream in = null ;  
  33.         try  {  
  34.             in = AppConfig.class .getResourceAsStream(  
  35. "AppConfig.properties" );  
  36.             p.load(in);  
  37.             //把配置文件中的内容读出来设置到属性上   
  38.             this .parameterA = p.getProperty( "paramA" );  
  39.             this .parameterB = p.getProperty( "paramB" );  
  40.         } catch  (IOException e) {  
  41.             System.out.println("装载配置文件出错了，具体堆栈信息如下：" );  
  42.             e.printStackTrace();  
  43.         }finally {  
  44.             try  {  
  45.                 in.close();  
  46.             } catch  (IOException e) {  
  47.                 e.printStackTrace();  
  48.             }  
  49.         }  
  50.     }  
  51. }   
/**
 * 读取应用配置文件
 */
public class AppConfig {
	/**
	 * 用来存放配置文件中参数A的值
	 */
	private String parameterA;
	/**
	 * 用来存放配置文件中参数B的值
	 */
	private String parameterB;	

	public String getParameterA() {
		return parameterA;
	}
	public String getParameterB() {
		return parameterB;
	}
	/**
	 * 构造方法
	 */
	public AppConfig(){
		//调用读取配置文件的方法
		readConfig();
	}
	/**
	 * 读取配置文件，把配置文件中的内容读出来设置到属性上
	 */
	private void readConfig(){
		Properties p = new Properties(); 
		InputStream in = null;
		try {
			in = AppConfig.class.getResourceAsStream(
"AppConfig.properties");
			p.load(in);
			//把配置文件中的内容读出来设置到属性上
			this.parameterA = p.getProperty("paramA");
			this.parameterB = p.getProperty("paramB");
		} catch (IOException e) {
			System.out.println("装载配置文件出错了，具体堆栈信息如下：");
			e.printStackTrace();
		}finally{
			try {
				in.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

 

注意：只有访问参数的方法，没有设置参数的方法。

（2）应用的配置文件，名字是AppConfig.properties，放在AppConfig相同的包里面，简单示例如下：

Java代码
  1. paramA=a  
  2. paramB=b   
paramA=a
paramB=b

 

（3）写个客户端来测试一下，示例代码如下：

Java代码
  1. public   class  Client {  
  2.     public   static   void  main(String[] args) {  
  3.         //创建读取应用配置的对象   
  4.         AppConfig config = new  AppConfig();  
  5.           
  6.         String paramA = config.getParameterA();  
  7.         String paramB = config.getParameterB();  
  8.           
  9.         System.out.println("paramA=" +paramA+ ",paramB=" +paramB);  
  10.     }  
  11. }   
public class Client {
	public static void main(String[] args) {
		//创建读取应用配置的对象
		AppConfig config = new AppConfig();
		
		String paramA = config.getParameterA();
		String paramB = config.getParameterB();
		
		System.out.println("paramA="+paramA+",paramB="+paramB);
	}
}

 

运行结果如下：

Java代码
  1. paramA=a,paramB=b   
paramA=a,paramB=b

 

1.3  有何问题

        上面的实现很简单嘛，很容易的就实现了要求的功能。仔细想想，有没有什么问题呢？
        看看客户端使用这个类的地方，是通过new一个AppConfig的实例来得到一个操作配置文件内容的对象。如果在系统运行中，有很多地方都需要使用配置文件的内容，也就是很多地方都需要创建AppConfig这个对象的实例。
        换句话说，在系统运行期间，系统中会存在很多个AppConfig的实例对象，这有什么问题吗？
        当然有问题了，试想一下，每一个AppConfig实例对象，里面都封装着配置文件的内容，系统中有多个AppConfig实例对象，也就是说系统中会同 时存在多份配置文件的内容，这会严重浪费内存资源。如果配置文件内容较少，问题还小一点，如果配置文件内容本来就多的话，对于系统资源的浪费问题就大了。 事实上，对于AppConfig这种类，在运行期间，只需要一个实例对象就够了。
        把上面的描述进一步抽象一下，问题就出来了：在一个系统运行期间，某个类只需要一个类实例就可以了，那么应该怎么实现呢？


2  解决方案

2.1  单例模式来解决

        用来解决上述问题的一个合理的解决方案就是单例模式。那么什么是单例模式呢？
（1）单例模式定义
        保证一个类仅有一个实例，并提供一个访问它的全局访问点。
（2）应用单例模式来解决的思路
        仔细分析上面的问题，现在一个类能够被创建多个实例，问题的根源在于类的构造方法是公开的，也就是可以让类的外部来通过构造方法创建多个实例。换句话说，只要类的构造方法能让类的外部访问，就没有办法去控制外部来创建这个类的实例个数。
        要想控制一个类只被创建一个实例，那么首要的问题就是要把创建实例的权限收回来，让类自身来负责自己类实例的创建工作，然后由这个类来提供外部可以访问这个类实例的方法，这就是单例模式的实现方式。


2.2  模式结构和说明

单例模式结构见图1所：


 图1  单例模式结构图
Singleton：
         负责创建Singleton类自己的唯一实例，并提供一个getInstance的方法，让外部来访问这个类的唯一实例。

2.3  单例模式示例代码

        在Java中，单例模式的实现又分为两种，一种称为懒汉式，一种称为饿汉式，其实就是在具体创建对象实例的处理上，有不同的实现方式。下面分别来看这两种实现方式的代码示例。为何这么写，具体的在后面再讲述。
       （1）懒汉式实现，示例代码如下：

Java代码
  1. /**  
  2.  * 懒汉式单例实现的示例  
  3.  */   
  4. public   class  Singleton {  
  5.     /**  
  6.      * 定义一个变量来存储创建好的类实例  
  7.      */   
  8.     private   static  Singleton uniqueInstance =  null ;  
  9.     /**  
  10.      * 私有化构造方法，好在内部控制创建实例的数目  
  11.      */   
  12.     private  Singleton(){  
  13.         //   
  14.     }  
  15.     /**  
  16.      * 定义一个方法来为客户端提供类实例  
  17.      * @return 一个Singleton的实例  
  18.      */   
  19.     public   static   synchronized  Singleton getInstance(){  
  20.         //判断存储实例的变量是否有值   
  21.         if (uniqueInstance ==  null ){  
  22.             //如果没有，就创建一个类实例，并把值赋值给存储类实例的变量   
  23.             uniqueInstance = new  Singleton();  
  24.         }  
  25.         //如果有值，那就直接使用   
  26.         return  uniqueInstance;  
  27.     }  
  28.     /**  
  29.      * 示意方法，单例可以有自己的操作  
  30.      */   
  31.     public   void  singletonOperation(){  
  32.         //功能处理   
  33.     }  
  34.     /**  
  35.      * 示意属性，单例可以有自己的属性  
  36.      */   
  37.     private  String singletonData;  
  38.     /**  
  39.      * 示意方法，让外部通过这些方法来访问属性的值  
  40.      * @return 属性的值  
  41.      */   
  42.     public  String getSingletonData(){  
  43.         return  singletonData;  
  44.     }  
  45. }   
/**
 * 懒汉式单例实现的示例
 */
public class Singleton {
	/**
	 * 定义一个变量来存储创建好的类实例
	 */
	private static Singleton uniqueInstance = null;
	/**
	 * 私有化构造方法，好在内部控制创建实例的数目
	 */
	private Singleton(){
		//
	}
	/**
	 * 定义一个方法来为客户端提供类实例
	 * @return 一个Singleton的实例
	 */
	public static synchronized Singleton getInstance(){
		//判断存储实例的变量是否有值
		if(uniqueInstance == null){
			//如果没有，就创建一个类实例，并把值赋值给存储类实例的变量
			uniqueInstance = new Singleton();
		}
		//如果有值，那就直接使用
		return uniqueInstance;
	}
	/**
	 * 示意方法，单例可以有自己的操作
	 */
	public void singletonOperation(){
		//功能处理
	}
	/**
	 * 示意属性，单例可以有自己的属性
	 */
	private String singletonData;
	/**
	 * 示意方法，让外部通过这些方法来访问属性的值
	 * @return 属性的值
	 */
	public String getSingletonData(){
		return singletonData;
	}
}

 （2）饿汉式实现，示例代码如下：

Java代码
  1. /**  
  2.  * 饿汉式单例实现的示例  
  3.  */   
  4. public   class  Singleton {  
  5.     /**  
  6.      * 定义一个变量来存储创建好的类实例，直接在这里创建类实例，只会创建一次  
  7.      */   
  8.     private   static  Singleton uniqueInstance =  new  Singleton();  
  9.     /**  
  10.      * 私有化构造方法，好在内部控制创建实例的数目  
  11.      */   
  12.     private  Singleton(){  
  13.         //   
  14.     }  
  15.     /**  
  16.      * 定义一个方法来为客户端提供类实例  
  17.      * @return 一个Singleton的实例  
  18.      */   
  19.     public   static  Singleton getInstance(){  
  20.         //直接使用已经创建好的实例   
  21.         return  uniqueInstance;  
  22.     }  
  23.       
  24.     /**  
  25.      * 示意方法，单例可以有自己的操作  
  26.      */   
  27.     public   void  singletonOperation(){  
  28.         //功能处理   
  29.     }  
  30.     /**  
  31.      * 示意属性，单例可以有自己的属性  
  32.      */   
  33.     private  String singletonData;  
  34.     /**  
  35.      * 示意方法，让外部通过这些方法来访问属性的值  
  36.      * @return 属性的值  
  37.      */   
  38.     public  String getSingletonData(){  
  39.         return  singletonData;  
  40.     }  
  41. }   
/**
 * 饿汉式单例实现的示例
 */
public class Singleton {
	/**
	 * 定义一个变量来存储创建好的类实例，直接在这里创建类实例，只会创建一次
	 */
	private static Singleton uniqueInstance = new Singleton();
	/**
	 * 私有化构造方法，好在内部控制创建实例的数目
	 */
	private Singleton(){
		//
	}
	/**
	 * 定义一个方法来为客户端提供类实例
	 * @return 一个Singleton的实例
	 */
	public static Singleton getInstance(){
		//直接使用已经创建好的实例
		return uniqueInstance;
	}
	
	/**
	 * 示意方法，单例可以有自己的操作
	 */
	public void singletonOperation(){
		//功能处理
	}
	/**
	 * 示意属性，单例可以有自己的属性
	 */
	private String singletonData;
	/**
	 * 示意方法，让外部通过这些方法来访问属性的值
	 * @return 属性的值
	 */
	public String getSingletonData(){
		return singletonData;
	}
}

 

2.4  使用单例模式重写示例

        要使用单例模式来重写示例，由于单例模式有两种实现方式，这里选一种来实现就好了，就选择饿汉式的实现方式来重写示例吧。
        采用饿汉式的实现方式来重写实例的示例代码如下：

Java代码
  1. /**  
  2.  * 读取应用配置文件，单例实现  
  3.  */   
  4. public   class  AppConfig {  
  5.     /**  
  6.      * 定义一个变量来存储创建好的类实例，直接在这里创建类实例，只会创建一次  
  7.      */   
  8.     private   static  AppConfig instance =  new  AppConfig();  
  9.     /**  
  10.      * 定义一个方法来为客户端提供AppConfig类的实例  
  11.      * @return 一个AppConfig的实例  
  12.      */   
  13.     public   static  AppConfig getInstance(){  
  14.         return  instance;  
  15.     }  
  16.       
  17.     /**  
  18.      * 用来存放配置文件中参数A的值  
  19.      */   
  20.     private  String parameterA;  
  21.     /**  
  22.      * 用来存放配置文件中参数B的值  
  23.      */   
  24.     private  String parameterB;  
  25.     public  String getParameterA() {  
  26.         return  parameterA;  
  27.     }  
  28.     public  String getParameterB() {  
  29.         return  parameterB;  
  30.     }  
  31.     /**  
  32.      * 私有化构造方法  
  33.      */   
  34.     private  AppConfig(){  
  35.         //调用读取配置文件的方法   
  36.         readConfig();  
  37.     }  
  38.     /**  
  39.      * 读取配置文件，把配置文件中的内容读出来设置到属性上  
  40.      */   
  41.     private   void  readConfig(){  
  42.         Properties p = new  Properties();   
  43.         InputStream in = null ;  
  44.         try  {  
  45.             in = AppConfig.class .getResourceAsStream(  
  46. "AppConfig.properties" );  
  47.             p.load(in);  
  48.             //把配置文件中的内容读出来设置到属性上   
  49.             this .parameterA = p.getProperty( "paramA" );  
  50.             this .parameterB = p.getProperty( "paramB" );  
  51.         } catch  (IOException e) {  
  52.             System.out.println("装载配置文件出错了，具体堆栈信息如下：" );  
  53.             e.printStackTrace();  
  54.         }finally {  
  55.             try  {  
  56.                 in.close();  
  57.             } catch  (IOException e) {  
  58.                 e.printStackTrace();  
  59.             }  
  60.         }  
  61.     }     
  62. }   
/**
 * 读取应用配置文件，单例实现
 */
public class AppConfig {
	/**
	 * 定义一个变量来存储创建好的类实例，直接在这里创建类实例，只会创建一次
	 */
	private static AppConfig instance = new AppConfig();
	/**
	 * 定义一个方法来为客户端提供AppConfig类的实例
	 * @return 一个AppConfig的实例
	 */
	public static AppConfig getInstance(){
		return instance;
	}
	
	/**
	 * 用来存放配置文件中参数A的值
	 */
	private String parameterA;
	/**
	 * 用来存放配置文件中参数B的值
	 */
	private String parameterB;
	public String getParameterA() {
		return parameterA;
	}
	public String getParameterB() {
		return parameterB;
	}
	/**
	 * 私有化构造方法
	 */
	private AppConfig(){
		//调用读取配置文件的方法
		readConfig();
	}
	/**
	 * 读取配置文件，把配置文件中的内容读出来设置到属性上
	 */
	private void readConfig(){
		Properties p = new Properties(); 
		InputStream in = null;
		try {
			in = AppConfig.class.getResourceAsStream(
"AppConfig.properties");
			p.load(in);
			//把配置文件中的内容读出来设置到属性上
			this.parameterA = p.getProperty("paramA");
			this.parameterB = p.getProperty("paramB");
		} catch (IOException e) {
			System.out.println("装载配置文件出错了，具体堆栈信息如下：");
			e.printStackTrace();
		}finally{
			try {
				in.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}	
}

 当然，测试的客户端也需要相应的变化，示例代码如下：

Java代码
  1. public   class  Client {  
  2.     public   static   void  main(String[] args) {  
  3.         //创建读取应用配置的对象   
  4.         AppConfig config = AppConfig.getInstance();  
  5.   
  6.         String paramA = config.getParameterA();  
  7.         String paramB = config.getParameterB();  
  8.   
  9.         System.out.println("paramA=" +paramA+ ",paramB=" +paramB);  
  10.     }  
  11. }   
public class Client {
	public static void main(String[] args) {
		//创建读取应用配置的对象
		AppConfig config = AppConfig.getInstance();

		String paramA = config.getParameterA();
		String paramB = config.getParameterB();

		System.out.println("paramA="+paramA+",paramB="+paramB);
	}
}

 去测试看看，是否能满足要求。

 

 

未完待续，精彩稍后继续

转载自：http://chjavach.iteye.com/blog/721076

seaizon
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
设计模式-1-单例模式
peace_dove的博客
06-15 167
单例模式1、简单介绍2、几种实现单例的方式2.1、定义私有化成员的时候，直接初始化对象（饿汉式）2.2、在静态代码块中初始化成员对象（效果同上）2.3、在使用的时候才初始化（懒汉式）2.4、使用synchronized给getInstance方法加锁（懒汉式）2.5、getInstance中使用同步代码块（懒汉式）2.6、双重检查法：在方法5的基础上再次添加一个同步代码块进行检查2.7、静态内部类方式2.8、使用枚举3、简单总结 1、简单介绍 一般应用于只需要有一个实例存在的场景，比如各种Manager 各
设计模式之【单例模式】
Janway-Win
02-28 656
为什么要使用单例模式？单例模式存在哪些问题？有哪些应用场景？今天 ，我们一下来学习设计模式之【单例模式】。
【软件设计模式】单例模式应用
木成河的博客
06-15 321
很多应用项目都有配置文件，这些配置文件里面定义一些应用需要的参数数据。 如果客户端使用这个类是通过new一个AppConfig的实例来得到一个操作配置文件内容的对象，则在系统运行中，有很多地方都需要使用配置文件的内容，系统中会同时存在多份配置文件的内容，这会严重浪费内存资源。事实上，对于AppConfig类，在运行期间，只需要一个对象实例就够了。那么应该怎么实现呢？用Java控制台应用程序实现该单例模式。绘制该模式的UML图。AppConfig.java Client.java 运行结果：.........
研磨设计模式之单例模式-1
跟着cc学设计 私塾在线学习网 http://sishuok.com
07-26 100
  看到很多朋友在写单例，也来凑个热闹，虽然很简单，但是也有很多知识点在单例里面，看看是否能写出点不一样来。      单例模式（Singleton）   1  场景问题 1.1  读取配置文件的内容         考虑这样一个应用，读取配置文件的内容。        很多应用项目，都有与应用相关的配置文件，这些配置文件多是由项目开发人员自定义的，在里面定义一些应用需要的参数...
很多应用项目都有配置文件，这些配置文件里面定义一些应用需要的参数数据。 如果客户端使用这个类是通过new一个AppConfig的实例来得到一个操作配置 文件内容的对象，则在系统运行中，有 很多地方都需
weixin_43899069的博客
11-25 1795
  很多应用项目都有配置文件，这些配置文件里面定义一些应用需要的参数数据。   如果客户端使用这个类是通过new一个AppConfig的实例来得到一个操作配置文件内容的对象，则在系统运行中，有很多地方都需要使用配置文件的内容，系统中会同时存在多份配置文件的内容，这会严重浪费内存资源。   事实上，对于AppConfig类，在运行期间，只需要一个对象实例就够了。那么应该怎么实现呢？用Java控制台应用程序实现该单例模式。绘制该模式的UML图。 代码一：AppConfig.java public class
软件设计模式实验报告（Java实现）
12-13
很多应用项目都有配置文件，这些配置文件里面定义一些应用需要的参数数据。 通常客户端使用这个类是通过new一个AppConfig的实例来得到一个操作配置文件内容的对象。如果在系统运行中，有很多地方都需要使用配置文件的内容，系统中会同时存在多份配置文件的内容，这会严重浪费内存资源。 事实上，对于AppConfig类，在运行期间，只需要一个对象实例就够了。那么应该怎么实现呢？用C#控制台应用程序实现该单例模式。绘制该模式的UML图。
研磨设计模式 试读（第5章）
laixiao1105的专栏
11-10 853
   第5章 单例模式（Singleton） 5.1 场 景 问 题5.1.1 读取配置文件的内容考虑这样一个应用，读取配置文件的内容。很多应用项目，都有与应用相关的配置文件，这些配置文件很多是由项目开发人员自定义的，在里面定义一些应用需要的参数数据。当然在实际的项目中，这种配置文件多采用xml格式，也有采用properties格式的，毕竟使用Java来
研磨设计模式-配套源代码 UTF-8格式
01-22
《研磨设计模式》是一本深入探讨软件设计原则与实践的经典书籍，其配套源代码提供了丰富的实例，帮助读者更好地理解和应用各种设计模式。这个UTF-8格式的压缩包包含了书中介绍的各种设计模式的实现，是学习和研究...
研磨设计模式.docx
09-28
研磨设计模式系列包括单例模式、工厂方法模式、策略模式、命令模式和桥接模式等多种模式，每种模式都有其特点和应用场景。 单例模式 单例模式是一种创建型模式，用于限制一个类的实例化只能产生一个对象。单例模式...
设计模式实验报告一
11-12
设计模式实验报告一
AppConfig-Perl
03-20
AppConfg Perl 安装template的必备条件包。
设计模式----单例模式
Archar_Saber的博客
04-07 300
单例模式：单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，它提供全局的访问的方法。解决方法：让类自身负责保存它的唯一实例。这个类可以保证没有其它实例被创建，并且它可以提供一个访问该实例的方法。单例模式的要点有三个：一是某个类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例。模式的主要优点：提供了对唯一实例的受控访问。由于系...
Java设计模式之 单例模式实验报告书
越努力越幸运~~ Java领域从业者；CSDN新兴创新博主；Java领域优质创作者；书写奋斗者故事;欢迎交流学习进步；
09-04 2394
目录 Java设计模式之 1 单例模式实验报告书 1 *实验四：单例模式 2 一、实验目的 2 二、实验内容 3 三、实验步骤 3 Appconfige.java 4 Client.java 4 3.2 静态内部 5 3.3懒汉模式 5 AppConfig.java 6 2.Clint.java 7 3.4双重检查锁定 7 1.AppConfig.java 7 2.Client.java 8 四...
Java私塾：研磨设计模式之单例模式
u013062625的博客
12-10 213
看到很多朋友在写单例，也来凑个热闹，虽然很简单，但是也有很多知识点在单例里面，看看是否能写出点不一样来。 单例模式（Singleton） 1 场景问题 1.1 读取配置文件的内容 考虑这样一个应用，读取配置文件的内容。 很多应用项目，都有与应用相关的配置文件，这些配置文件多是由项目开发人员自定义的，在里面定义一些应用需要的参...
设计模式 单例模式
往事随风的博客
09-16 295
1 场景问题1.1 读取配置文件的内容考虑这样一个应用，读取配置文件的内容。很多应用项目，都有与应用相关的配置文件，这些配置文件多是由项目开发人员自定义的，在里面定义一些应用需要的参数数据。当然在实际的项目中，这种配置文件多采用xml格式的。也有采用properties格式的，毕竟使用Java来读取properties格式的配置文件比较简单。现在要读取配置文件的内容，该如何实现呢？1.2 不用模式的
单例模式
便纵有千种风情
05-31 613
很多应用项目都有配置文件，这些配置文件里面定义一些应用需要的参数数据。                  通常客户端使用这个类是通过new一个AppConfig的实例来得到一个操作配置文件内容的对象。如果在系统运行中，有很多地方都需要使用配置文件的内容，系统中会同时存在多份配置文件的内容，这会严重浪费内存资源。 事实上，对于AppConfig类，在运行期间，只需要一个对象实例就够了。那么应
软件设计模式（实验一）—— 单例模式的应用（Java）
weixin_45525142的博客
08-17 1480
实验一 单例模式的应用 一、实验目的 （1) 掌握单例模式（Singleton）的特点 （2) 分析具体问题，使用单例模式进行设计。 二、实验内容和要求 很多应用项目都有配置文件，这些配置文件里面定义一些应用需要的参数数据。 通常客户端使用这个类是通过new一个AppConfig的实例来得到一个操作配置文件内容的对象。如果在系统运行中，有很多地方都需要使用配置文件的内容，系统中会同时存在多份配置文件的内容，这会严重浪费内存资源。 事实上，对于AppConfig类，在运行期间，只需要一个对象实例就够
第六天：java设计模式、GUI编程与面向对象设计原则
最新发布
JavaUpgrade
08-13 234
设计模式的定义：回顾设计模式的定义，即解决特定设计问题的通用解决方案。常见设计模式：了解并掌握几种常见的设计模式，如单例模式、工厂模式、策略模式、观察者模式等。了解它们的基本结构、应用场景和优缺点。设计模式的应用：通过实际例子或练习，尝试将设计模式应用到Java代码中，以解决实际问题。
研磨设计模式：深入解析单例与工厂方法
"研磨设计模式之单例模式.pdf" 是一篇关于设计模式的系列文章，由作者chjavach撰写，主要涵盖了GoF的23种设计模式之一——单例模式。文章旨在通过深入解析和讨论设计模式，促进读者对这些模式的理解和应用。作者计划...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值