-
- 努力学习搬砖 2022-03-29
设计模式——单例模式
一、介绍
设计模式更多的是思想层面，是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了使代码高可用，易于他人理解以及保证代码的可靠性。
设计模式有23中：单例模式、抽象工厂模式、工厂模式、建造者模式、原型模式等。
单例模式（使用单例模式就是为了保证整个应用中某个实例有且只有一个）：
在程序开发中，有些对象只需要一个，比如：配置文件、工具类、线程池、缓存、日志对象等；如果创建多个对象，会导致很多问题，比如资源占用，结果不一致等等。
二、实现
单例模式（Singleton）：
饿汉模式（静态成员属类所有，加载类时，就会创建类的唯一实例，不管用户是否使用这个实例，它已经被加载，形象的称之为“饿汉模式”）：
public class Singleton{ //默认的构造方法在创建对象时被调用；多次new则创建多个类对象 //1、私有化构造方法(外部无法直接通过构造方法创建实例，避免创建多个实例) private Singleton(){} //2、保证实例只有一个，自己创建实例(创建类的唯一实例,使用private static修饰类的静态成员) //因外部类无法直接使用对象.成员方法()，所以使用static静态修饰对象，用类名.成员名创建实例 //为了控制访问、安全，加private不允许外部访问成员变量，不能使用类名.成员名创建实例 private static Singleton instance = new Singleton(); //3、提供一个用于获取实例的方法(属于对象方法，不用static修饰的话无法用类名.方法创建实例) /*public Singleton getInstance(){ return instance; }*/ //使用public static修饰类方法 public static Singleton getInstance(){ return instance; } }public class Test{ public static void main(String[] args){ //私有化构造方法后，外部类无法直接创建实例 /*Singleton s1 = Singleton.instance;//调用静态成员创建实例 Singleton s2 = Singleton.instance;//调用静态成员创建实例 if(s1==s2){//true 保证创建的Singleton对象是单个实例 System.out.println("s1和s2是同一个实例"); }else{ System.out.println("s1和s2不是同一个实例"); }*/ //调用失败，方法是对象方法（没有用static修饰的方法） /*Singleton s1 = Singleton.getInstance();*/ Singleton s1 = Singleton.getInstance(); Singleton s2 = Singleton.getInstance(); if(s1==s2){//true 保证创建的Singleton对象是单个实例 System.out.println("s1和s2是同一个实例"); }else{ System.out.println("s1和s2不是同一个实例"); } } }懒汉模式（类加载时不创建唯一实例，当第一个用户获取时判断实例为空时时创建，之后所有用户获取已经存在的实例将不再创建）：
public class Singleton2{ //1、私有化构造方法，不允许外部直接通过构造方法创建对象 private Singleton2(){} //2、声明类的唯一实例，使用private static 修饰 private static Singleton2 instance ; //3、提供一个用于获取实例的方法，使用public static修饰 public static Singleton2 getInstance(){ if(instance == null){ instance = new Singleton2(); } return instance; } }public class Test{ public static void main(String[] args){ Singleton2 s3 = Singleton2.getInstance(); Singleton2 s4 = Singleton2.getInstance(); if(s3==s4){//true 保证创建的Singleton对象是单个实例 System.out.println("s3和s4是同一个实例"); }else{ System.out.println("s3和s4不是同一个实例"); } }三、区别
饿汉模式加载类时比较慢，运行时获取对象速度比较快，线程安全；
懒汉模式加载类时比较快（加载类时没有创建类的对象），但运行时获取对象速度比较慢（用户第一次获取对象时由于类还没有被创建，需要创建对象的一个过程），线程不安全。
- 0赞 · 0采集
-
- 长亭外的少年 2021-07-29
- 单例模式六种实现方式
- 0赞 · 0采集
-
- 宝慕林5438281 2021-04-28
- 声明实例和实例化 两种模式区别在实例化的地方不一样
-
截图0赞 · 0采集
-
- 宝慕林5438281 2021-04-28
- 对象方法和类方法： 类方法前加static，归类所有，其他类可以直接调用该方法
-
截图0赞 · 0采集
-
- 宝慕林5438281 2021-04-28
- static 类的
-
截图0赞 · 0采集
-
- JeasonLiu先生 2021-04-11
- 设计模式，单例模式 笔记 1，设计模式的定义。 用你的人多了，一种反复使用的，多数人知晓的，方法的总结。 2 饿汉模式 1)控制不可以被外部直接实例化对象，使用private修饰构造函数。 2)私有化构造函数后，外部无法创建实例化对象，所以要实现唯一实例对象，通过类对象实现。 单纯的在类里实例化一个对象，该对象作为类成员，需要外部通过对象加点去获取，但是外部没有对象，就要通过添加static去将这个唯一实例化对象变成类的成员变量，通过类名的方式去获取该对象。 3)为了安全考虑，不允许外部直接访问类成员变量，给变量添加private修饰，此时，外部不可以通过类名直接访问这个对象。 再添加一个public访问函数，同理，只添加public为类的对象，无法外部直接使用。所以添加static修饰，变为类方法。 4)该方法，加载类的时候直接实例化一个对象，所以加载较慢，但是调用较快 3 懒汉模式 加载的时候不实例化，第一次调用的时候实例化。所以加载较快，使用较慢。 4 饿汉模式，线程安全 懒汉模式，线程不安全
-
截图0赞 · 0采集
-
- ______1________ 2020-12-23
- 懒汉模式
-
截图0赞 · 0采集
-
- WE_Xing 2020-07-25
Singleton
-
截图0赞 · 0采集
-
- WE_Xing 2020-07-25
Singleton 懒汉式
-
截图0赞 · 0采集
-
- WE_Xing 2020-07-25
Singleton 饿汉式
-
截图0赞 · 0采集
-
- WE_Xing 2020-07-25
配置文件/工具类/线程池/缓存/日志对象等
-
截图0赞 · 0采集
-
- WE_Xing 2020-07-25
Design Pattern
-
截图0赞 · 0采集
-
- 依然so疯 2020-03-17
- 单例模式只有一个实例 饿汉模式 私有构造方法 初始化实例private static 获取实例方法public static 加载类时创建实例 所以慢 线程安全 懒汉模式 私有构造方法 声明实例private static 获取实例方法public static里判断实例是否为空 空初始化实例 不空返回实例 加载类时只声明实例 所以快 用户获取实例时判断是否为空 为空初始化实例 否则返回实例 线程不安全
-
截图0赞 · 0采集
-
- 慕慕4194591 2019-10-30
- Gh
- 0赞 · 0采集
-
- 慕无忌7508980 2019-09-15
- 1.设计模式：是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。 2.单例模式： 2.1应用场景：有些对象我们只需要一个，eg：皇帝、老婆 2.2作用：保证整个应用中某个实例有且只有一个 2.3类型以及实现 2.3.1饿汉模式 ①构造方法私有化，private，不允许外部直接创建对象 ②创建类的唯一实例，使用private static修饰，类加载时就创建了，所以加载速度较慢。 ③提供一个用于获取实例的使用public static修饰的方法，直接返回该实例，所以运行时获取对象的速度比较快。 2.3.2懒汉模式 ①同饿汉 ②声明类的实例，使用private static修饰，但不对其进行实例化，类加载时不进行创建 ③同饿汉，但是会在首次调用该方法时实例化声明的类的实例，在之后的调用中返回该实例化对象。 3.区别 饿汉模式 加载类的速度较慢，运行时获取对象的速度较快，同时是线程安全的 懒汉模式 加载类的速度较快，运行时第一次获取对象的速度较慢，线程不安全，需要加锁?
-
截图2赞 · 1采集
-
- 微风微漾 2019-08-14
添加static 让他变为类所有，不再是对象方法,可以通过类名直接访问
public static Singleton getInstance(){}
Singleton s1=Singleton.getInstance();
-
截图0赞 · 0采集
-
- 微风微漾 2019-08-13
设计模式目的
-
截图0赞 · 0采集
-
- 慕桂英1111525 2019-06-24
- 学习了
- 0赞 · 0采集
-
- guo951114 2019-04-11
- 饿汉式单列模式
-
截图0赞 · 0采集
-
- weixin_慕仰8191171 2019-04-10
饿汉模式的特点是加载类时比较慢，但运行时获取对象的速度比较快
懒汉模式的特点是加载类时比较快，但运行时获取对象的速度比较慢
- 0赞 · 1采集
-
- 奇大姨父 2019-04-10
饿汉模式加载类慢，运行时获取对象快，线程安全
懒汉模式加载类快，运行时获取对象慢，线程不安全
- 0赞 · 0采集
-
- 奇大姨父 2019-04-10
使用设计模式的为了可重用代码、让代码更容易被他人理解、保证代码可靠性
- 1赞 · 0采集
-
- 奇大姨父 2019-04-10
设计模式：是一套被反复使用、所属人知晓的、经过分类编目的、代码设计经验的总结
- 0赞 · 0采集
-
- 不忘初心__ 2019-03-26
单例模式 --- 懒汉模式
class Singleton { //1.将构造方法私有化，使外部无法直接创建对象 private Singleton() { } //2.创建类的唯一实例 private static Singleton instance; //3.提供获取实例的方法 public static Singleton getInstance() { if(instance==null){ instance = new Singleton(); } return instance; } }特点：在第一次调用时，实例化对象。（特点加载类较快，调用较慢）
- 0赞 · 0采集
-
- 不忘初心__ 2019-03-26
单例模式 --- 饿汉模式
class Singleton { //1.将构造方法私有化，使外部无法直接创建对象 private Singleton() { } //2.创建类的唯一实例 private static Singleton instance = new Singleton(); //3.提供获取实例的方法 public static Singleton getInstance() { return instance; } }特点：在加载类时实例化对象。（加载类较慢，但调用较快）
- 0赞 · 0采集
-
- 望生帝 2019-03-14
//区别：饿汉模式的特点是加载类时比较慢，但运行时获取对象的速度比较快,线程安全
//懒汉模式的特点是加载类时比较快，但运行时获取对象的速度比较慢，线程不安全
- 0赞 · 0采集
-
- 望生帝 2019-03-14
//单例模式：懒汉模式
public class Singleton2{
//1、将构造方式私有化，不允许外边直接创建对象
private Singleton2(){}
//2、创建类的唯一实例，使用private static修饰
private static Singleton2 instance;
//3、提供一个用于获取实例的方法，使用public static修饰
public static Singleton2 getInstance(){
if(instance==null)
{
instance=new Singleton2();
}
return instance;
}
}
public class Test{
public static void main(String[] args)
{
Singleton s1=Singleton2.getInstance();
Singleton s2=Singleton2.getInstance();
if(s1==s2)
{
System.out.println("s1和s2是同一个实例");
}else{
System.out.println("s1和s2不是同一个实例");
}
}
}
- 0赞 · 0采集
-
- 望生帝 2019-03-14
//单例模式：饿汉模式
public class Singleton{
//1、将构造方法私有化，不允许外部直接创建对象
private Singleton(){}
//2、创建类的唯一实例,使用private static修饰
private static Singleton instance=new Singleton();
//3、提供一个用于获取实例的方法
public static Singleton getInstace()
{
return instance;
}
}
public class Test{
public static void main(String[] args)
{
Singleton s1=Singleton.getInstance();
Singleton s2=Singleton.getInstance();
if(s1==s2)
{
System.out.println("s1和s2是同一个实例");
}else{
System.out.println("s1和s2不是同一个实例");
}
}
}
- 0赞 · 0采集
-
- 望生帝 2019-03-14
设计模式：懒汉模式、饿汉模式
目的：可重用代码、易理解、保证代码可靠性
单例模式使用：在有些对象我们只需要一个的时候，比如：配置文件、工具类、线程池、缓存、日志对象等。如果创造多个实例，就会导致许多问题，比如占用过多资源，不一致的结果等。
- 0赞 · 0采集
-
- 慕仰mooc 2019-03-08
单例模式 1：饿汉模式，加载慢，获取快，线程安全 2：懒汉模式，加载快，获取慢，线程不安全 单列模式分为： 饿汉式：声明的同时直接实例化。 特点：加载类时比较慢，但运行时获取对象的速度比较快，线程安全。 懒汉式：声明的时候不实例化。 特点：加载类时比较快，但运行时获取对象的速度比较慢，线程不安全。 实现单列模式的三个步骤： 1、将构造方法私有化，不允许外界直接创建对象。 2、声明类的唯一实例，使用private static修饰。 3、提供一个供外界获取实例的方法，使用public static修饰。
- 0赞 · 2采集
