单例设计模式

/*

 * 第一种方式称为：饿汉式

 * 这是先初始化对象

 * Single类一进入内存，就已经创建好了对象

 */

/*

class Single

{

    private String name;

    private Single(){};

    private static Single s = new Single();

    public static Single SingleInstance()

    {

       return s;

    }

}

*/

/*

 * 第二种方式  称为：懒汉式

 * 对象是被方法调用时，才初始化，也叫做对象的延时加载。

 * Single类进内存，对象还没有存在，只有调用了“SingleInstance方法时，才建立对象”

 */

/*

 * 设计模式：

 * java中有23种设计模式：

 * 我们介绍其中一种设计模式：

 * 单例设计模式：（解决一个类在对象中，只存在一个对象）

 *

 * 想要保证对象的唯一

 * 1，为了避免其它程序过多的建立该类对象，先禁止其它程序建立该类对象。

 * 2，还为了让其它程序可以访问到该类对象，只好在本类中，自定义一个对象。

 * 3，为了方便其它程序对自定义对象的访问，可以对外提供一些访问方式。

 *

 * 这三步使用代码体现方式？

 * 1，将构造函数私有化。

 * 2，在类中创建一个本类对象。

 * 3，提供一个方法可以获取该对象。

 *

 * 什么时候使用？

 * 对于事物该怎么描述，还怎么描述

 * 当需要将该事物的对象在内存中唯一时，就将以上三步加上即可。

 * 例如下面代码：Studetn类（对一个特殊学生定义：唯一的学生）

 */

 

class Single

{

    private int num;

    public void setNum(int num)

    {

       this.num = num;

    }

    public int getNum()

    {

       returnnum;

    }

    private Single(){}         //第一步：将初始化构造函数私有化。

   

    //由于不能让外部访问此方法，所以前面要加private

    private static Single s = new Single();    //第二步：在本类中创建一个本类对象。

    public static Single getInstance() //第三步：提供一个方法，获取该对象。（返回值是：调用哪个方法返回哪个）

    {

       returns;   //因为静态成员只能访问静态成员变量，所以上面的s也要加上static

    }

}

public class _08设计模式 {

   

    public static void main(String[] args)

    {

       //如何调用上面的对象？因为不能创建对象new....所以只能通过类名.方法名 所以方法加static

       Single s1 = Single.getInstance();

       Single s2 = Single.getInstance();

       s1.setNum(33);//赋值

       System.out.println(s2.getNum());

      

       Student d1 = Student.StudetnInstance();

       Student d2 = Student.StudetnInstance();

       d1.setAge(22);//给d1赋值后，再打印d2的年龄；也是22，

       System.out.println(d2.getAge());//结果是：22

    }

 

}

class Student

{

    private int age;

    public void setAge(int age)

    {

       this.age=age;

    }

    public int getAge()

    {

       returnage;

    }

    private Student(){}

    private static Student s = new Student();

    public static Student StudetnInstance()

    {

       returns;

    }

}

 

/*

 * 第一种方式称为：饿汉式

 * 这是先初始化对象

 * Single类一进入内存，就已经创建好了对象

 */

/*

class Single

{

    private String name;

    private Single(){};

    private static Single s = new Single();

    public static Single SingleInstance()

    {

       return s;

    }

}

*/

/*

 * 第二种方式  称为：懒汉式

 * 对象是被方法调用时，才初始化，也叫做对象的延时加载。

 * Single类进内存，对象还没有存在，只有调用了“SingleInstance方法时，才建立对象”

 */

class Singlee

{

    private static Singlee s = null;

    private Singlee(){}

    public static Singlee SingleInstance()

    {

       if(s==null)//双重if判断

       {

           synchronized(Singlee.class)//上锁

           {

              if(s==null)

              {

                  s = new Singlee();

              }

           }

       }

       return s;

    }

}

public class _09设计模式_单例_第二种方式 {

   

    public static void main(String[] args)

    {

       Singlee s = Singlee.SingleInstance();

      

    }

 

}