黑马程序员_10_单列设计模式

时间:2023-02-19 16:03:47

                                           黑马程序员——单列设计模式

                                            ------- android培训java培训、期待与您交流! ----------


设计模式:顾名思义就是解决一类问题的固定步骤,如建房必须打地基---起柱子---砌墙---封顶---装修。

单列设计模式:定义是必须保证一个类在内存中只有一个对象。

从应用场景来看又分为:饿汉式单例设计模式,懒汉式单例设计模式。

饿汉式单列设计模式步骤:

1、私有化构造函数,这样别人就不能通过new关键随意创建对象了。

2、但是必须保证一个类在内存中有一个对象,所以在本类中创建一个本类的对象,且声明一个变量指向。

    3、提供一个公共的静态的方法获取本类的对象。
    
    
  1.         
            
    1. class Single{
    2. //2声明本类的一个引用类型变量并且指向该类对象。
    3. private static Single s = new Single();
    4. //1私有化构造函数。
    5. private Single(){}
    6. //3提供一个公共的静态方法获取本类的对象。
    7. public static Single getInstance()
    8. {
    9. return s;//返回一个对象
    10. }
    11. }
    12. class Instance
    13. {
    14. public static void main(String[] args){
    15. //获取本类的一个对象。
    16. Single s1 = Single.getInstance();
    17. Single s2 = Single.getInstance();
    18. System.out.println(s1==s2);//输出结果是ture
    19. }
    20. }

注意:饿汉式单例设计模式,提供的公共方法必须是静态方法。在成员位置声明本类的一个引用类型变量且指向该类对象,如果别人没使用到,会出现资源浪费问题。

懒汉式单例设计模式步骤:       1、私有化构造函数。       2、声明本类的引用类型变量,但不创建本类的对象。       3、提供一个公共静态的方法创建本类的对象并且返回,在创建之前必须要先判断是否已经创建了该类的对象, 如果已经创建了那么直接返回即可,如果没有创建那么先创建再返回。代码如下:
    
    
  1. //懒汉式
  2. class Single2{
  3. //声明本类的引用类型变量,但是不创建本类的对象。
  4. private static Single2 s;
  5. //私有化了构造函数
  6. private Single2(){}
  7. //提供一个公共静态的方法创建本类的对象并且返回。
  8. public static Single2 getInstance(){
  9. if(s==null){//判断s是否已经创建
  10. s = new Single2();
  11. }
  12. return s;
  13. }
  14. }
  15. class Test
  16. {
  17. public static void main(String[] args)
  18. {
  19. //获取到了本类的一个对象。
  20. Single2 s1 = Single2.getInstance();
  21. Single2 s2 = Single2.getInstance();
  22. System.out.println("是同一个对象吗?"+ (s1==s2));//输出结果是ture
  23. }
  24. }

推荐使用:饿汉式单例设计模式,因为懒汉式存在线程安全问题。懒汉式单例设计模式:事先不做,什么时候需要什么时候创建对象。但存在线程安全。
饿汉式单例设计模式:事先先做,先把对象给创建,但缺点是如果没人使用,浪费资源。
懒汉式单列设计模式存在着线程安全问题,那该如何解决呢?我们可以采用同步代码块进行双重判断解决该类问题。这种方法又叫延时加载单例设计模式:代码如下:
    
    
  1. package itheima;
  2. //懒汉式
  3. class Single{
  4. //声明本类的引用类型变量,但是不创建本类的对象。
  5. private static Single s;
  6. //私有化了构造函数
  7. private Single(){}
  8. //提供一个公共静态的方法创建本类的对象并且返回。
  9. public static Single getInstance(){
  10. //采用双重判断,这样只有第一次需要判断锁,
  11. if(s==null){
  12. //锁采用本类字节码文件,保证锁的唯一
  13. synchronized (Single.class) {
  14. if(s==null){//判断s是否已经创建
  15. s = new Single();
  16. }
  17. }
  18. }
  19. return s;
  20. }
  21. }
采用双重判断,大大提高了效率。不采用同步函数,是因为每次进来都需要判断锁,效率低。



                                           ------- android培训java培训、期待与您交流! ----------