尚硅谷Java设计模式——029单例模式

最新推荐文章于 2023-07-10 10:57:21 发布
最新推荐文章于 2023-07-10 10:57:21 发布
阅读量208 收藏
点赞数
分类专栏： Java学习路线-尚硅谷 文章标签： 单例模式 饿汉式 静态常量 设计模式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33790600/article/details/119077833
版权

单例设计模式介绍

所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法(静态方法)。

比如Hibernate的SessionFactory，它充当数据存储源的代理，并负责创建Session对象。SessionFactory并不是轻量级的，一般情况下，一个项目通常只需要一个SessionFactory就够，这时就会使用到单例模式。

单例设计模式八种方式

1) 饿汉式(静态常量)
2) 饿汉式（静态代码块）
3) 懒汉式(线程不安全)
4) 懒汉式(线程安全，同步方法)
5) 懒汉式(线程安全，同步代码块)
6) 双重检查
7) 静态内部类
8) 枚举

1 饿汉式（静态常量）

饿汉式（静态常量）应用实例。
步骤如下：

  1. 构造器私有化 (防止 new )
  2. 类的内部创建对象
  3. 向外暴露一个静态的公共方法，getInstance

代码演示

package com.atguigu.singleton.type1;

/**
 * @author WHT
 * @create 2021-07-25 8:27
 */
public class SingletonTest01 {
    public static void main(String[] args) {
        // 测试
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2); // true
        System.out.println("instance.hashCode=" + instance.hashCode());
        System.out.println("instance2.hashCode=" + instance2.hashCode());
    }
}


// 饿汉式(静态常量)
class Singleton {

    //1. 构造器私有化, 外部不能new
    private Singleton() {

    }

    //2.本类内部创建对象实例
    private final static Singleton instance = new Singleton();

    //3. 提供一个公有的静态方法，返回实例对象
    public static Singleton getInstance() {
        return instance;
    }

}

运行结果

D:\java\jdk-11.0.11\bin\java.exe "-javaagent:D:\IntelliJ IDEA 2020.1.1\lib\idea_rt.jar=2169:D:\IntelliJ IDEA 2020.1.1\bin" -Dfile.encoding=UTF-8 -classpath E:\WHT\Project\Java\DesignPattern\out\production\DesignPattern com.atguigu.singleton.type1.SingletonTest01
true
instance.hashCode=1239731077
instance2.hashCode=1239731077

Process finished with exit code 0
优缺点说明：

  1. 优点：这种写法比较简单，就是在类装载的时候就完成实例化。避免了线程同步问题。

  2. 缺点：在类装载的时候就完成实例化，没有达到Lazy Loading的效果。如果从始至终从未使用过这个实例，则会造成内存的浪费。

  3. 这种方式基于classloder机制避免了多线程的同步问题，不过，instance在类装载时就实例化，在单例模式中大多数都是调用getInstance方法， 但是导致类装载的原因有很多种，因此不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化instance就没有达到lazy loading的效果。

  4. 结论：这种单例模式可用，但可能造成内存浪费。

2 饿汉式（静态代码块）

饿汉式（静态代码块）应用实例。

代码演示

package com.atguigu.singleton.type2;

/**
 * @author WHT
 * @create 2021-07-25 8:27
 */
public class SingletonTest02 {
    public static void main(String[] args) {
        // 测试
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2); // true
        System.out.println("instance.hashCode=" + instance.hashCode());
        System.out.println("instance2.hashCode=" + instance2.hashCode());
    }
}


// 饿汉式(静态代码块)
class Singleton {

    //1. 构造器私有化, 外部不能new
    private Singleton() {

    }

    //2.本类内部创建对象实例
    private static Singleton instance;

    // 在静态代码块中，创建单例对象
    static {
        instance = new Singleton();
    }

    //3. 提供一个公有的静态方法，返回实例对象
    public static Singleton getInstance() {

        return instance;
    }

}

运行结果

D:\java\jdk-11.0.11\bin\java.exe "-javaagent:D:\IntelliJ IDEA 2020.1.1\lib\idea_rt.jar=5373:D:\IntelliJ IDEA 2020.1.1\bin" -Dfile.encoding=UTF-8 -classpath E:\WHT\Project\Java\DesignPattern\out\production\DesignPattern com.atguigu.singleton.type2.SingletonTest02
true
instance.hashCode=1239731077
instance2.hashCode=1239731077

Process finished with exit code 0
优缺点说明

这种方式和上面的方式其实类似，只不过将类实例化的过程放在了静态代码块中，也是在类装载的时候，就执行静态代码块中的代码，初始化类的实例。优缺点和上面是一样的。

3 懒汉式(线程不安全)

代码演示

package com.atguigu.singleton.type3;

/**
 * @author WHT
 * @create 2021-07-25 8:27
 */
public class SingletonTest03 {
    public static void main(String[] args) {
        // 测试
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2); // true
        System.out.println("instance.hashCode=" + instance.hashCode());
        System.out.println("instance2.hashCode=" + instance2.hashCode());
    }
}


// 懒汉式(线程不安全)
class Singleton {

    //1. 构造器私有化, 外部不能new
    private Singleton() {

    }

    //2.本类内部创建对象实例
    private static Singleton instance;

    //3.提供一个静态的公有方法，当使用到该方法时，才去创建instance
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }

}

运行结果

D:\java\jdk-11.0.11\bin\java.exe "-javaagent:D:\IntelliJ IDEA 2020.1.1\lib\idea_rt.jar=6813:D:\IntelliJ IDEA 2020.1.1\bin" -Dfile.encoding=UTF-8 -classpath E:\WHT\Project\Java\DesignPattern\out\production\DesignPattern com.atguigu.singleton.type3.SingletonTest03
true
instance.hashCode=2083562754
instance2.hashCode=2083562754

Process finished with exit code 0
优缺点说明

  1. 起到了Lazy Loading的效果，但是只能在单线程下使用。

  2. 如果在多线程下，一个线程进入了if (singleton == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以在多线程环境下不可使用这种方式。

  3. 结论：在实际开发中，不要使用这种方式。

4 懒汉式(线程安全，同步方法)

代码演示

package com.atguigu.singleton.type4;

/**
 * @author WHT
 * @create 2021-07-25 8:27
 */
public class SingletonTest04 {
    public static void main(String[] args) {
        // 测试
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2); // true
        System.out.println("instance.hashCode=" + instance.hashCode());
        System.out.println("instance2.hashCode=" + instance2.hashCode());
    }
}


// 懒汉式(线程安全，同步方法)
class Singleton {

    //1. 构造器私有化, 外部不能new
    private Singleton() {

    }

    //2.本类内部创建对象实例
    private static Singleton instance;

    //3.提供一个静态的公有方法，加入同步处理的代码，解决线程安全问题
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }

}

运行结果

D:\java\jdk-11.0.11\bin\java.exe "-javaagent:D:\IntelliJ IDEA 2020.1.1\lib\idea_rt.jar=7314:D:\IntelliJ IDEA 2020.1.1\bin" -Dfile.encoding=UTF-8 -classpath E:\WHT\Project\Java\DesignPattern\out\production\DesignPattern com.atguigu.singleton.type4.SingletonTest04
true
instance.hashCode=2083562754
instance2.hashCode=2083562754

Process finished with exit code 0
优缺点说明

  1. 解决了线程不安全问题。

  2. 效率太低了，每个线程在想获得类的实例时候，执行getInstance()方法都要进行同步。而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接return就行了。方法进行同步效率太低。

  3. 结论：在实际开发中，不推荐使用这种方式。

5 懒汉式(线程安全，同步代码块)

代码演示

package com.atguigu.singleton.type5;

/**
 * @author WHT
 * @create 2021-07-25 8:27
 */
public class SingletonTest05 {
    public static void main(String[] args) {
        // 测试
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2); // true
        System.out.println("instance.hashCode=" + instance.hashCode());
        System.out.println("instance2.hashCode=" + instance2.hashCode());
    }
}


// 懒汉式(线程安全，同步代码块)
class Singleton {

    //1. 构造器私有化, 外部不能new
    private Singleton() {

    }

    //2.本类内部创建对象实例
    private static Singleton instance;

    //3.提供一个静态的公有方法，加入同步处理的代码，解决线程安全问题
    public static Singleton getInstance() {
        if (instance == null) {
        	synchronized (Singleton.class) {
            	instance = new Singleton();
            }
        }
        return instance;
    }

}

运行结果

D:\java\jdk-11.0.11\bin\java.exe "-javaagent:D:\IntelliJ IDEA 2020.1.1\lib\idea_rt.jar=8805:D:\IntelliJ IDEA 2020.1.1\bin" -Dfile.encoding=UTF-8 -classpath E:\WHT\Project\Java\DesignPattern\out\production\DesignPattern com.atguigu.singleton.type5.SingletonTest05
true
instance.hashCode=2083562754
instance2.hashCode=2083562754

Process finished with exit code 0
优缺点说明

  1. 这种方式，本意是想对第四种实现方式的改进，因为前面同步方法效率太低，改为同步产生实例化的代码块。

  2. 但是这种同步并不能起到线程同步的作用。跟第3种实现方式遇到的情形一致，假如一个线程进入了if (singleton == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。

  3. 结论：在实际开发中，不能使用这种方式。

6 双重检查

代码演示

package com.atguigu.singleton.type6;

/**
 * @author WHT
 * @create 2021-07-25 8:27
 */
public class SingletonTest06 {
    public static void main(String[] args) {
        // 测试
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2); // true
        System.out.println("instance.hashCode=" + instance.hashCode());
        System.out.println("instance2.hashCode=" + instance2.hashCode());
    }
}


// 双重检查
class Singleton {

    //1. 构造器私有化, 外部不能new
    private Singleton() {

    }

    //2.本类内部创建对象实例
    private static volatile Singleton instance;

    //3.提供一个静态的公有方法，加入双重检查的代码，解决线程安全问题，同时解决懒加载问题，同时保证了效率
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }

}

运行结果

D:\java\jdk-11.0.11\bin\java.exe "-javaagent:D:\IntelliJ IDEA 2020.1.1\lib\idea_rt.jar=9766:D:\IntelliJ IDEA 2020.1.1\bin" -Dfile.encoding=UTF-8 -classpath E:\WHT\Project\Java\DesignPattern\out\production\DesignPattern com.atguigu.singleton.type6.SingletonTest06
true
instance.hashCode=2083562754
instance2.hashCode=2083562754

Process finished with exit code 0
优缺点说明

  1. Double-Check概念是多线程开发中常使用到的，如代码中所示，我们进行了两次 if (singleton == null) 检查，这样就可以保证线程安全了。

  2. 这样，实例化代码只用执行一次，后面再次访问时，判断 if (singleton == null)，如果 singleton != null，直接return实例化对象，也避免的反复进行方法同步。

  3. 线程安全；延迟加载；效率较高。

  4. 结论：在实际开发中，推荐使用这种单例设计模式。

7 静态内部类

代码演示

package com.atguigu.singleton.type7;

/**
 * @author WHT
 * @create 2021-07-25 8:27
 */
public class SingletonTest07 {
    public static void main(String[] args) {
        // 测试
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2); // true
        System.out.println("instance.hashCode=" + instance.hashCode());
        System.out.println("instance2.hashCode=" + instance2.hashCode());
    }
}


// 静态内部类方法，推荐使用
class Singleton {

    private static volatile Singleton instance;

    //1. 构造器私有化, 外部不能new
    private Singleton() {

    }

    //2.写一个静态内部类，该类中有一个静态属性Singleton
    private static class SingletonInstance {
        private static final Singleton INSTANCE = new Singleton();
    }

    //3.提供一个静态的公有方法，直接返回SingletonInstance.INSTANCE
    public static synchronized Singleton getInstance() {

        return SingletonInstance.INSTANCE;
    }

}

运行结果

D:\java\jdk-11.0.11\bin\java.exe "-javaagent:D:\IntelliJ IDEA 2020.1.1\lib\idea_rt.jar=10270:D:\IntelliJ IDEA 2020.1.1\bin" -Dfile.encoding=UTF-8 -classpath E:\WHT\Project\Java\DesignPattern\out\production\DesignPattern com.atguigu.singleton.type7.SingletonTest07
true
instance.hashCode=1239731077
instance2.hashCode=1239731077

Process finished with exit code 0
优缺点说明

  1. 这种方式采用了类装载的机制来保证初始化实例时只有一个线程。

  2. 静态内部类方式在Singleton类被装载时并不会立即实例化，而是在需要实例化时，调用getInstance方法，才会装载SingletonInstance类，从而完成Singleton的实例化。

  3. 类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。

  4. 优点：避免了线程不安全，利用静态内部类特点实现延迟加载，效率高。

  5. 结论：推荐使用。

8 枚举

代码演示

package com.atguigu.singleton.type8;

/**
 * @author WHT
 * @create 2021-07-25 8:27
 */
public class SingletonTest08 {
    public static void main(String[] args) {
        // 测试
        Singleton instance = Singleton.INSTANCE;
        Singleton instance2 = Singleton.INSTANCE;
        System.out.println(instance == instance2); // true
        System.out.println("instance.hashCode=" + instance.hashCode());
        System.out.println("instance2.hashCode=" + instance2.hashCode());

        instance.sayOk();
    }
}


// 使用枚举，可以实现单例模式，推荐使用
enum Singleton {
    INSTANCE;
    public void sayOk() {
        System.out.println("ok~");
    }
}

运行结果

D:\java\jdk-11.0.11\bin\java.exe "-javaagent:D:\IntelliJ IDEA 2020.1.1\lib\idea_rt.jar=11117:D:\IntelliJ IDEA 2020.1.1\bin" -Dfile.encoding=UTF-8 -classpath E:\WHT\Project\Java\DesignPattern\out\production\DesignPattern com.atguigu.singleton.type8.SingletonTest08
true
instance.hashCode=2083562754
instance2.hashCode=2083562754
ok~

Process finished with exit code 0
优缺点说明

  1. 借助JDK1.5中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。

  2. 这种方式是Effective Java作者Josh Bloch 提倡的方式。

  3. 结论：推荐使用。

单例模式在JDK 应用的源码分析

  1. JDK中，java.lang.Runtime 就是经典的单例模式(饿汉式)。

  2. 源码分析

public class Runtime {
    private static final Runtime currentRuntime = new Runtime();

    private static Version version;

    /**
     * Returns the runtime object associated with the current Java application.
     * Most of the methods of class {@code Runtime} are instance
     * methods and must be invoked with respect to the current runtime object.
     *
     * @return  the {@code Runtime} object associated with the current
     *          Java application.
     */
    public static Runtime getRuntime() {
        return currentRuntime;
    }

    /** Don't let anyone else instantiate this class */
    private Runtime() {}

单例模式注意事项和细节说明

  1. 单例模式保证了 系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能。

  2. 当想实例化一个单例类的时候，必须要记住使用相应的获取对象的方法，而不是使用new。

  3. 单例模式使用的场景：需要频繁的进行创建和销毁的对象、创建对象时耗时过多或耗费资源过多(即：重量级对象)，但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象(比如数据源、session工厂等)。

淘淘图兔兔呀
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
尚硅谷Java基础实战——Bank项目下载地址
12-29
"尚硅谷Java基础实战——Bank项目"是一个旨在帮助初学者深入理解Java编程概念并实践应用的项目。这个项目以银行系统为背景，涵盖了诸多Java基础知识点，包括类与对象、数据类型、控制结构、异常处理、集合框架、IO流...
尚硅谷设计模式学习(3)---[单例模式]
从零开始的异世界JAVA学习
09-23 532
????????????尚硅谷传送门==>B站尚硅谷Java设计模式 ❤❤❤感谢尚硅谷❤❤❤ ????????????最近开始计划学习一下设计模式了,加油!!! 目录单例模式????1.饿汉式(静态常量版)????2.饿汉式(静态代码块版)????3.懒汉式(线程不安全版)????4.懒汉式(线程安全之同步方法版)????5.懒汉式(线程安全之同步代码块版)????6.双重检查版????7.静态内部类版????8.枚举版 单例模式 一个类把自己的构造方法隐藏起来; 这个类仅存在一个对象实例
Java设计模式系列之工厂模式精讲
zjjcchina的博客
07-10 104
上面是生活的案例，在学习Java的过程中，同样不少地方就出现了工程模式的思想，比如Spring中Bean的加载和创建都是通过工厂模式的思想，还有就是MyBatis，相信大家有印象的话，在开发MyBatis时，其实最核心的操作数据的对象就是SqlSession，而这个对象的创建就是通过工厂模式的思想，大家不妨回忆一下，怎么得到一个SqlSession，是不是通过一个叫做SqlSessionFactory的工厂类，并且调用它的openSession()方法进而返回的一个SqlSession实例对象。
java设计模式（二）——单例设计模式
裴小霞的博客
11-28 171
单例设计模式介绍 所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法(静态方法)。 比如Hibernate的SessionFactory，它充当数据存储源的代理，并负责创建Session对象。SessionFactory并不是轻量级的，一般情况下，一个项目通常只需要一个SessionFactory...
Java-笔记14-复习
weixin_33904756的博客
05-24 319
1. static 修饰的属性，相较于实例变量，有哪些特别之处(>=3点) 随着类的加载而加载；早于对象的创建；只要权限允许，可以通过”对象.static属性”的方式进行调用；存在于方法区的静态域 2. final 可以用来修 饰哪些结构，分别表示什么意思 * 1. final可以用来修饰的结构：类、方法、变量 * * 2. final 用来修饰一个类:此类不...
Java中的单例模式
SakuraMG的博客
12-09 139
设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。设计模式就像是经典的棋谱，不同的棋局我们使用不同的棋谱，免去我们自己再思考和摸索。Java中公认的有23种设计模式。二、什么是单例设计模式？单例，就是指单个的实例。单例设计模式就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。单例模式有两种方式：（1）饿汉式；（2）懒汉式。
尚硅谷_韩顺平_图解Java设计模式
10-09
后续章节会继续深入探讨其他六大原则，以及23种经典设计模式，如工厂模式、单例模式、建造者模式、观察者模式等。这些模式是软件开发中的常用工具，掌握它们对于提升软件工程的实践能力至关重要。此外，这份笔记还会...
Java设计模式笔记-尚硅谷
10-05
Java设计模式笔记-尚硅谷
尚硅谷 韩顺平 图解Java设计模式.txt
07-12
韩老师用java语言讲的设计模式通俗易懂，支持韩老师，一直看你的讲课，点赞。
尚硅谷设计模式源码笔记课件.zip
08-04
1) 内容包括: 设计模式七大原则(单一职责、接口隔离、依赖倒转、里氏替换、开闭原则、迪米特法则、合成复用)、UML类图(类的依赖、泛化和实现、类的关联、聚合和组合) 23种设计模式包括：创建型模式：单例模式(8种...
Java之23种设计模式解析_尚硅谷_宋红康
12-14
Java之23种设计模式解析_尚硅谷_宋红康
( [尚硅谷]_宋红康_Java 之23种设计模式解析.pdf )
05-11
( [尚硅谷]_宋红康_Java 之23种设计模式解析.pdf )
Java设计模式学习-----设计模式的七大原则
m0_48577216的博客
03-22 228
Java设计模式学习-----尚硅谷java设计模式课程 1、设计模式的七大原则 设计模式常用的七大原则有: 1） 单一职责原则 2）接口隔离原则 3）依赖倒转原则 4）里氏替换原则 5）开闭原则 6）迪米特法则 7）合成复用原则 1.1 单一职责原则 基本介绍： 对类来说，即一个类只能负责一项职责，如类 A 负责两个不同职责：职责 1，职责 2。当职责 1 需求变更而改变 A 时，可能造成职责 2 执行错误，所以需要将类 A 的粒度分解为 A1，A2 A 注意细节： 1）降低类的复杂度，一个类只负责一
JAVA学习日记:JDBC(6)
SIESTA030的博客
11-21 145
今天我的所学内容： 1.元数据 2.如何获取结果集以及数据库产品的元数据 元数据： MetaData，定义数据的数据。 抽象出来就好比我们定义这个水果叫苹果，我们就是苹果的元数据。（只不过我们和苹果都不是数据罢了）。 如何获取结果集以及数据库产品的元数据： DatabaseMetaData接口： 用于描述和封装数据库的元数据的接口。 它的对象由Connection接口中的getMetaData()方法获得。 方法： getDatabasePr
JAVASE学习总结（10）
qq_61551764的博客
12-05 228
生命周期
设计模式 - 单例模式
saienenen的博客
12-22 229
1. 单例模式定义 单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。这些应用都或多或少具有资源管理器的功能。每台计算机可以有若干个打印机，但只能有一个Printer Spooler，以避免两个打印作业同时输出到打印机中。每台计算机可以有若干通信端口，系统应当集中管理这些通信端口，以避免一个通信端口同时被两个请求同时调用。总之，选择单例模式就是为了避免不一致状态，避免政出多头 2.单例模式特点
Java单例设计模式（学习尚硅谷设计模式）
weixin_46011971的博客
03-18 192
单例设计模式介绍 所谓类的单例设计模式，就是 采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例， 并且该类只提供一个取得其对象实例的方法(静态方法)。 比如 Hibernate 的 SessionFactory，它充当数据存储源的代理，并负责创建 Session 对象。SessionFactory 并不是 轻量级的，一般情况下，一个项目通常只需要一个 SessionFactory...
java遍历文件夹及其子文件夹下的所有文件，讲文件路径输出到控制台
weixin_33387378的博客
03-18 2162
package com.zpc.tet.java; import java.io.File; /** * @Author timor * @Date 2019/3/18 */ public class FileTest { public static void main(String[] args) { String filePath = "H:\\图片"; ...
韩顺平图解Java设计模式
嘟爷java超神学堂
08-27 2941
今天分享一部设计模式相关的视频，好好复习帮助还是很大的。课程介绍1) 优秀的程序应该是这样的：阅读时，感觉很优雅；新增功能时，感觉很轻松；运行时，感觉很快速,这就需要设计...
尚硅谷__图解java设计模式.pdf
最新发布
07-31
尚硅谷是一家提供职业教育培训的机构，他们出版了《图解Java设计模式》这本书。 这本书主要介绍了Java设计模式的内容。设计模式是一种在软件设计中常用的解决问题的方法，它提供了一套通用的解决方案，帮助我们在...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

淘淘图兔兔呀

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值