厚积薄发打卡Day28 ：狂神说Java之彻底玩转单例设计模式

最新推荐文章于 2021-06-14 17:56:37 发布
最新推荐文章于 2021-06-14 17:56:37 发布
阅读量315 收藏 5
点赞数 1
分类专栏： Java基础进阶 设计模式 狂神说Java学习 文章标签： java 设计模式 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42191980/article/details/114367254
版权

前言：

学习视频来源：【狂神说Java】JUC并发编程最新版通俗易懂

本文承接上篇博客：狂神说Java之从JMM 到 volatile

这节设计模式是在JUC穿插讲解的，但又是十分基础与重要，因此特地单拎出来好好学习。

开整 🚀🚀🚀

18.彻底玩转单例模式

参考文章：
菜鸟教程-单例模式
深入理解设计模式（一）：单例模式
彻底玩转单例模式

单例模式：

简介：

单例模式是一种常用的软件设计模式，其定义是单例对象的类只能允许一个实例存在。

注意：

  • 1、单例类只能有一个实例。
  • 2、单例类必须自己创建自己的唯一实例。
  • 3、单例类必须给所有其他对象提供这一实例。

许多时候整个系统只需要拥有一个的全局对象，这样有利于我们协调系统整体的行为。

适用场景：

  • 1.需要生成唯一序列的环境
  • 2.需要频繁实例化然后销毁的对象。
  • 3.创建对象时耗时过多或者耗资源过多，但又经常用到的对象。
  • 4.方便资源相互通信的环境

构建步骤：

  1. 将该类的构造方法定义为私有方法
    • 这样其他处的代码就无法通过调用该类的构造方法来实例化该类的对象，只有通过该类提供的静态方法来得到该类的唯一实例；
  2. 在该类内提供一个静态实例化方法
    • 当我们调用这个方法时，如果类持有的引用不为空就返回这个引用，
    • 如果类保持的引用为空就创建该类的实例并将实例的引用赋予该类保持的引用。

优缺点：

优点：

  • 在内存中只有一个对象，节省内存空间；
  • 避免频繁的创建销毁对象，可以提高性能；
  • 避免对共享资源的多重占用，简化访问；
  • 为整个系统提供一个全局访问点。

缺点：

  • 不适用于变化频繁的对象；

  • 滥用单例将带来一些负面问题，如为了节省资源将数据库连接池对象设计为的单例类，可能会导致共享连接池对象的程序过多而出现连接池溢出；

  • 如果实例化的对象长时间不被利用，系统会认为该对象是垃圾而被回收，这可能会导致对象状态的丢失；

饿汉式单例模式：

​ 饿汉式：饥饿的人，看到食物就上来抢。对应在代码中，在类加载时就立刻实例化。

public class HungrySingleton {
   
    //假如类中存在这样的空间开辟的操作：
    //使用饿汉式时，不管用不用，上来就给你开了再说，造成空间浪费。
    private byte[] data1 = new byte[1024*1024];
    private byte[] data2 = new byte[1024*1024];
    private byte[] data3 = new byte[1024*1024];
    private byte[] data4 = new byte[1024*1024];

    //1、私有构造器
    private HungrySingleton(){

    }
    //2、类的内部创建对象
    private final static HungrySingleton HUNGRYSINGLE = new HungrySingleton();

    //3、向外暴露一个静态的公共方法。 getInstance
    public static HungrySingleton getInstance(){
        return HUNGRYSINGLE;
    }
    public static void main(String[] args) {
        //单线程：
        HungrySingleton instance1 = HungrySingleton.getInstance();
        HungrySingleton instance2 = HungrySingleton.getInstance();
        System.out.println(instance1 == instance2);//true
        System.out.println("------------");
        //多线程：
        new Thread(()->{
            HungrySingleton instance_A = HungrySingleton.getInstance();
            System.out.println(instance_A);
            //com.kuangstudy.Singleton.HungrySingleton@626213bf
        }).start();
        new Thread(()->{
            HungrySingleton instance_B = HungrySingleton.getInstance();
            System.out.println(instance_B);
            //com.kuangstudy.Singleton.HungrySingleton@626213bf
        }).start();
    }
}

小结：

  • 优点：
    1. 基于 classloader 机制避免了多线程的同步问题，在类装载的时候就完成实例化。避免了线程同步问题==>线程安全。
    2. 没有加锁，执行效率会提高。
    3. 简单好用。
  • 缺点：
    1. 在类装载的时候就完成实例化，没有达到Lazy Loading的效果。如果从始至终从未使用过这个实例，则会造成内存的浪费。

懒汉式单例模式：

非线程安全：

public class LazySingleton {

    //1.私有化构造函数
    private LazySingleton() {
        System.out.println(Thread.currentThread().getName()+" ->OK");
    }

    //2.创建对象（容器）
    private static LazySingleton lazyMan ;

    //3.对外提供静态实例化方法，判断在对象为空的时候创建
    public static LazySingleton getInstance(){
        //用的时候再加载
        if (lazyMan == null) {
            lazyMan = new LazySingleton();
        }
        return lazyMan;
    }
    //测试单线程下懒汉式单例
    public static void main(String[] args) {
        LazySingleton instance1 = LazySingleton.getInstance();
        LazySingleton instance2 = LazySingleton.getInstance();
        //实例化两个只出现：main ->OK 
        System.out.println(instance1);//com.kuangstudy.Singleton.LazySingleton@61bbe9ba
        System.out.println(instance2);//com.kuangstudy.Singleton.LazySingleton@61bbe9ba
    }
}
小结

  • 这种方式是最基本的实现方式，这种实现最大的问题就是不支持多线程。因为没有加锁 synchronized，所以严格意义上它并不算单例模式。

  • 这种方式 lazy loading 很明显，不要求线程安全，在多线程不能正常工作。

    public class LazySingleton {

    //1.私有化构造函数
    private LazySingleton() {
        System.out.println(Thread.currentThread().getName()+" ->OK");
    }

    //2.创建对象（容器）
    private static LazySingleton lazyMan ;

    //3.对外提供静态实例化方法，判断在对象为空的时候创建
    public static LazySingleton getInstance(){
        //用的时候再加载
        if (lazyMan == null) {
            lazyMan = new LazySingleton();
        }
        return lazyMan;
    }
    //开启多条线程实例化LazySingleton
    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            //            new Thread(()->{LazySingleton.getInstance();}).start();
            new Thread(LazySingleton::getInstance).start();
        }
    }
    //结果实例化超过1个对象：(不唯一)
    /*

    Thread-0 ->OK
    Thread-3 ->OK
    Thread-2 ->OK
    Thread-1 ->OK

    */
}

线程安全：

public class LazySingletonWithDCL {

    //1.私有化构造函数
    private LazySingletonWithDCL() {
        System.out.println(Thread.currentThread().getName() + " ->OK");
    }

    //2.创建对象（容器）
    //    private static LazySingletonWithDCL lazyMan ;
    //5.new 不是一个原子性操作：
    private volatile static LazySingletonWithDCL lazyMan;

    //3.对外提供静态实例化方法
    //4.为保证线程安全，需要上锁
    public static LazySingletonWithDCL getInstance() {
        if (lazyMan == null) {
            synchronized (LazySingletonWithDCL.class) {
                if (lazyMan == null) {
                    lazyMan = new LazySingletonWithDCL();
                }
            }
        }
        return lazyMan;
    }

    //开启多条线程实例化LazySingletonWithDCL
    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            //            new Thread(()->{LazySingletonWithDCL.getInstance();}).start();
            new Thread(LazySingletonWithDCL::getInstance).start();
        }
    }
}
问题：
  1. 为什么要synchronized (LazySingletonWithDCL.class)而不是对方法加锁？

    相关博客：Synchronized方法锁、对象锁、类锁区别 (精)

    简单回答：

    1. synchronized 重量级锁，锁的范围越小越好，class只有一个，而方法会每次都执行，因此为了提高效率，锁对象而不是锁方法。
  2. new对象的过程为什么不是一个原子性操作？

    相关博客：new一个对象竟然不是原子操作？

    实锤 new 对象不是原子性操作，会执行以下操作：

    1. 分配内存空间
    2. 执行构造方法，初始化对象
    3. 把对象指向空间

    实践出真知：

    1. 这是原子类AtomicInteger.getAndIncrement()方法，反编译后：
      在这里插入图片描述

    2. public class TestNew {

    private static int num = 0;

    public static void main(String[] args) {
        TestNew testNew = new TestNew();
    }
    public void add(){
        num++;
    };
}

      反编译后：

      在这里插入图片描述

小结：
  • 双检锁/双重校验锁（DCL，即 double-checked locking）
    • 这种方式采用双锁机制，安全且在多线程情况下能保持高性能。getInstance() 的性能对应用程序很关键。
  • 这样，实例化代码只用执行一次，后面再次访问时，判断 if(lazyMan == null)，直接return实例化对象，也避免的反复进行方法同步.
  • 线程安全；延迟加载；效率较高

反射破坏单例：

在Java进阶中学习过非常暴力的获取类的方式：反射（详见：注解与反射）

因此对于在单例模式中私有的方法，我们可以通过反射进行破解：

  1. 对DCL饿汉式单例进行破解：

实力诠释再多的🔒也抵不住反射的暴力破解

public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
    LazySingletonWithDCL instance = LazySingletonWithDCL.getInstance();
    //利用反射创建对象
    //获取无参构造
    Constructor<LazySingletonWithDCL> declaredConstructor = LazySingletonWithDCL.class.getDeclaredConstructor(null);
    //开放权限
    declaredConstructor.setAccessible(true);
    LazySingletonWithDCL instance_withReflect = declaredConstructor.newInstance();

    System.out.println(instance); //LazySingletonWithDCL@61bbe9ba
    System.out.println(instance_withReflect);  //LazySingletonWithDCL@610455d6
    System.out.println(instance == instance_withReflect);  //false
}

  1. 单例模式增加校验反击：

    • 因为反射走的是无参构造，可以在构造函数中进行判断
public class LazySingletonWithDCL {

    //1.私有化构造函数
    //6.增加对反射的判断
    private LazySingletonWithDCL() {
        synchronized (LazySingletonWithDCL.class){
            //6.1如果此时已经有实例，阻止反射创建
            if (lazyMan != null){
                throw new RuntimeException("不要试图通过反射破解单例");
            }
        }
        System.out.println(Thread.currentThread().getName() + " ->OK");
    }

    //2.创建对象（容器）
    //    private static LazySingletonWithDCL lazyMan ;
    //5.new 不是一个原子性操作：
    private volatile static LazySingletonWithDCL lazyMan;

    //3.对外提供静态实例化方法
    //4.为保证线程安全，需要上锁
    public static LazySingletonWithDCL getInstance() {
        if (lazyMan == null) {
            synchronized (LazySingletonWithDCL.class) {
                if (lazyMan == null) {
                    lazyMan = new LazySingletonWithDCL();
                }
            }
        }
        return lazyMan;
    }

    public static void main(String[] args) throws Exception {
        LazySingletonWithDCL instance = LazySingletonWithDCL.getInstance();
        System.out.println(instance); //创建成功: LazySingletonWithDCL@61bbe9ba
        //利用反射创建对象
        //获取无参构造
        Constructor<LazySingletonWithDCL> declaredConstructor = LazySingletonWithDCL.class.getDeclaredConstructor(null);
        //开放权限
        declaredConstructor.setAccessible(true);
        LazySingletonWithDCL instance_withReflect = declaredConstructor.newInstance();

        System.out.println(instance_withReflect);  //LazySingletonWithDCL@610455d6
        System.out.println(instance == instance_withReflect);  //false
    }
}

main ->OK
com.kuangstudy.Singleton.LazySingletonWithDCL@61bbe9ba
Exception in thread "main" java.lang.reflect.InvocationTargetException
	at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
	at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62)
	at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
	at java.lang.reflect.Constructor.newInstance(Constructor.java:423)
	at com.kuangstudy.Singleton.LazySingletonWithDCL.main(LazySingletonWithDCL.java:60)
Caused by: java.lang.RuntimeException: 不要试图通过反射破解单例
	at com.kuangstudy.Singleton.LazySingletonWithDCL.<init>(LazySingletonWithDCL.java:20)
	... 5 more

只创建出了一个实例，并成功拦截了 通过反射创建对象的行为

  1. 反射再扳回一城

上述例子2中是用一个饿汉+反射创建，但如果两个对象都是用反射创建呢？

public static void main(String[] args) throws Exception {
    //获取类模板class
    Constructor<LazySingletonWithDCL> declaredConstructor = LazySingletonWithDCL.class.getDeclaredConstructor(null);
    //开放权限
    declaredConstructor.setAccessible(true);
    //通过空参创建实例
    LazySingletonWithDCL instance_withReflect1 = declaredConstructor.newInstance();
    LazySingletonWithDCL instance_withReflect2 = declaredConstructor.newInstance();
    System.out.println(instance_withReflect1);//LazySingletonWithDCL@61bbe9ba
    System.out.println(instance_withReflect2);//LazySingletonWithDCL@610455d6
    System.out.println(instance_withReflect1 == instance_withReflect2);//false
}

结果非常明显：再一次破坏了单例模式

  1. 懒汉单例再度防守：

    （加入标志位）

    在空参方法里运用标志位，因为实例化对象需要获取类模板：

    • 当获取了一次类模板之后，就把标志位flag置反。
    • 等一次通过反射获取类模板创建对象的时候便能抛异常
public class LazySingletonWithDCL {

    //7.加入标志位，防止多个反射破坏单例
    private static boolean flag = true;

    //1.私有化构造函数
    //6.增加对反射的判断
    private LazySingletonWithDCL() {
        synchronized (LazySingletonWithDCL.class){
            if (flag){
                flag = false;
            }else {
                //                //6.1如果此时已经有实例，阻止反射创建
                //                if (lazyMan != null){
                throw new RuntimeException("不要试图通过反射破解单例");
                //                }
            }

        }
        System.out.println(Thread.currentThread().getName() + " ->OK");
    }

    //2.创建对象（容器）
    //    private static LazySingletonWithDCL lazyMan ;
    //5.new 不是一个原子性操作：
    private volatile static LazySingletonWithDCL lazyMan;

    //3.对外提供静态实例化方法
    //4.为保证线程安全，需要上锁
    public static LazySingletonWithDCL getInstance() {
        if (lazyMan == null) {
            synchronized (LazySingletonWithDCL.class) {
                if (lazyMan == null) {
                    lazyMan = new LazySingletonWithDCL();
                }
            }
        }
        return lazyMan;
    }

    public static void main(String[] args) throws Exception {
        //获取类模板class
        Constructor<LazySingletonWithDCL> declaredConstructor = LazySingletonWithDCL.class.getDeclaredConstructor(null);
        //开放权限
        declaredConstructor.setAccessible(true);
        //通过空参创建实例
        LazySingletonWithDCL instance_withReflect1 = declaredConstructor.newInstance();
        System.out.println(instance_withReflect1);//LazySingletonWithDCL@61bbe9ba

        LazySingletonWithDCL instance_withReflect2 = declaredConstructor.newInstance();
        System.out.println(instance_withReflect2);
        //报错：java.lang.RuntimeException: 不要试图通过反射破解单例
        System.out.println(instance_withReflect1 == instance_withReflect2);
    }
}

由运行结果可见，保住了单例模式。

至此，用过反射调用空参实例化的方法被标志位掐断

  1. 反射再度进攻

    （你既然设置了标志位，那我就来破坏标志位）

public static void main(String[] args) throws Exception{
    //获取标志位
    Field flag = LazySingletonWithDCL.class.getDeclaredField("flag");
    flag.setAccessible(true);

    //获取类模板class
    Constructor<LazySingletonWithDCL> declaredConstructor = LazySingletonWithDCL.class.getDeclaredConstructor(null);
    //开放权限
    declaredConstructor.setAccessible(true);
    //通过空参创建实例
    LazySingletonWithDCL instance_withReflect1 = declaredConstructor.newInstance();
    System.out.println(instance_withReflect1);//LazySingletonWithDCL@61bbe9ba

    //在获取并使用完类模板后，重新设置flag值：
    flag.set(instance_withReflect1,true);
    LazySingletonWithDCL instance_withReflect2 = declaredConstructor.newInstance();
    System.out.println(instance_withReflect2);

}

此时：

main ->OK
com.kuangstudy.Singleton.LazySingletonWithDCL@61bbe9ba
main ->OK
com.kuangstudy.Singleton.LazySingletonWithDCL@511d50c0

可以看到单例模式再一次被破坏了

  1. 该如何真正确保单例？

解铃还须系铃人，那我们就从单例入手分析一波：

查看反射中newInstance()方法

在这里插入图片描述

否则会报异常：

 IllegalArgumentException("Cannot reflectively create enum objects")

枚举保证单例：

  1. 构造枚举尝试单例模式：

public enum EnumSingleton {

    INSTANCE;

    public EnumSingleton getInstance(){
        return INSTANCE;
    }
}

class Test{

    public static void main(String[] args) {
        EnumSingleton instance1 = EnumSingleton.INSTANCE;
        EnumSingleton instance2 = EnumSingleton.INSTANCE;
        System.out.println(instance1.hashCode());//1639705018
        System.out.println(instance2.hashCode());//1639705018
    }
}

简单代码创建一个实例，针不戳

  1. 尝试用反射破坏枚举的单例模式

public static void main(String[] args) throws Exception {
    //instance1正常获取
    EnumSingleton instance1 = EnumSingleton.INSTANCE;
    System.out.println(instance1); //INSTANCE

    //instance2通过反射获取：
    //1.获取其空参
    Constructor<EnumSingleton> constructor = EnumSingleton.class.getDeclaredConstructor(null);
    //2.打开权限：
    constructor.setAccessible(true);
    //3.实例化对象：
    EnumSingleton instance2 = constructor.newInstance();
    System.out.println(instance2);
}

结果：

  1. instance1 正常实例化

  2. 但是在通过反射的时候报了错：

    在这里插入图片描述

    找不到EnumSingleton 的空参构造？

    这就奇怪了。

    idea查看class文件也是只有空参构造：

    在这里插入图片描述

    用javap -p -c .\EnumSingleton.class口令也是看到空参：

    在这里插入图片描述

  3. 探究枚举类的构造函数：

    上述方法行不通后得运用更加专业的工具进行反编译：

    使用jad工具

    使用命令：

     .\jad.exe -sjava .\EnumSingleton.class

    将class成功反编译为Java文件：

    // Decompiled by Jad v1.5.8e2. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://kpdus.tripod.com/jad.html
// Decompiler options: packimports(3) 
// Source File Name:   EnumSingleton.java

package com.kuangstudy.Singleton;


public final class EnumSingleton extends Enum
{

    public static EnumSingleton[] values()
    {
        return (EnumSingleton[])$VALUES.clone();
    }

    public static EnumSingleton valueOf(String name)
    {
        return (EnumSingleton)Enum.valueOf(com/kuangstudy/Singleton/EnumSingleton, name);
    }

    private EnumSingleton(String s, int i)
    {
        super(s, i);
    }

    public EnumSingleton getInstance()
    {
        return INSTANCE;
    }

    public static final EnumSingleton INSTANCE;
    private static final EnumSingleton $VALUES[];

    static 
    {
        INSTANCE = new EnumSingleton("INSTANCE", 0);
        $VALUES = (new EnumSingleton[] {
            INSTANCE
        });
    }
}

    此时我们发现枚举类内部其实是一个有参的构造函数。

    此时我们修改代码：

     //1.获取其有参构造：
        Constructor<EnumSingleton> constructor = EnumSingleton.class.getDeclaredConstructor(String.class,int.class);

    这时候我们就能如愿得到想要的报错了 （？怎么听起来怪怪的）

    INSTANCE
Exception in thread "main" java.lang.IllegalArgumentException: Cannot reflectively create enum objects
	at java.lang.reflect.Constructor.newInstance(Constructor.java:417)
	at com.kuangstudy.Singleton.Test.main(EnumSingleton.java:40)

    小结：

    用枚举构建单例模式：

    特点属性
    JDK 版本JDK1.5 起
    是否 Lazy 初始化否
    是否多线程安全是
    实现难度易
  • 这种实现方式还没有被广泛采用，但这是实现单例模式的最佳方法。它更简洁，自动支持序列化机制，绝对防止多次实例化。
  • 这种方式是 Effective Java 作者 Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化。不过，由于 JDK1.5 之后才加入 enum 特性，用这种方式写不免让人感觉生疏，在实际工作中，也很少用。
    不能通过 reflection attack 来调用私有构造方法。

单例模式在JDK中的应用：

在Runtime类中使用了单例模式（不过是俄汉式）上代码：

public class Runtime {
    //2.类的内部创建对象
    private static Runtime currentRuntime = new Runtime();

    //3.开发对外的实例化方法
    public static Runtime getRuntime() {
        return currentRuntime;
    }

    //1.私有化构造方法
    private Runtime() {}

    ....
}
coolgwayne
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
基于狂神说Java的超市订单管理系统（SMBMS）设计源码
03-28
这是一个基于狂神说Java开发的超市订单管理系统（SMBMS），使用Java语言开发，包含113个文件。主要文件类型包括31个Java源文件、23个JavaScript文件、20个JSP文件、18个PNG图片文件、5个CSS文件、4个JPG图片文件、3...
狂神说Java设计模式
小小学渣的博客
10-06 385
1. 什么是设计模式？ 设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案，是一套被反复使用、多数人知晓、及经过分类编目的、代码设计经验的总结。使用设计模式是为了重用代码、让代码更容易被他人理解、保障代码的可靠性，可维护性。 2. 面向对象设计（OOP）七大原则 开闭原则：对扩展开放、对修改关闭 里式替换原则：继承需要修改父类的性质 依赖倒置原则：要面向接口编程、不要面向实现编程 针对接口编程的意思就是说，应当使用Java接口和抽象Java类进行变量的类型声明、参量的类型声明、方法的返回
【狂神说Java】设计模式----单例模式
pan_h1995的博客
06-03 2686
彻底玩转单例模式 恶汉式、DCL懒汉式 恶汉式： package com.ph.single; //恶汉使单利模式 public class Hungry { //可能会浪费空间，开辟了空间，却没有使用 private Hungry(){ } private final static Hungry HUNGRY = new Hungry(); public static Hungry getInstance(){ return HUNG
狂神JUC——单例模式
黄坤的博客
06-02 460
1.饿汉式 package com.company.singleton_pattern; //饿汉式（已经创建好，就等拿了,会浪费空间） public class Hungry { //构造器私有 private Hungry(){ } private static final Hungry hungry = new Hungry(); public static Hungry getInstance(){ return hungry; .
狂神说Java之设计模式
fggsgnhz的博客
03-31 1378
设计模式概述 设计模式：是一套用来提高代码可复用性，可维护性、可读性、稳健型以及安全性的解决方案 设计模式的本质：是面向对象设计原则的实际运用，是对类的封装、继承、多态以及类的关联关系和组合关系的充分理解。 设计模式的的基本要素：模式名称、问题、解决方案、效果 分类 创建型模式：（描述怎样去创建一个对象，创建和使用分离） 单例模式、工厂模式、抽象工厂模式、建造者模式、原型模式 结构型模式：（描述如何将类或对象安装某种类型组成更大的结构） 适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式
单例模式还能这样 ——致敬狂神
qq_38697228的博客
07-08 293
饥汉模式(积极加载) public class Hungry { byte[] byts1 = new byte[1024*1024]; byte[] byts2 = new byte[1024*1024]; byte[] byts3 = new byte[1024*1024]; byte[] byts4 = new byte[1024*1024]; private Hungry(){}//构造器私有化 private static Hungry instance = new Hungry()
狂神说java系列笔记（java基础+javaweb+ssm+微服务）全套
04-26
狂神说java系列笔记（java基础+javaweb+ssm+微服务）全套
kuangshen:狂神学java笔记仓库
05-10
kuangshen 狂神学java笔记仓库 源代码链接 csdn博客
狂神说java的笔记和源码.zip
05-16
狂神说java的笔记和源码 狂神说java的笔记和源码 狂神说java的笔记和源码 狂神说java的笔记和源码 狂神说java的笔记和源码 狂神说java的笔记和...
狂神说java MyBatis 笔记
12-31
狂神说java MyBatis 笔记
[狂神Java]设计模式——什么是设计模式
Jzandth的博客
09-10 429
创建型模式：描述怎么创建一个对象，并使得创建对象和使用对象分离，就是不在一个代码块里面 结构型模式：描述怎么来设计类的结构 行为型模式：描述类或对象之间怎么相互协作，去完成单个对象不能完成的任务     注意：我们学习设计模式主要就是学习设计模式的思想、它应用于哪些场景/能解决什么样的问题、它怎么使用     可以不全学，学现在主要用的就行 ...
创建型模式——狂神说java学习笔记三
weixin_43751396的博客
05-24 423
原文链接：公众号狂神说 视频教程[狂神说B站]: https://www.bilibili.com/video/BV1K54y197iS 如有侵权，联系立删 创建型模式 省去new的过程 单例模式、工厂模式、抽象工厂模式、建造者模式、原型模式 单例模式 饿汉单例模式 一上来就能把所有东西都加载 （1）一上来就加载对象； （2）可能造成内从空间的浪费 public class Hungry { private Hungry() { System.out.println("我是一个饿汉"); } //
Java 设计模式 05 适配器模式
qq_44815465的博客
09-13 82
本文总结于视频狂神说：狂神说java设计模式 适配器模式核心 当一个类需要使用到另外一个类的方法时，而这两个类之间并没有任何关系，如果一味的使用 new 对象的方式则非常冗余，所以需要一个适配器来拉近两者的关系，例如 B 类持有适配器对象，将 A 对象传入适配器中，让适配器调用 A 的方法。 假如：有一台电脑，网线，电脑和网线的接口不一样，这时候需要一个网线转接口来连接电脑和网线才能正常上网 代码实现： demo-1 【类适配模式】 类结构图 定义一个网线类 //网线类 public class NetL
厚积薄发打卡Day26：狂神说Java之JUC并发编程＜代码+笔记＞（上）
COOLGWAYNE_TECH_BLOG
02-28 1254
前言： 学习视频来源：【狂神说Java】JUC并发编程最新版通俗易懂 一个十分优秀且励志的技术大牛+Java讲师，十分推荐他的频道：遇见狂神说 ???????????? 至于为啥这篇文章不是”全网最全“了，是因为狂神自己总结了一份学习笔记哈哈，本文是根据学习资料自己总结，方便以后查漏补缺???? 狂神置顶评论： (置顶) 白漂有罪，拒绝白嫖，从点赞转发关注做起！ 文章同步在公众号：狂神说 （公众号日更，记得关注） 视频文档地址：https://gitee.com/kuangstudy/openclass
厚积薄发打卡Day64 ：【狂神 & bugstack】狂神JVM快速入门（下）＜GC机制与算法＞
COOLGWAYNE_TECH_BLOG
06-14 1253
视频学习：【狂神说Java】JVM快速入门篇 相关资料： 《深入理解Java虚拟机》第三版 漫画：什么是JVM的垃圾回收？ 非常简单易懂，十分推荐 bugstack虫洞栈——面经#27 实例查看回收过程 10. 实例验证GC 老是说GC，如何看到GC运行的实际效果？TALK IS CHEAP,SHOW ME THE CODE 举个例子：（例子来源：bugstack虫洞栈——面经#27） 测试代码： public class ReferenceCountingGC { public.
厚积薄发打卡Day25 ：狂神说Java之多线程详解＜全网最全(代码+笔记)＞
COOLGWAYNE_TECH_BLOG
02-17 683
厚积薄发打卡Day25 ：狂神说Java之多线程详解（全网最全_代码+笔记） 概述 课程大纲： 线程简介 线程实现（重点） 线程状态 线程同步（重点） 线程通信问题 高级主题 线程、进程、多线程 线程简介： 多任务： 现实中太多这样同时做多件事情的例子了，看起来是多个任务都在做，其实本质上我们的大脑在同一时间依旧只做了一件事情。 多线程： 原来是一条路，慢慢因为车太多了，道路堵塞，效率极低。为了提高使用的效率，能够充分利用道路，于是加了多个车道。从此，妈妈再也不用担心道路堵塞了。 程序 -&
厚积薄发打卡Day62 ：【狂神】狂神JVM快速入门（上）＜从JVM体系到native方法＞
COOLGWAYNE_TECH_BLOG
05-31 613
视频学习地址： 【狂神说Java】JVM快速入门篇 前言 先给大家看几道面试题？ 1、请你谈谈你对JVM的理解？Java8的虚拟机有什么更新？ 2、什么是OOM？什么是StackOverFlowError？有哪些方法分析？ 3、JVM的常用参数调优你知道哪些？ 4、内存快照抓取和MAT分析DUMP文件知道吗？ 5、堆里面的分区：Eden，Survival from to，老年代，各自的特点？ 6、GC的三种收集方法：标记清除，标记整理，复制算法的原理与特点，分别用在什么地方？ 唠叨几句 每一个.
厚积薄发打卡Day24 ：狂神说Java之注解与反射＜全网最全(代码+笔记)＞
COOLGWAYNE_TECH_BLOG
02-10 452
原视频地址： 【狂神说Java】注解和反射，强烈推荐大家学习 什么是注解 什么是注解？ Annotation是从JDK5.0开始引入的新技术. Annotation的作用： 不是程序本身，可以对程序作出解释.(这一点和注释（comment)没什么区别） 可以被其他程序（比如：编译器等）读取. 通过反射获取 Annotation的格式： 注解是以“@注释名“在代码中存在的，还可以添加一些参数值，例如：@SuppressWarnings(value=“unchecked”). .
狂神 java设计模式
最新发布
09-28
狂神说Java是一个知名的视频教程系列，主要讲解Java编程相关的知识。根据引用和引用中的运行结果可以看出，适配器模式和装饰者模式是狂神在其中介绍的两种设计模式。适配器模式用于将一个类的接口转换成客户端所期待的另一种接口，以解决接口不兼容的问题。而装饰者模式则是在不改变原有对象的基础上，动态地给对象增加额外的功能，以实现扩展和复用。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值