设计模式专题之反射机制&单例模式

最新推荐文章于 2023-08-24 16:27:35 发布
最新推荐文章于 2023-08-24 16:27:35 发布
阅读量240 收藏 3
点赞数
分类专栏： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/s_zero/article/details/104596046
版权

1. 反射机制

1.1 什么是Java反射

就是正在运行，动态获取这个类的所有信息。
反射机制的作用

  1. 反编译：.class–>.java
  2. 通过反射机制访问java对象的属性，方法，构造方法等；

1.2 反射机制的应用场景

Jdbc 加载驱动
Spring IOC
ORM框架等

反射机制获取类有三种方法

  1. 第一种方式： 使用forname方法，参数为类的全路径
Classc1 = Class.forName("com.test.Employee");
  1. 第二种方式： java中每个类型都有class 属性.
Classc2 = Employee.class;
  1. 第三种方式： java语言中任何一个java对象都有getClass 方法
Employeee e = new Employee();  
Classc3 = e.getClass(); //c3是运行时类 (e的运行时类是Employee)

反射创建对象的方式

Class<?> forName = Class.forName("com.it.entity.User");
// 创建此Class 对象所表示的类的一个新实例 调用了User的无参数构造方法.
Object newInstance = forName.newInstance();

实例化有参构造函数

Class<?> forName = Class.forName("com.it.entity.User");
Constructor<?> constructor = forName.getConstructor(String.class, String.class);
User newInstance = (User) constructor.newInstance("123", "123");

反射创建api
方法名称与作用：
getDeclaredMethods [] ：获取该类的所有方法
getReturnType() ：获取该类的返回值
getParameterTypes() ：获取传入参数
getDeclaredFields() ：获取该类的所有字段
setAccessible ：允许访问私有成员

使用反射为类私有属性赋值

/**
 * @Auther: 洺润Star
 * @Date: 2020/3/2 09:49
 * @Description:
 */
public class Test01ReflexUser {
    private String name;
    public String getName() {
        return name;
    }
}



/**
 * @Auther: 洺润Star
 * @Date: 2020/3/2 09:49
 * @Description:使用反射为类的私有属性赋值
 */
public class Test01ReflexMain {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchFieldException, NoSuchMethodException {
        Class<?> aClass = Class.forName("designpattern.reflex.Test01ReflexUser");
        Field[] declaredFields = aClass.getDeclaredFields();
        for (Field field :declaredFields){
            System.out.println(field);
        }
        Method[] declaredMethods = aClass.getDeclaredMethods();
        for (Method method: declaredMethods){
            System.out.println(method);
        }
        Test01ReflexUser test01ReflexUser = (Test01ReflexUser) aClass.newInstance();
        Field name = aClass.getDeclaredField("name");
        name.setAccessible(true);
        name.set(test01ReflexUser,"洺润star");
        System.out.println(test01ReflexUser.getName());
    }
}

在这里插入图片描述

JDBC反射加载驱动

public class DemoJDBC {
    public static void main(String[] args) throws Exception {
        // 加载驱动类
        Class.forName("com.mysql.jdbc.Driver");
    
        // 通过DriverManager获取数据库连接
        String url = "jdbc:mysql:///";
        String user = "";
        String password = "";
        Connection connection = (Connection)DriverManager.getConnection(url, user, password);
        
        PreparedStatement statement = (PreparedStatement) connection.prepareStatement(
                "insert persion (name, age) value (?, ?)");
        statement.setString(1, "hdu");
        statement.setInt(2, 21);
        statement.executeUpdate();
        
        ResultSet resultSet = statement.executeQuery("select * from persion");
        // 操作ResultSet结果集
        while (resultSet.next()) {
            // 第一种获取字段方式
            System.out.println(resultSet.getString(1) + " " + 
                    resultSet.getString(2) + " " + resultSet.getString(3));
        }

        // 关闭数据库连接
        resultSet.close();
        statement.close();
        connection.close();
    }
}

禁止使用反射机制初始化：
将构造函数为私有化，如将上例中的Test01ReflexUser无参构造函数私有化，再调用就会出现权限不足错误。但是这样做会导致只有在Test01ReflexUser类中才能使用反射。
在这里插入图片描述

2. 设计模式

2.1 设计模式分类

  • 创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
  • 结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
  • 行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

2.2 设计模式的六大原则

  • 开闭原则（Open Close Principle）
    开闭原则就是说对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。所以一句话概括就是：为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点。
  • 里氏代换原则LSP（Liskov Substitution Principle）面向对象设计的基本原则之一。 里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。
    LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。—— From Baidu 百科
  • 依赖倒转原则（Dependence Inversion Principle）
    这个是开闭原则的基础，具体内容：真对接口编程，依赖于抽象而不依赖于具体。
  • 接口隔离原则（Interface Segregation Principle）
    这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。还是一个降低类之间的耦合度的意思，从这儿我们看出，其实设计模式就是一个软件的设计思想，从大型软件架构出发，为了升级和维护方便。所以上文中多次出现：降低依赖，降低耦合。
  • 迪米特法则（最少知道原则）（Demeter Principle）
    为什么叫最少知道原则，就是说：一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。
  • 合成复用原则（Composite Reuse Principle） 原则是尽量使用合成/聚合的方式，而不是使用继承。

3. 单例模式

3.1 什么是单例

保证一个类只有一个实例，并且提供一个访问该全局访问点

3.2 单例应用场景

  1. Windows的Task Manager（任务管理器）就是很典型的单例模式（这个很熟悉吧），想想看，是不是呢，你能打开两个windows task manager吗？ 不信你自己试试看哦~
  2. windows的Recycle Bin（回收站）也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例。
  3. 网站的计数器，一般也是采用单例模式实现，否则难以同步。
  4. 应用程序的日志应用，一般都何用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加。
  5. Web应用的配置对象的读取，一般也应用单例模式，这个是由于配置文件是共享的资源。
  6. 数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。数据库软件系统中使用数据库连接池，主要是节省打开或者关闭数据库连接所引起的效率损耗，这种效率上的损耗还是非常昂贵的，因为何用单例模式来维护，就可以大大降低这种损耗。
  7. 多线程的线程池的设计一般也是采用单例模式，这是由于线程池要方便对池中的线程进行控制。
  8. 操作系统的文件系统，也是大的单例模式实现的具体例子，一个操作系统只能有一个文件系统。
  9. HttpApplication 也是单位例的典型应用。熟悉ASP.Net(IIS)的整个请求生命周期的人应该知道HttpApplication也是单例模式，所有的HttpModule都共享一个HttpApplication实例.

3.3 单例优缺点

优点：

1. 在单例模式中，活动的单例只有一个实例，对单例类的所有实例化得到的都是相同的一个实例。这样就 防止其它对象对自己的实例化，确保所有的对象都访问一个实例 
2.单例模式具有一定的伸缩性，类自己来控制实例化进程，类就在改变实例化进程上有相应的伸缩性。 
3.提供了对唯一实例的受控访问。 
4.由于在系统内存中只存在一个对象，因此可以 节约系统资源，当 需要频繁创建和销毁的对象时单例模式无疑可以提高系统的性能。 
5.允许可变数目的实例。 
6.避免对共享资源的多重占用。

缺点：

1.不适用于变化的对象，如果同一类型的对象总是要在不同的用例场景发生变化，单例就会引起数据的错误，不能保存彼此的状态。 
2.由于单利模式中没有抽象层，因此单例类的扩展有很大的困难。 
3.单例类的职责过重，在一定程度上违背了“单一职责原则”。 
4.滥用单例将带来一些负面问题，如为了节省资源将数据库连接池对象设计为的单例类，可能会导致共享连接池对象的程序过多而出现连接池溢出；如果实例化的对象长时间不被利用，系统会认为是垃圾而被回收，这将导致对象状态的丢失。

3.3 创建单例的7种方式

  1. 饿汉式:类初始化时,会立即加载该对象，线程天生安全,调用效率高。
  2. 懒汉式（线程安全和不安全两种）: 类初始化时,不会初始化该对象,真正需要使用的时候才会创建该对象,具备懒加载功能。
  3. 静态内部方式:结合了懒汉式和饿汉式各自的优点，真正需要对象的时候才会加载，加载类是线程安全的。
  4. 枚举单例: 使用枚举实现单例模式 优点:实现简单、调用效率高，枚举本身就是单例，由jvm从根本上提供保障!避免通过反射和反序列化的漏洞， 缺点没有延迟加载。
  5. 双重检测锁方式 (因为JVM本质重排序的原因，可能会初始化多次，不推荐使用)
  6. 使用容器：多个单例对象注入到HashMap中，进行统一管理，更加方便快捷

3.3.1饿汉式

//饿汉式
public class SingletonDemo01 {
	// 类初始化时,会立即加载该对象，线程天生安全,调用效率高
	private static SingletonDemo01 singletonDemo01 = new SingletonDemo01();

	private SingletonDemo01() {
		System.out.println("SingletonDemo01初始化");
	}

	public static SingletonDemo01 getInstance() {
		System.out.println("getInstance");
		return singletonDemo01;
	}

	public static void main(String[] args) {
		SingletonDemo01 s1 = SingletonDemo01.getInstance();
		SingletonDemo01 s2 = SingletonDemo01.getInstance();
		System.out.println(s1 == s2);
	}

}

3.3.2懒汉式

//懒汉式
public class SingletonDemo02 {

	//类初始化时，不会初始化该对象，真正需要使用的时候才会创建该对象。
	private static SingletonDemo02 singletonDemo02;

	private SingletonDemo02() {
   
	}

	public synchronized static SingletonDemo02 getInstance() {
		if (singletonDemo02 == null) {
			singletonDemo02 = new SingletonDemo02();
		}
		return singletonDemo02;
	}

	public static void main(String[] args) {
		SingletonDemo02 s1 = SingletonDemo02.getInstance();
		SingletonDemo02 s2 = SingletonDemo02.getInstance();
		System.out.println(s1 == s2);
	}

}

上面这种是线程安全的，如果将synchronized 关键字去掉则线程不安全

3.3.3 静态内部类

// 静态内部类方式
public class SingletonDemo03 {
	private SingletonDemo03() {
           System.out.println("初始化..");
	}

	public static class SingletonClassInstance {
		private static final SingletonDemo03 singletonDemo03 = new SingletonDemo03();
	}

	// 方法没有同步
	public static SingletonDemo03 getInstance() {
		System.out.println("getInstance");
		return SingletonClassInstance.singletonDemo03;
	}

	public static void main(String[] args) {
		SingletonDemo03 s1 = SingletonDemo03.getInstance();
		SingletonDemo03 s2 = SingletonDemo03.getInstance();
		System.out.println(s1 == s2);
	}
}

优势：兼顾了懒汉模式的内存优化（使用时才初始化）以及饿汉模式的安全性（不会被反射入侵）。

劣势：需要两个类去做到这一点，虽然不会创建静态内部类的对象，但是其 Class 对象还是会被创建，而且是属于永久带的对象。

3.3.4 枚举方式

什么是枚举
枚举本身是单例的，一般用于项目中定义常量，如下所示。

enum UserEnum {
	HTTP_200(200, "请求成功"),HTTP_500(500,"请求失败");
	private Integer code;
	private String name;

	UserEnum(Integer code, String name) {
		this.code = code;
		this.name = name;
	}

	public Integer getCode() {
		return code;
	}

	public void setCode(Integer code) {
		this.code = code;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

}

public class TestEnum {

	public static void main(String[] args) {
		System.out.println(UserEnum.HTTP_500.getCode());
	}
}

使用枚举实现单例模式 优点:实现简单、枚举本身就是单例，由jvm从根本上提供保障!避免通过反射和反序列化的漏洞 缺点没有延迟加载

public class User {
	public static User getInstance() {
		return SingletonDemo04.INSTANCE.getInstance();
	}

	private static enum SingletonDemo04 {
		INSTANCE;
		// 枚举元素为单例
		private User user;

		private SingletonDemo04() {
			System.out.println("SingletonDemo04");
			user = new User();
		}

		public User getInstance() {
			return user;
		}
	}

	public static void main(String[] args) {
		User u1 = User.getInstance();
		User u2 = User.getInstance();
		System.out.println(u1 == u2);
	}
}

3.3.5双重检测锁

public class Test05Singleton {
    private static Test05Singleton test05Singleton;

    public Test05Singleton() {
        System.out.println("类初始化");
    }
    //线程安全，效率底
    public static Test05Singleton getInstance(){
        if (test05Singleton == null){
            synchronized (Test05Singleton.class){
                if (test05Singleton == null){
                    test05Singleton = new Test05Singleton();
                }
            }
        }
        return test05Singleton;
    }

    public static void main(String[] args) {
        Test05Singleton instance = Test05Singleton.getInstance();
        Test05Singleton instance2 = Test05Singleton.getInstance();
        System.out.println(instance == instance2);
    }
}

在这里插入图片描述

3.3.6 使用容器


/**
 * @Auther: 洺润Star
 * @Date: 2020/4/7 20:53
 * @Description:使用容器实现单例模式
 */
public class Test06Singleton {
    private static Map<String,Object> objectMap= new HashMap<>();
    private Test06Singleton(){}
    public static void registerService(String key,Object singleton){
        if(!objectMap.containsKey(key)){
            objectMap.put(key,singleton);
        }
    }
    public static Object getObjectService(String key){
        return objectMap.get(key);
    }

    public static void main(String[] args) {
        registerService("test",new Test06Singleton());
        Test06Singleton test1 = (Test06Singleton) getObjectService("test");
        Test06Singleton test2 = (Test06Singleton) getObjectService("test");
        System.out.println(test1 == test2);
    }
}

3.3.6 单例防止反射漏洞攻击

在构造函数中，只能允许初始化化一次即可,其中构造函数中抛出异常即可终止类的实例化。

private static boolean flag = false;

	private SingletonDemo04() {

		if (!flag) {
			flag = !flag;
		} else {
			throw new RuntimeException("单例模式被侵犯！");
		}
	}

	public static void main(String[] args) {

	}

3.3.7 如何选择单例创建方式

如果不需要延迟加载单例，可以使用枚举或者饿汉式，相对来说枚举性好于饿汉式。
如果需要延迟加载，可以使用静态内部类或者懒韩式，相对来说静态内部类好于懒韩式。

洺润
关注
专栏目录
Go必知必会系列：设计模式与重构
AI天才研究院
09-24 1705
作者：禅与计算机程序设计艺术 1.简介 软件开发是一门复杂的科学，涉及到面向对象编程、设计模式、编码规范、单元测试等众多知识点。作为一名技术人员，掌握优秀设计模式对项目的质量有着直接影响，可以有效提高开发效率和可维护性。本专题将从设计模式的理论出发，带领读者了解设计模式背后的设计思想、分类和意图，并通过
MySQL系列：java单例模式例子
m0_56662269的博客
05-27 172
前言 Redis是企业级系统高并发、高可用架构中非常重要的一个环节。Redis主要解决了关系型数据库并发量低的问题，有助于缓解关系型数据库在高并发场景下的压力，提高系统的吞吐量（具体Redis是如何提高系统的性能、吞吐量，后面会专门讲）。 而我们在Redis的实际使用过程中，难免会遇到缓存与数据库双写时数据不一致的问题，这也是我们必须要考虑的问题。如果还有同学不了解这个问题，可以搬小板凳来听听啦。 Linux 专题 微服务专题 微服务架构有哪些优势？ 微服务有哪些特点？ 设计微服务的最佳实践是什么？ 微
反射破坏单例模式及解决办法
llangzh的博客
10-27 1069
使用反射对单例模式的破坏： /** * 反射破坏单例 */ public class ProxyBreakSingleton { @Test public void test(){ //通过单例模式创建对象 DoubleIfSynchronizedSingleton synchronizedSingleton = DoubleIfSynchronizedSingleton.getSingleton(); //反射创建对象
设计模式——反射模式
huyiju的博客
08-21 6703
1：什么是反射 大家都知道，要让Java程序能够运行，那么就得让Java类要被Java虚拟机加载。Java类如果不被Java虚拟机加载，是不能正常运行的。现在我们运行的所有的程序都是在编译期的时候就已经知道了你所需要的那个类的已经被加载了。 Java的反射机制是在编译并不确定是哪个类被加载了，而是在程序运行的时候才加载、探知、自审。使用在编译期并不知道的类。这样的特点就是反射。 JAVA反射...
设计模式和反射
hangoer的博客
08-14 319
设计模式 定义 前⼈总结出来的对⼀些常⻅问题的解决⽅案,后⼈直接拿来解决特定问题⽽存在的解题思路。 分类 常⽤的设计模式:单例,⼯⼚,代理,适配器,装饰,模板,观察者等,⼀共有23种 第⼀:创建型模式:如何创建对象以及何时创建对象 包括: ⼯⼚模式(FACTORY METHOD) 抽象⼯⼚模式 建造(BUILDER)模式 代理模式(SINGLETON) 原型模式(Prototype) 第⼆:结构型模式:对象该如何组织以及采⽤什么样的结构更合理 包括: 适配器(Adapter)模式 合成(Composite
单例模式与反射
fangside的博客
03-23 412
单例模式与反射单例模式饿汉式单例懒汉式单例静态内部类以上都是不安全的那么如何解决反射造成的破坏 以懒汉模式为例可是如果当不使用![在这里插入图片描述](https://img-blog.csdnimg.cn/20210323153635703.png) 单例模式 构造方法私有化，拒绝用户new对象。 饿汉式单例 缺点：可能导致资源浪费 懒汉式单例 用的时候再加载，就可以避免资源浪费 volatile:避免指令重开。 静态内部类 以上都是不安全的 反射可以破坏以上单例 那么如何解决反射造成的破坏
设计模式--单例模式（反射）
wBkvam
08-02 846
单例模式 这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。 注意： 单例模式只能有一个实例 单例类必须自己创建自己的唯一实例 单例类必须给所有其他对象提供这一实例 介绍 意图： 保证一个类仅有一个实例，并提供一个访问它的全局访问点。 主要解决： 一个全局使用的类频繁地创建与销毁。 何时使用： 当您想控制实例数目，节省系统资源的时候。 如何解决： 判断系统是否已经有这个单例，如果有则返回，如果没有
设计模式面试专题.pdf
03-28
枚举实现的单例模式则是线程安全的，同时避免了反射破坏单例的可能。 观察者模式是一种设计模式，用于构建一对多的依赖关系，其中一个对象的状态发生变化时，所有依赖的对象都会收到通知。在Java中，Swing组件中的...
Java后端架构技术面试汇总：基础+设计模式+MySQL+分布式+微服务等
m0_56212833的博客
04-28 1502
前言 很多人面试之前，可能没有在互联网公司工作过或者说工作过但年头较短，不知道互联网公司技术面试都会问哪些问题？ 再加上可能自己准备也不充分，去面试没几个回合就被面试官几个问题打蒙了，最后以惨败收场。下述整理的180道Java后端常问的面试体系汇总，有整理出一份知识点复习笔记和Java后端高频知识考点专题文档答案免费分享给大家！ 由于篇幅原因，在这只把部分的题目列举出来，答案就不做全部展示了，这些题我已经整理成pdf文档免费分享给那些有需要的朋友，同时整理也花费了蛮多时间，有需要的朋友可以帮忙点这里直达即
单例+反射模式
m0_75280915的博客
08-24 158
单例模式+反射模式
Tensorflow中设计模式-反射模式
weixin_42721176的博客
06-07 433
Tensorflow中设计模式-反射模式 作为一个优秀的深度学习框架，tensorflow支持各种各样的设备和op，而且支持用户自定义op。用户在自定义一个op后，这个op如何注册进tensorflow框架，用户在使用这个op时，tensorflow是如何知道这个op的呢？今天可以聊聊tensorflow底层代码中广泛使用的反射设计模式。 在开始聊tensorflow之前，我们先了解一下什么是反射模式。在很多时候，我们创建要创建的对象，在代码编译前都已经写好，但是在有的场合下，只有在程序运行的时候，才知
反射，单例模式（setAccessible）
qq_50845167的博客
02-24 132
通过反射创建对象 https://blog.csdn.net/qq_33236248/article/details/80347884?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522161414999116780255258512%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=161414999116780255258512&amp
单例模式以及通过反射和序列化破解单例模式
mushui59的专栏
09-15 135
对于Java来说单例模式可以有以下几种方式： 饿汉方式 懒汉方式 双重检查加锁懒汉方式 内部类方式 枚举方式 破解单例模式有两种方式：通过反射的方式和通过序列化的方式。下面将一一对此进行分析。 饿汉方式非常简单，即使用一个初始化的静态变量，代码如下： 1 public class EagerSingleton { 2    private...
简单总结单例模式和反射
qq_40629019的博客
06-19 486
恶汉式单例模式 只要是单例模式，先进行构造器的私有化，将无参构造方法加private进行私有 恶汉式是不管需不需要直接生成对象和开辟属性空间，容易造成资源的浪费 ​ package com.ujiuye.single; ​ //恶汉式单例 public class Hungry { //恶汉式会容易浪费空间，不管什么直接全部加载会造成资源的浪费 private byte[] data1 = new byte[1024*1024]; private byte[] da...
反射在设计模式中的应用
babala_234的专栏
06-08 414
利用设计模式可以使我们的代码更灵活，更容易扩展，更容易维护。各种面向对象的程序设计语言都提供了基本相同的机制：比如类、继承、派生、多态等等。但是又有各自的特色，c# 中的反射机制便是一个很重要的工具，好好地利用就可以在实际中发挥很大的作用。 　　 我们来看一个例子： 　　 我的程序中有需要一系列的对象，比如apple,orange…, 要想利用他们，我们就必须在程序中根据用户要求，然后一个...
反射_单例模式_注解
qq794554587的博客
05-07 109
获取类对象 //1使用对象获取类对象 Person zhangsan=new Person(); Class<?> class1=zhangsan.getClass(); System.out.println(class1.hashCode()); //2使用类名.class属性 Class<?> class2=Person.class; System.out.println(class2.hashCode()); //3使用Class的静态方法[推荐
反射与单例模式笔记
weixin_43215223的博客
07-04 318
单例模式笔记 学自B站，遇见狂神 一、恶汉式单例模式 缺点：可能会浪费空间，开辟了空间，却没有使用 Hungry.class package com.wu; public class Hungry { //可能会浪费空间，开辟了空间，却没有使用 byte[] date1= new byte[1024*1024]; byte[] date2= new byte[1024*1024]; byte[] date3= new byte[1024*1024]; //第一步，
反射与单例模式
最新发布
tao_662628的博客
08-24 137
5：获取字段第一步：首先要有一个目标类（用来验证反射）
反射如何破坏单例模式
weixin_30681121的博客
02-06 96
一个单例类： public class Singleton { private static Singleton instance = new Singleton(); private Singleton() {} public static Singleton getInstance() { return ins...
Java设计模式之单例模式详解
单例模式（Singleton）是一种常用的设计模式，它的主要目的是确保一个类中只有一个实例，并且该实例必须自动创建，并向整个系统提供该实例。下面我们来详细了解单例模式的定义、结构、优缺点和应用场景。 定义： ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值