疯狂java


您现在的位置: 疯狂软件 >> 新闻资讯 >> 正文

Java单态设计模式


 

   

  核心--在类的内部把构造器私有化,同时在内部产生对象,并通过类.静态方法(static)返回实例化对象的引用

  设计模式是在大量的实践总结和理论化之后优选的代码结果,编程风格,以及解决问题的思考方式.设计模式就像是经典的棋谱,不同的棋局我们用不同的棋谱.

  单态设计模式:采取一定的方法保证在整个软件系统中,对某个类只能产生一个对象实例,并且该类只提供一个取得其对象的实例方法.

  在java中实现单态模式只需要执行以下三步:

  1.将类的构造方法的访问权限声明为private.这样就不能用new操作符在类的外部产生类的对象了,但在类内部仍可以产生该类的对象.

  2.在类内部生成一个静态的实例.

  3.提供一个静态的方法用于外部取得该类的实例.

  因为在类的外部无法得到类的对象,所以只能调用该类的某个静态方法以返回类内部创建的对象,又因为静态方法只能访问类中的静态成员变量,所以,指向类内部产生该类对象的变量也必须定义成静态的.

  class Chinese{

  static Chinese objRef = new Chinese();

  private Chinese(){}

  public static Chinese getInstance(){

  return objRef;

  }

  }

  class Chinese_opt{

  static Chinese_opt objRef = null;

  private Chinese_opt(){}

  public static Chinese_opt getInstance(){

  if(objRef == null)

  objRef = new Chinese_opt();

  return objRef;

  }

  }

  class TestChinese{

  public static void main(String[] args){

  Chinese chinese1 = Chinese.getInstance();

  Chinese chinese2 = Chinese.getInstance();

  System.out.println(chinese1 == chinese2);

  }

  }

  1:构造方法私有化:

  面向对象编程的三大特性:封装、继承、多态。类的封装性不仅体现在对属性的封装上,实际上方法也是可以被封装的,构造方法是特殊的方法当然也可以被封装,例如下面的代码就是对构造方法的封装:

  package com.zxf.javaopp;

  public class Singleton {

  private Singleton(){ // 将构造方法进行了封装,私有化

  }

  public void print(){

  System.out.println("Hello World!!!") ;

  }

  }

  构造函数被私有化,不能在外部实例化,就无法在外部使用,此时只能在该类的内部实例化对象了,然后将该类拿到外部进行使用,由于该类不能再外部实例化,此时在内部的实例化必须是用static关键字修饰的:代码如下:

  package com.zxf.javaopp;

  class Singleton1{

  static Singleton1 instance = new Singleton1() ; // 在内部产生本类的实例化对象

  private Singleton1(){ // 将构造方法进行了封装,私有化

  }

  public void print(){

  System.out.println("Hello World!!!") ;

  }

  }

  public class SingletonDemo01{

  public static void main(String args[]){

  Singleton1 s1 = null ; // 声明对象

  s1 = Singleton1.instance ; // 取得实例化对象

  s1.print() ; // 调用方法

  }

  }

  虽然上面的代码实现了功能,但又有些问题:通常情况下:我们将属性封装,此时的代码就要修改如下:

  package com.zxf.javaopp;

  class Singleton1{

  static Singleton1 instance = new Singleton1() ; // 在内部产生本类的实例化对象

  public static Singleton1 getInstance(){ // 通过静态方法取得instance对象

  return instance ;

  }

  private Singleton1(){ // 将构造方法进行了封装,私有化

  }

  public void print(){

  System.out.println("Hello World!!!") ;

  }

  }

  public class SingletonDemo01{

  public static void main(String args[]){

  Singleton1 s1 = null ; // 声明对象

  s1 = Singleton1.getInstance() ; // 取得实例化对象

  s1.print() ; // 调用方法

  }

  }

  以上的代码似乎变得很复杂,不如不将构造方法实例化呢,但是为什么又会这样做呢?

  假如我们现在要产生几个对象:按以往的代码,就需要实例化多次,每个对象都有其对应的堆栈空间,此时的内存就消耗的很多,系统的效率坑定比较低,但是使用将构造方法封装的模式效率就比较高:

  JAVA单态设计模式

  使用将构造方法封装的方法:无论产生多少个对象,我们只实例化一次,这样的设计在设计模式上称为单态设计模式(单例设计模式):

  singleton,如果不希望一个类产生多个实例的话,则必须使用单态设计模式,此设计模式,在以后的高性能开发中经常使用,而且在java的类库中大量的使用了此设计模式。

  所谓单态就是在入口处限制了对象的实例操作。

  单态设计模式的意义:

  实际上这种模式非常常用,我们大家使用的windows操作系统中就使用了此设计模式,windows中用一个回车站: ,除了桌面以外,其他的每个硬盘中都有一个回车站,其他的回车站和其他硬盘的每个回车站都是同一个,也就是所整个操作系统中有且只有一个回车站,各个地方只是引用此实例。

  总结:

  单态设计模式的核心就是将类的

  构造函数私有化,在类的内部产生实例对象,并通过类的静态方法返回类的实例对象。