浅谈JAVASE单例设计模式

简单的说设计模式,其实就是对问题行之有效的解决方式。其实它是一种思想。

1.单例设计模式。

解决的问题:就是可以保证一个类在内存中的对象唯一性。(单个实例)

使用单例设计模式需求:必须对于多个程序使用同一个配置信息对象时,就需要保证该对象的唯一性。

如何保证对象唯一性?                                                      解决步骤:

1.不允许其他程序用new创建该对象。                                            1.私有化该类构造函数。

2.在该类创建一个本类实例。                                                         2.通过new 在该类中创建一个本类对象。

3.对外提供一个方法让其他程序可以获取该对象。                            3.定义一个公有的方法,将创建的对象返回。

//饿汉式(开发时常用)
class Single//类一加载,对象就已经存在了。
{
  private static Single s = new Single();

  private Single(){}

  public static Single getInstance()
  {
    return s;
  }
}
//懒汉式(面试时常问,在多线程并发访问时候有可能导致不能保证不了对象的唯一性,存在安全隐患!)
class Single2//类加载进来,没有对象,只有调用了getInstance方法时,才会创建对象。
      //延迟加载形式。
{
  private static Single2 s = null;

  private Single2(){}

  public static Single2 getInstance()
  {
    if(s==null)
      s = new Single2();
    return s;
  }
}

//调用类
class SingleDemo
{
  public static void main(String[] args)
  {
    Single s1 = Single.getInstance();
    Single s2 = Single.getInstance();

    System.out.println(s1==s2);

//   Single ss = Single.s; //此处不采用这个是因为不可控,采用 Single.getInstance();可以传参数进行相应调用。

  }
}

饿汉式单例类在自己被加载时就将自己实例化。即便加载器是静态的,在饿汉式单例类被加载时仍会将自己实例化。单从资源利用效率角度来讲,这个比懒汉式单例类稍差些。从速度和反应时间角度来讲,则比懒汉式单例类稍好些。

3.登记式:

代码:

package pattern.singleton;import java.util.HashMap;import java.util.Map;
 //登记式单例类.
 //类似Spring里面的方法,将类名注册,下次从里面直接获取。
public class Singleton3 {
 private static Map<String,Singleton3> map = new HashMap<String,Singleton3>();
 static{
 Singleton3 single = new Singleton3();
 map.put(single.getClass().getName(), single);
 }
 //保护的默认构造子
protected Singleton3(){}
 //静态工厂方法,返还此类惟一的实例
public static Singleton3 getInstance(String name) {
 if(name == null) {
 name = Singleton3.class.getName();
 System.out.println("name == null"+"--->name="+name);
 }
 if(map.get(name) == null) {
 try {
 map.put(name, (Singleton3) Class.forName(name).newInstance());
 } catch (InstantiationException e) {
 e.printStackTrace();
 } catch (IllegalAccessException e) {
 e.printStackTrace();
 } catch (ClassNotFoundException e) {
 e.printStackTrace();
 }
 }
 return map.get(name);
 }
 //一个示意性的商业方法
public String about() {
 return "Hello, I am RegSingleton.";
 }
 public static void main(String[] args) {
 Singleton3 single3 = Singleton3.getInstance(null);
 System.out.println(single3.about());
 }
 }
(0)

相关推荐

  • 讲解Java设计模式编程中的建造者模式与原型模式

    建造者模式 定义 又叫生成器模式,它可以将复杂对象的建造过程抽象出来(抽象类别),使这个抽象过程的不同实现方法可以构造出不同表现(属性)的对象. 当创建复杂对象的算法应该独立于该对象的组成部分时,而且构造过程必须允许被构造的对象有不同的表示时.我们可以考虑使用建造者模式. 实现 1. Builder为创建一个Product对象的各个部件指定抽象接口.通常包含创建产品和返回产品的抽象方法,也可以是具体方法,把创建过程放到ConcreteBuilder类中. 2. ConcreteBuilder 实

  • Java设计模式编程中的工厂方法模式和抽象工厂模式

    工厂方法模式 动机 创建一个对象往往需要复杂的过程,所以不适合包含在一个复合工厂中,当有新的产品时,需要修改这个复合的工厂,不利于扩展. 而且,有些对象的创建可以需要用到复合工厂访问不到的信息,所以,定义一个工厂接口,通过实现这个接口来决定实例化那个产品,这就是工厂方法模式,让类的实例化推迟到子类中进行. 目的 1. 定义一个接口,让子类决定实例化哪个产品. 2. 通过通用接口创建对象. 实现 1. 产品接口和具体产品很好理解. 2. 工厂类提供一个工厂方法,返回一个产品对象.但是这个工厂方法是

  • 举例讲解Java设计模式中的对象池模式编程

    定义 一个对象池是一组已经初始化过且可以使用的对象的集合,池的用户可以从池子中取得对象,对其进行操作处理,并在不需要时归还给池子而非销毁它. 若初始化.实例化的代价高,且有需求需要经常实例化,但每次实例化的数量较少的情况下,使用对象池可以获得显著的效能提升.从池子中取得对象的时间是可预测的,但新建一个实例所需的时间是不确定. 实现 1. Reusable - 对象池中的对象,通常实例化代价比较高. 2. Client - 使用一个对象的实例. 3. ReusablePool - 管理对象的实例化

  • 浅析Java设计模式编程中的单例模式和简单工厂模式

    单例模式 动机 有时候只有一个类的实例是很重要的.比如,一个系统应该只有一个窗口管理实例. 单例模式是最简单设计模式:类负责实例化自己,确保只有一个实例,并且提供一个访问这个实例的入口. 目的 1. 确保只有一个实例被创建. 2. 提供访问这个实例的入口. 使用final确保被创建一次,private的构造函数确保不被实例化.public的getInstance方法确保外部能够访问.下面是饿汉模式: public class Singleton { private static final Si

  • Java设计模式之单例模式实例分析

    本文实例讲述了Java设计模式之单例模式.分享给大家供大家参考,具体如下: 单例模式:(Singleton Pattern)是一个比较简单的模式,其定义如下: Ensure a class has only one instance, and provide a global point of access to it.(确保某一个类只有一个实例,而且自行实例化并向整个系统提供这个实例) 单例模式,很简单的一个模式.其实在android开发中,很多地方都会用到单例模式,比如某些工具类.Json数

  • 详解Java设计模式编程中的里氏替换原则

    定义1:如果对每一个类型为 T1的对象 o1,都有类型为 T2 的对象o2,使得以 T1定义的所有程序 P 在所有的对象 o1 都代换成 o2 时,程序 P 的行为没有发生变化,那么类型 T2 是类型 T1 的子类型. 定义2:所有引用基类的地方必须能透明地使用其子类的对象. 问题由来:有一功能P1,由类A完成.现需要将功能P1进行扩展,扩展后的功能为P,其中P由原有功能P1与新功能P2组成.新功能P由类A的子类B来完成,则子类B在完成新功能P2的同时,有可能会导致原有功能P1发生故障. 解决方

  • Java观察者设计模式(Observable和Observer)

    观察者模式定义了一种一对多的依赖关系,让多个观察者对象同时监听某一个主题对象. 这个主题对象在状态上发生变化时,会通知所有观察者对象,让它们能够自动更新自己. 一.观察者模式介绍 在Java中通过Observable类和Observer接口实现了观察者模式.一个Observer对象监视着一个Observable对象的变化,当Observable对象发生变化时,Observer得到通知,就可以进行相应的工作. 如果画面A是显示数据库里面的数据,而画面B修改了数据库里面的数据,那么这时候画面A就要重

  • 举例解析Java的设计模式编程中里氏替换原则的意义

    里氏替换原则,OCP作为OO的高层原则,主张使用"抽象(Abstraction)"和"多态(Polymorphism)"将设计中的静态结构改为动态结构,维持设计的封闭性."抽象"是语言提供的功能."多态"由继承语义实现. 里氏替换原则包含以下4层含义: 子类可以实现父类的抽象方法,但是不能覆盖父类的非抽象方法. 子类中可以增加自己特有的方法. 当子类覆盖或实现父类的方法时,方法的前置条件(即方法的形参)要比父类方法的输入参数更

  • Java结构型设计模式中的适配器模式与桥接模式解析

    适配器模式 定义 适配器模式(英语:adapter pattern)有时候也称包装样式或者包装.将一个类的接口转接成用户所期待的.一个适配使得因接口不兼容而不能在一起工作的类工作在一起. 有两类适配器模式: 1. 对象适配器模式 - 对象适配器通过关联满足用户期待接口,还降低了代码间的不良耦合.在工作中推荐使用"对象适配". 2. 类适配器模式 - 这种适配器模式下,适配器继承自已实现的类(一般多重继承),java中没有多重继承,所以这里不做介绍. 实现 1. Target - 定义C

  • 详解Java编程的Observer观察者设计模式

    java语言里包含了许多对设计模式的直接支持,如command模式,agent模式,observer模式等.虽然java提供的对这些模式的支持很简单,不能满足比较复杂的应用.但在简单的场景下,使用这些类往往能够得到立杆见影的效果.所以,如果没有什么特殊需求,还是最好利用java的这些类.         Observer模式,又称监听模式,观察者模式,是经典设计模式之一(one of GOF).java语言中,对这种模式支持的类和接口主要有以下几个,全部来自java.beans包: java.b

随机推荐