第158天学习打卡（单例模式）

最新推荐文章于 2024-08-24 11:46:12 发布
最新推荐文章于 2024-08-24 11:46:12 发布
阅读量131 收藏
点赞数
文章标签： 设计模式 反编译 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/doudoutj/article/details/117934104
版权
本文深入探讨了设计模式中的单例模式，包括饿汉式、懒汉式、DCL懒汉式、静态内部类实现，以及如何通过反射破坏单例。同时，介绍了枚举作为实现单例的线程安全方式。学习设计模式可以提升编程能力，提高代码质量，遵循面向对象设计原则。
摘要由CSDN通过智能技术生成

什么是设计模式

设计模式（Design Pattern）是前辈们对代码开发经验的总结，是解决特定问题的一系列套路。它不是语法规定，而是一套用来提高代码可复用性、可维护性、可读性、稳健性以及安全性的解决方案。

学习设计模式的意义

设计模式的本质是面向对象设计原则的实际运用，是对类的封装性、继承性和多态性以及类的关联关系和组合关系的充分理解。

正确使用设计模式具有以下优点：

  • 可以提高程序员的思维能力、编程能力和设计能力
  • 使程序设计更加标准化、代码编制更加工程化，使软件开发效率大大提高，从而缩短软件的开发周期。
  • 使设计的代码可重用性高，可读性强，可靠性高，灵活性好，可维护性强

设计模式的基本要素

  • 模式名称
  • 问题
  • 解决方案
  • 效果

GoF 23

  • 一种思维，一种态度，一种进步

创建型模式：

  • 单例模式，工厂模式，抽象工厂模式，建造者模式，原型模式

结构型模式：

  • 适配器模式，桥接模式，装饰模式，组合模式，外观模式，享元模式，代理模式

行为型模式：

  • 模板方法模式，命令模式，迭代器模式，观察者模式，中介者模式，备忘录模式，解释器模式，状态模式，策略模式，职责链模式，访问者模式。

OOP(面向对象)七大原则

  • 开闭原则：对扩展开放，对修改关闭
  • 里氏替换原则：继承必须确保超类所拥有的性质在子类中仍然成立
  • 依赖倒置原则：要面向接口编程，不要面向实现编程
  • 单一职责原则：控制类的粒度大小，将对象解耦，提高其内聚性
  • 接口隔离原则： 要为各个类建立它们需要的专用接口
  • 迪米特法则：只与你的直接朋友交谈，不跟“陌生人”说话
  • 合成复用原则：尽量先使用组合或者聚合等关联关系来实现，其次才考虑使用继承关系来实现

单例模式（构造器一定要私有）

饿汉式

package com.doudou.note.single;
//饿汉式单例
public class Hungry {
    //可能会浪费空间
    private byte[] date1 = new byte[1024*1024];
    private byte[] date2 = new byte[1024*1024];
    private byte[] date3 = new byte[1024*1024];
    private byte[] date4 = new byte[1024*1024];

    private  Hungry(){

    }
    private final static Hungry HUNGRY = new Hungry();

    public static Hungry getInstance(){
        return HUNGRY;
    }
}

懒汉式

package com.doudou.note.single;
//懒汉式单例
public class LazyMan {
    private LazyMan(){
        //构造器私有
        System.out.println(Thread.currentThread().getName() + "ok");
    }
    private static LazyMan lazyMan;

    public static LazyMan getInstance(){
        if(lazyMan == null){
            lazyMan = new LazyMan();
        }
        return lazyMan;
    }

    //单例模式下是ok的
    //多线程并发 会出现问题
    public static void main(String[] args){
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                LazyMan.getInstance();
            }).start();

        }
    }
}

输出结果：

Thread-0ok
Thread-3ok
Thread-1ok
Thread-2ok

Process finished with exit code 0

DCL懒汉式

package com.doudou.note.single;
//懒汉式单例
public class LazyMan {
    private LazyMan(){
        //构造器私有
        System.out.println(Thread.currentThread().getName() + "ok");
    }
    private static LazyMan lazyMan;
//双重检测锁模式的 懒汉式单例  DCL懒汉式
    public static LazyMan getInstance(){
        if(lazyMan==null){
            synchronized (LazyMan.class){//锁class只有一个
                if(lazyMan == null){
                    lazyMan = new LazyMan();
                }
            }
        }

        return lazyMan;
    }

    //单例模式下是ok的
    //多线程并发 会出现问题
    public static void main(String[] args){
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                LazyMan.getInstance();
            }).start();

        }
    }
}

输出结果：

Thread-0ok

Process finished with exit code 0

加入volatile实现双重指令重排和原子性操作

package com.doudou.note.single;
//懒汉式单例
public class LazyMan {
    private LazyMan(){
        //构造器私有
        System.out.println(Thread.currentThread().getName() + "ok");
    }

    //volatile可以实现双重指令重排和实现原子性操作
    private volatile static LazyMan lazyMan;

    //双重检测锁模式的 懒汉式单例  DCL懒汉式
    public static LazyMan getInstance(){
        if(lazyMan==null){
            synchronized (LazyMan.class){//锁class只有一个
                if(lazyMan == null){
                    lazyMan = new LazyMan();//不是一个原子性操作
                    /**
                     * 1.分配内存空间
                     * 2.执行构造方法，初始化对象
                     * 3.把这个对象指向这个空间
                     *
                     * 比如出现指令重排现象
                     * 原本应该执行 123  可能出现132  如果A线程执行了132  B此时进来 会认为lazyMan还没有完成构造
                     */
                }
            }
        }

        return lazyMan;
    }


}

静态内部类

package com.doudou.note.single;
//静态内部类
public class Holder {
    private Holder(){

    }
    public static Holder getInstance(){
        return InnerClass.HOLDER;
    }

    public static class InnerClass{
        private static final  Holder HOLDER = new Holder();
    }
}

单例不安全，存在反射

反射可以破坏单例

package com.doudou.note.single;

import java.lang.reflect.Constructor;

//懒汉式单例
public class LazyMan {
    private LazyMan(){
        //构造器私有
        System.out.println(Thread.currentThread().getName() + "ok");
    }

    //volatile可以实现双重指令重排和实现原子性操作
    private volatile static LazyMan lazyMan;

    //双重检测锁模式的 懒汉式单例  DCL懒汉式
    public static LazyMan getInstance(){
        if(lazyMan==null){
            synchronized (LazyMan.class){//锁class只有一个
                if(lazyMan == null){
                    lazyMan = new LazyMan();//不是一个原子性操作
                    /**
                     * 1.分配内存空间
                     * 2.执行构造方法，初始化对象
                     * 3.把这个对象指向这个空间
                     *
                     * 比如出现指令重排现象
                     * 原本应该执行 123  可能出现132  如果A线程执行了132  B此时进来 会认为lazyMan还没有完成构造
                     */
                }
            }
        }

        return lazyMan;
    }
    //反射
    public static void main(String[] args) throws Exception {
        LazyMan instance = LazyMan.getInstance();
        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);//获得空参构造器
        declaredConstructor.setAccessible(true);
        LazyMan instance1 = declaredConstructor.newInstance();

        System.out.println(instance);
        System.out.println(instance1);

    }


}

输出结果：

mainok
mainok
com.doudou.note.single.LazyMan@14ae5a5
com.doudou.note.single.LazyMan@7f31245a

Process finished with exit code 0

破坏反射

package com.doudou.note.single;

import java.lang.reflect.Constructor;

//懒汉式单例
public class LazyMan {
    private LazyMan(){
        //构造器私有
        synchronized (LazyMan.class){
            if (lazyMan!=null){
                throw new RuntimeException("不要试图使用反射破坏异常");
            }
        }


    }

    //volatile可以实现双重指令重排和实现原子性操作
    private volatile static LazyMan lazyMan;

    //双重检测锁模式的 懒汉式单例  DCL懒汉式
    public static LazyMan getInstance(){
        if(lazyMan==null){
            synchronized (LazyMan.class){//锁class只有一个
                if(lazyMan == null){
                    lazyMan = new LazyMan();//不是一个原子性操作
                    /**
                     * 1.分配内存空间
                     * 2.执行构造方法，初始化对象
                     * 3.把这个对象指向这个空间
                     *
                     * 比如出现指令重排现象
                     * 原本应该执行 123  可能出现132  如果A线程执行了132  B此时进来 会认为lazyMan还没有完成构造
                     */
                }
            }
        }

        return lazyMan;
    }
    //反射
    public static void main(String[] args) throws Exception {
        LazyMan instance = LazyMan.getInstance();
        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);//获得空参构造器
        declaredConstructor.setAccessible(true);
        LazyMan instance1 = declaredConstructor.newInstance();

        System.out.println(instance);
        System.out.println(instance1);

    }


}

输出结果

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.doudou.note.single.LazyMan.main(LazyMan.java:46)
Caused by: java.lang.RuntimeException: 不要试图使用反射破坏异常
	at com.doudou.note.single.LazyMan.<init>(LazyMan.java:11)
	... 5 more

Process finished with exit code 1

破坏单例模式

package com.doudou.note.single;

import java.lang.reflect.Constructor;

//懒汉式单例
public class LazyMan {
    private LazyMan(){
        //构造器私有
        synchronized (LazyMan.class){
            if (lazyMan!=null){
                throw new RuntimeException("不要试图使用反射破坏异常");
            }
        }


    }

    //volatile可以实现双重指令重排和实现原子性操作
    private volatile static LazyMan lazyMan;

    //双重检测锁模式的 懒汉式单例  DCL懒汉式
    public static LazyMan getInstance(){
        if(lazyMan==null){
            synchronized (LazyMan.class){//锁class只有一个
                if(lazyMan == null){
                    lazyMan = new LazyMan();//不是一个原子性操作
                    /**
                     * 1.分配内存空间
                     * 2.执行构造方法，初始化对象
                     * 3.把这个对象指向这个空间
                     *
                     * 比如出现指令重排现象
                     * 原本应该执行 123  可能出现132  如果A线程执行了132  B此时进来 会认为lazyMan还没有完成构造
                     */
                }
            }
        }

        return lazyMan;
    }
    //反射
    public static void main(String[] args) throws Exception {
        // LazyMan instance = LazyMan.getInstance();
        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);//获得空参构造器
        declaredConstructor.setAccessible(true);
        LazyMan instance = declaredConstructor.newInstance();
        LazyMan instance1 = declaredConstructor.newInstance();

        System.out.println(instance);
        System.out.println(instance1);

    }


}

输出结果

com.doudou.note.single.LazyMan@14ae5a5
com.doudou.note.single.LazyMan@7f31245a

Process finished with exit code 0

破坏反射2

package com.doudou.note.single;

import java.lang.reflect.Constructor;

//懒汉式单例
public class LazyMan {
    private static boolean qinjiang = false;
    private LazyMan(){
        //构造器私有
        synchronized (LazyMan.class){
            if (qinjiang == false){
                qinjiang = true;

            }else{
                throw new RuntimeException("不要试图使用反射破话异常");
            }
        }


    }

    //volatile可以实现双重指令重排和实现原子性操作
    private volatile static LazyMan lazyMan;

    //双重检测锁模式的 懒汉式单例  DCL懒汉式
    public static LazyMan getInstance(){
        if(lazyMan==null){
            synchronized (LazyMan.class){//锁class只有一个
                if(lazyMan == null){
                    lazyMan = new LazyMan();//不是一个原子性操作
                    /**
                     * 1.分配内存空间
                     * 2.执行构造方法，初始化对象
                     * 3.把这个对象指向这个空间
                     *
                     * 比如出现指令重排现象
                     * 原本应该执行 123  可能出现132  如果A线程执行了132  B此时进来 会认为lazyMan还没有完成构造
                     */
                }
            }
        }

        return lazyMan;
    }
    //反射
    public static void main(String[] args) throws Exception {
        // LazyMan instance = LazyMan.getInstance();
        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);//获得空参构造器
        declaredConstructor.setAccessible(true);
        LazyMan instance = declaredConstructor.newInstance();
        LazyMan instance1 = declaredConstructor.newInstance();

        System.out.println(instance);
        System.out.println(instance1);

    }


}

输出结果

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.doudou.note.single.LazyMan.main(LazyMan.java:51)
Caused by: java.lang.RuntimeException: 不要试图使用反射破话异常
	at com.doudou.note.single.LazyMan.<init>(LazyMan.java:15)
	... 5 more

Process finished with exit code 1

破坏单例

package com.doudou.note.single;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;

//懒汉式单例
public class LazyMan {
    private static boolean qinjiang = false;
    private LazyMan(){
        //构造器私有
        synchronized (LazyMan.class){
            if (qinjiang == false){
                qinjiang = true;

            }else{
                throw new RuntimeException("不要试图使用反射破话异常");
            }
        }


    }

    //volatile可以实现双重指令重排和实现原子性操作
    private volatile static LazyMan lazyMan;

    //双重检测锁模式的 懒汉式单例  DCL懒汉式
    public static LazyMan getInstance(){
        if(lazyMan==null){
            synchronized (LazyMan.class){//锁class只有一个
                if(lazyMan == null){
                    lazyMan = new LazyMan();//不是一个原子性操作
                    /**
                     * 1.分配内存空间
                     * 2.执行构造方法，初始化对象
                     * 3.把这个对象指向这个空间
                     *
                     * 比如出现指令重排现象
                     * 原本应该执行 123  可能出现132  如果A线程执行了132  B此时进来 会认为lazyMan还没有完成构造
                     */
                }
            }
        }

        return lazyMan;
    }
    //反射
    public static void main(String[] args) throws Exception {
        // LazyMan instance = LazyMan.getInstance();

        Field qinjiang = LazyMan.class.getDeclaredField("qinjiang");
        qinjiang.setAccessible(true);

        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);//获得空参构造器
        declaredConstructor.setAccessible(true);
        LazyMan instance = declaredConstructor.newInstance();

        qinjiang.set(instance, false);//第一个对象的值再改为false
        LazyMan instance1 = declaredConstructor.newInstance();

        System.out.println(instance);
        System.out.println(instance1);

    }


}

结果

com.doudou.note.single.LazyMan@7f31245a
com.doudou.note.single.LazyMan@6d6f6e28

Process finished with exit code 0

枚举（反射不能破坏枚举）

package com.doudou.note.single;
//enum 是一个什么？ 枚举本身也是一个Class类



public enum EnumSingle {

    INSTANCE;
    public EnumSingle getInstance(){
        return  INSTANCE;
    }


}
class Test{
    public static void main(String[] args) {
        EnumSingle instance1 = EnumSingle.INSTANCE;
        EnumSingle instance2 = EnumSingle.INSTANCE;

        System.out.println(instance1);
        System.out.println(instance2);

    }
}

输出结果：

INSTANCE
INSTANCE

Process finished with exit code 0

反射不能破坏枚举证明

package com.doudou.note.single;
//enum 是一个什么？ 枚举本身也是一个Class类


import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public enum EnumSingle {

    INSTANCE;
    public EnumSingle getInstance(){
        return  INSTANCE;
    }


}
class Test{
    public static void main(String[] args) throws Exception {
        EnumSingle instance1 = EnumSingle.INSTANCE;
        Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);//私有权限进行破除
        EnumSingle instance2 = declaredConstructor.newInstance();

        //NoSuchMethodException: com.doudou.note.single.EnumSingle.<init>()
        System.out.println(instance1);
        System.out.println(instance2);


    }
}

输出结果(发现证明失败)：

Exception in thread "main" java.lang.NoSuchMethodException: com.doudou.note.single.EnumSingle.<init>()
	at java.lang.Class.getConstructor0(Class.java:3082)
	at java.lang.Class.getDeclaredConstructor(Class.java:2178)
	at com.doudou.note.single.Test.main(EnumSingle.java:20)

对枚举的class文件进行编译

image-20210615212856023

把class文件反编译为java文件，首先把jad.exe复制到这个目录下

image-20210615213605303

查看反编译的java文件可以发现枚举确实不能破坏单例

package com.doudou.note.single;
//enum 是一个什么？ 枚举本身也是一个Class类


import java.lang.reflect.Constructor;
public enum EnumSingle {

    INSTANCE;
    public EnumSingle getInstance(){
        return  INSTANCE;
    }


}
class Test{
    public static void main(String[] args) throws Exception {
        EnumSingle instance1 = EnumSingle.INSTANCE;
        Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class, int.class);
        declaredConstructor.setAccessible(true);//私有权限进行破除
        EnumSingle instance2 = declaredConstructor.newInstance();

        //NoSuchMethodException: com.doudou.note.single.EnumSingle.<init>()
        System.out.println(instance1);
        System.out.println(instance2);


    }
}

结果（这个说明反射不能破坏枚举）：

Exception in thread "main" java.lang.IllegalArgumentException: Cannot reflectively create enum objects
	at java.lang.reflect.Constructor.newInstance(Constructor.java:417)
	at com.doudou.note.single.Test.main(EnumSingle.java:20)

Process finished with exit code 1

枚举的最终反编译源码(发现枚举没有无参构造 只有有参构造 而且有两个参数)

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

package com.doudou.note.single;


public final class EnumSingle extends Enum
{

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

    public static EnumSingle valueOf(String name)
    {
        return (EnumSingle)Enum.valueOf(com/doudou/note/single/EnumSingle, name);
    }

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

    public EnumSingle getInstance()
    {
        return INSTANCE;
    }

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

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

B站学习网址：【狂神说Java】单例模式-23种设计模式系列_哔哩哔哩_bilibili

doudoutj
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
记录自己在厦门两年来的面试经历--完结篇
m0_67394230的博客
07-23 1699
芜湖首先简单说明一下，笔者是为19年6月份毕业，从事JAVA开发，18年11月份开始实习工作，本文主要描述一下这两年多的面试经历，帮助还未毕业或者准备找工作的兄弟萌了解一下厦门的一些公司情况（主要在软件园二期）。实习期：数据谷 — 没下文 软件园望海路那边，公司主要做医疗方向的软件开发,厦门研发这边规模不大，二三十个人，常年都有JAVA开发实习生岗位,整体薪资比较低，笔者只参加过面试，面试内容整体还是根据简历来，多线程问的比较多,还记得实习生岗位的时候问了一个问题:给你两亿的数据，要求从一台电脑移植到另外一
整理面试题
weixin_52491177的博客
12-09 1422
一、基础篇 Java 基础 1.面向对象的特征 可以说是三大特征，也可以说是四大特征 ①第一个是抽象：就是把有共同特征的一类事物，构造成类，只关注它的属性和行为，而不关注这些行为的细节 ②第二个是封装：就是把数据和操作数据的方法绑定起来，私有化，对外只提供一个最简单的方法 ③第三个是继承：子类继承父类的属性，比如说有多个类定义了共性的内容时，为了提高代码的复用性，就把这些类中的共性内容抽取出来，定义在一个独立的类中，然后再使用其他类去继承这个类中的共性部分，实现了复用，这就是继承 ④第四个是多态：顾名思义就
2021秋招学习笔记
Rookie1012的博客
11-23 3143
文章目录Java基础篇学习(7/3-7/4)数据类型泛型、反射、注解、序列化（加实例）1、reflect类方法2、泛型3、反射原理这里补充java四大引用类型：**反射获取方法总结**反射使用方法invoke4、注解原理这里顺便提一句Java动态代理机制：5、序列化原理6、Clone的原理？7、BigInteger高精度数据结构+java+操作系统+网络（查漏补缺的）1、完全二叉树定义2、Inode元信息java序列化原理插入排序udp到达tcp功能拥塞控制-发送窗口大小问题7、Linux的inode8、线
第四届先进材料与机械电子国际学术会议（ICAMM 2024）
han_xue_feng的博客
04-18 1235
经典dp：dp[i]，表示以i结尾的子串，连续子数组最大和为dp[i]递推dp[i]分类：dp[i。今天tp联洲三面，面试官先讲了一大堆岗位需求，让我根据匹配点说经历，我说的就是一团糟，因为本身我就是。老哥们，现在大数据好卷那，之前在亚信实习了快一年(数据开发)，都是用数据中台来处理数据，不怎么写SQ。美的 库卡自动化机械（不是，我电子电气的，和hr说了，还是让我来）调试机器人面经hr + 专业技术官。60min1.翻转单词序列，A2.二叉树展开链表，A3.线程进程，线程之间，进程之间切换的开销，进程。
牛逼！机械专业自学一年上岸阿里新零售...
博客
08-06 710
作者：阿秀阿秀的校招笔记：https://interviewguide.cn大家好，我是阿秀。最近有位机械学弟给我分享了他自学进入阿里本地生活的经历。我聊了聊，觉得这位师弟非常不错，于是邀...
【亚马逊】应用科学家Applied Scienist暑期实习
华鑫的专栏
04-24 1098
攒人品挂的挺快的，但是感觉被KPI了1.不用自我介绍，直接提问（我嗅到了KPI面的气息）2.问了两个。本人985本材料专业，贵州人，现在签了上汽五菱的研发岗，还有一个offer是长沙的中联重科，对象留在。两家工作强度差不多，军工国企的话离家近，跟女朋友在一个公司，每年还有一万多左右的补贴，中兴离家和女朋。考研二战寄，双非一本，hr说是目标院校，机考分数386，面的开发，技术面手撕给的一道简单题，13个人。这是我的简历，投了好多实习，都没人理我啊啊啊啊啊，没一个人喊我面试，我真的好菜啊，除了算法岗，我还可。
【转载】大龄码农的新西兰移民之路
weixin_30279671的博客
07-24 768
大龄码农的新西兰移民之路 【转载】博主地址：https://www.cnblogs.com/yanxiaodi/p/MoveToNewZealand.html 最近一年没怎么发博客，确实在忙一件事情——移民新西兰。如今已顺利入职，新西兰绿卡正在申请过程中，终于有时间将最近一年的经历整理成文，也供有此想法的同学们参考。 先说一下自己的基本情况，我之前算是体制内的员工，本科并...
大龄码农的新西兰移民之路
Python开发者
05-26 1704
（点击上方公众号，可快速关注）转自：yan_xiaodi（微信公众号：nzcoder ） 最近一年没怎么发博客，确实在忙一件事情——移民新西兰。如今已顺利入职，新西兰绿卡...
《昇思25天学习打卡营第1天 - 快速入门 mindspore》
06-27
昇思25天学习打卡营 - 02 快速入门
昇思25天学习打卡营第5天-网络与模型相关要素探讨
07-01
将 MindSpore 整个模块引入到当前的 Python 脚本里，方便后续运用 MindSpore 所提供的各类功能与类。从 MindSpore 模块中单独导入“nn”（一般代表神经网络相关的类和函数）以及“ops”（通常指操作符相关的功能），...
小白的20天Java学习打卡day18【完结撒花】
12-22
太原理工大学机器人团队20天学习打卡day18 今天是学习java基础的最后一天，比计划中少用了两天，由于我是因为兴趣才学java的，目前还不打算往这方面发展，所以学完java基础也不会深入下去了，我打算明天回顾一下这...
小白的20天Java学习打卡day3
01-20
太原理工大学机器人团队20天学习打卡day3 1、数据类型​ ①数据类型的作用 程序当中有很多数据，每一个数据都是有相关类型的，不同数据类型的数据占用空间大小不同。 数据类型的作用是指导JVM在运行程序的时候给该...
小白的20天Java学习打卡day2
12-22
太原理工大学机器人团队20天学习打卡day2 学习内容：Java 学习网站：b站 day02 今天的内容比昨天多很多，也更难理解，希望能坚持下去 1、打开DOS命令窗口，执行java HelloWorld,执行原理 java.exe命令会启动JVM JVM...
设计模式（三）
dingyahui的博客
08-24 931
Circle 是具体的实现类，它实现了抽象类的方法，并使用实现类接口来完成绘制工作，测试函数中创建了两个具体的实现类对象和两个使用这些实现类的圆形对象，并调用它们的绘制方法。优点：使用代理模式创建代表对象，让代表对象来控制某对象的访问，被代理的对象可以是远程的对象，创建开销大的对象或需要安全控制的对象。：真实的角色实现实际的业务逻辑，不用关心其它非本职的事务，通过后期的代理完成附加的事务，附带的结果就是编程简洁清晰。：享元模式的优点在于大幅减少内存中对象的数量，降低程序内存的占用，提高性能。
设计模式六大原则：迪米特法则详细说明和案例示范
weixin_39996520的博客
08-20 587
只与直接的朋友通信：一个对象应当只与那些与它关系密切的对象直接通信，而不应该依赖于太多的其他对象。避免过度依赖：对象之间的依赖关系应该尽量减少，避免形成复杂的依赖链。在实际开发中，这意味着我们应该设计简洁的接口，避免对象过度依赖于其他对象的内部细节，从而减少对象之间的耦合度。迪米特法则强调对象之间的交互应尽可能少，避免产生复杂的依赖关系。通过引入中介类或封装层，可以将依赖关系控制在合理的范围内，减少类之间的耦合度，提高系统的可维护性和可扩展性。
设计模式六大原则之一的接口隔离原则
jun778895的博客
08-20 1272
接口隔离原则的定义是：客户端不应该依赖它不需要的接口；一个类对另一个类的依赖应该建立在最小的接口上。换句话说，接口的设计应当尽量细化，每个接口只包含客户端需要的方法，而不是将所有可能的方法都放在一个接口中。接口隔离原则是面向对象设计中的一个重要原则，它强调了接口的设计应当尽量保持简洁和专一。通过细化接口、减少依赖和提高复用性等方式，接口隔离原则有助于降低系统的复杂性、提高系统的灵活性和可维护性。然而，在应用接口隔离原则时，也需要注意避免过度细化接口和增加系统的复杂性。
设计模式-visit模式-在语法树的实践
csdn问鼎
08-21 430
visit模式在解析语法树场景下的实践
前端宝典十六：深入浅出8大设计模式
最新发布
franktaoge的博客
08-24 711
本文主要探讨前端开发中的各种设计模式，主要分类有： - 单例模式 - 建造者模式 - 代理模式 - 装饰器模式 - 适配器模式 - 策略模式 - 观察者模式 - 发布订阅模式 通过对他们实际开发中的使用场景的解析，深入浅出的一起更全面直观的进行学习：
微信小程序制作学习计划打卡记录页面包含前几天的学习时间代码
05-22
以下是一个简单的微信小程序制作学习计划打卡记录页面的代码示例，其中包含了前几天的学习时间： ``` 学习计划打卡记录 今天 <text>2021-07-01 学习时间： 请输入学习时间（分钟）"/> ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值