设计模式、代理模式、动态代理、懒汉式、饿汉式（学习笔记）

最新推荐文章于 2024-07-12 16:26:30 发布
最新推荐文章于 2024-07-12 16:26:30 发布
阅读量793 收藏 1
点赞数 48
分类专栏： 模式 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42203574/article/details/109727076
版权

设计模式

一.设计模式

1.什么是设计模式

  设计模式（Design pattern）：代表了最佳的实践，通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。

  简而言之：就是书写代码的一些规律，例如经常开车的人都知道，开车要用一档起步

2. java中的设计模式

java的设计模式大体上分为三大类：一共23种
创建型模式（5种）：工厂方法模式，抽象工厂模式，单例模式，建造者模式，原型模式。
结构型模式（7种）：适配器模式，装饰器模式，代理模式，外观模式，桥接模式，组合模式，享元模式。
行为型模式（11种）：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

3.设计模式遵循的原则有6个：

1、开闭原则（Open Close Principle）
　　对扩展开放，对修改关闭。

2、里氏代换原则（Liskov Substitution Principle）
　　只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。

3、依赖倒转原则（Dependence Inversion Principle）
　　这个是开闭原则的基础，对接口编程，依赖于抽象而不依赖于具体。

4、接口隔离原则（Interface Segregation Principle）
　　使用多个隔离的接口来降低耦合度。

5、迪米特法则（最少知道原则）（Demeter Principle）
　　一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。

6、合成复用原则（Composite Reuse Principle）
　　原则是尽量使用合成/聚合的方式，而不是使用继承。继承实际上破坏了类的封装性，超类的方法可能会被子类修改。

二.工厂模式

1.工厂模式（Factory Pattern） 定义：
  是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

  在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

1.工厂模式（Factory Pattern） 定义：

  是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

  在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

2.意图：

  定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。

  主要解决：主要解决接口选择的问题。

应用实例：
1、您需要一辆汽车，可以直接从工厂里面提货，而不用去管这辆汽车是怎么做出来的，以及这个汽车里面的具体实现。
2、Hibernate 换数据库只需换方言和驱动就可以。

3.优点：

1、一个调用者想创建一个对象，只要知道其名称就可以了。
2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。
3、屏蔽产品的具体实现，调用者只关心产品的接口

4.缺点：

  每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事

5.使用场景：

1、日志记录器：记录可能保存到本地硬盘、系统事件、远程服务器等，用户可以选择记录日志到什么地方。
2、数据库访问，当用户不知道最后系统采用哪一类数据库，以及数据库可能有变化时。
3、设计一个连接服务器的框架，需要三个协议，"POP3"、"IMAP"、"HTTP"，可以把这三个作为产品类，共同实现一个接口。

6.注意事项：

  作为一种创建类模式，在任何需要生成复杂对象的地方，都可以使用工厂方法模式。有一点需要注意的地方就是复杂对象适合使用工厂模式，
  而简单对象，特别是只需要通过 new 就可以完成创建的对象，无需使用工厂模式。如果使用工厂模式，就需要引入一个工厂类，会增加系统的复杂度

7.代码示例

简单工厂模式：就是建立一个工厂类，对实现了同一接口的一些类进行实例的创建。
简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类（
这些产品类继承自一个父类或接口）的实例
示例代码：
步骤一：创建一个接口/抽象类和抽象方法

package com.rj.bd.factorypattern;
/**
 * @desc   面条的抽象类（基类）
 */
public abstract class Noodels {
public abstract void kindsOfNoodle();//面条的种类
}



步骤二：创建实现类：
package com.rj.bd.factorypattern;
/**
 * @desc   炒类类
 */
public class ChaoMian extends Noodels {

	@Override
	public void kindsOfNoodle()
	{
     System.out.println("此时创造的是：炒面");
	}

}


package com.rj.bd.factorypattern;
/**
 * @desc   兰州拉面类
 */
public class LanZhouLaMian extends Noodels {

	@Override
	public void kindsOfNoodle()
	{
     System.out.println("此时创造的面条为：兰州拉面");
	}

}



package com.rj.bd.factorypattern;
/**
 * @desc   泡面类
 */
public class PaoMian extends Noodels {

	@Override
	public void kindsOfNoodle() 
	{
     System.out.println("此时创造的是：泡面");
	}

}




步骤三：创建简单工厂对象类
package com.sj.bd.mds;
/**
 * @desc   简单工厂类
 */
public class SimpleNoodlesFactory {
	    public static final int TYPE_LM = 1;//兰州拉面
	    public static final int TYPE_PM = 2;//泡面
	    public static final int TYPE_CM = 3;//炒面
	    
	    public static Noodles createNoodles(int type) {
	     case TYPE_PM:
			 return new PaoMian();
		case TYPE_LM:
			 return new LanZhouLaMian();
		case TYPE_CM:
			return new ChaoMian();
		default:
			return new ChaoMian();//默认为炒面类
	    }    
	    	    
}


步骤四：测试类
package com.sj.bd.mds;
/**
 * @desc   测试类：测试简单工厂
 */
public class CeShi {
	public static void main(String[] args) {
         //此时指出本次创建的面条是哪一类的
		 Noodels noodel = SimpleNoodelFactory.getNoodels(SimpleNoodelFactory.LM);
	     noodel.kindsOfNoodle();
		
	}

}

三.代理模式

1.什么是代理模式：
给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用

2.代理模式好处：
可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能，换言之：不改变源码的情况下，实现对目标对象的功能扩展
简而言之：为他人做嫁衣
PS:代理售货，代收发快递，

1.静态代理模式

定义：
1.静态代理：所谓静态代理就是自己要为要（被）代理的类写一个代理类，或者用工具为其生成的代理类，总之，就
是程序运行前就已经存在的编译好的代理类
2. 特点：不灵活，但是清楚的知道代理类是什么/哪个

代码示例

    小结与提问：通过上面的例子，我们可能有个疑问，难道就不能直接去厂家买车吗？当然可以，如果在使用场景
中实现类能满足要求时，
    我们当然可以直接实现类，但当实现类不能满足要求，要扩展需求，根据开闭原则你又不能修改实现类代码，这
时你就用代理类。
    比如购买一辆车我们要对客户进行一个购车款审核，如果符合条件就买车，不符合要求我们就告知客户购车款
不足。

引申：通过代理模式实现权限控制


package com.rj.bd.poxystyle.staticproxystyle2;
/**
 * @desc   接口
 */
public interface ICar {
public void buyCar();
}




package com.rj.bd.poxystyle.staticproxystyle2;

/**
 * @desc 客户类
 */
public class Customer implements ICar {

	public int cash;
	public String name;

	public int getCash() {
		return cash;
	}
	public void setCash(int cash) {
		this.cash = cash;
	}	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@Override
	public void buyCar() {
		System.out.println(this.name+"买车花了：" + this.cash + "元");
	}
}

package com.rj.bd.poxystyle.staticproxystyle2;
/**
 * @desc   4S店类也就是代理类
 */
public class S4Proxy  implements  ICar{

	public Customer  customer;//被代理的对象
		
	public S4Proxy(Customer  cu) 
	{
		System.out.println("4S店类初始化，也就是开门正式营业了");
		this.customer=cu;//接收买车客户
	}

	@Override
	public void buyCar() 
	{
		//先验资，也就是相当于现实世界中的先付款， 成功了然后才能说买车成功了
	    int cash = customer.getCash();
	   
		if (cash<100000)
		{
		  System.out.println("您的钱不够：先暂时不能买车呢");
		  return ;
		}
		customer.buyCar();
	}

}

package com.rj.bd.poxystyle.staticproxystyle2;
/**
 * @desc   测试类：测试静态代理模式
 */
public class Test {
	public static void main(String[] args) 
	{
        Customer  customer=new Customer();
        customer.setName("王百万");
		customer.setCash(200000);
		S4Proxy  proxy=new S4Proxy(customer);
		proxy.buyCar();
		
		System.out.println("-----------------------------");
		
		Customer  customer2=new Customer();
        customer2.setName("李美丽");
		customer2.setCash(80000);
		S4Proxy  proxy2=new S4Proxy(customer2);
		proxy2.buyCar();
	}

}

2.动态代理解释+jdk动态代理

1.导读模块：
  相比静态代理，动态代理具有更强的灵活性，因为它不用在我们设计实现的时候就指定某一个代理类来代理哪一个被代理对象，我们可以把这种指定延迟到程序运行时由JVM来实现

2.什么是动态代理：
  在程序运行时，运用反射机制动态创建而成

3.导读：
  在java的java.lang.reflect包下提供了一个Proxy（代理）类和一个InvocationHandler接口，通过这个类和这个接口可以生成JDK动态代理类和动态代理对象。

4.动态代理好处
  使用Java动态代理机制的好处：

1、减少编程的工作量：假如需要实现多种代理处理逻辑，只要写多个代理处理器就可以了，无需每种方式都写一个代理类。

2、功能的扩展：系统扩展性和维护性增强，程序修改起来也方便多了(一般只要改代理处理器类就行了)。

5.动态代理的使用场景：
  在后期的商业框架中很多都有用到的，例如Spring,Struts2

6.JDK动态代理：
   JDK动态代理所用到的代理类在程序调用到代理类对象时才由JVM真正创建，JVM根据传进来的 业务实现类对象 以及方法名 ，动态地创建了一个代理类的class文件并被字节码引擎执行，然后通过该代理类对象进行方法调用。我们需要做的，只需指定代理类的预处理、调用后操作即可

  简而言之：就是通过绑定接口与实现类，进而实现代理的
7.实现步骤：
1）首先，定义业务逻辑接口
2）然后，实现业务逻辑接口创建业务实现类
3）最后，实现 调用管理接口InvocationHandler 创建动态代理（工具）类
4）在使用时，首先创建一个业务实现类对象和一个代理类对象，然后定义接口引用（这里使用向上转型）
并用代理对象.bind(业务实现类对象)的返回值进行赋值。最后通过接口引用调用业务方法即可。
（接口引用真正指向的是一个绑定了业务类的代理类对象，所以通过接口方法名调用的是被代理的方法们）
8.代码解释

package com.rj.bd.poxystyle.JDKDynamicProxy;
/**
 * @desc   接口
 */
public interface ICar {
public void buyCar();
}



package com.rj.bd.poxystyle.JDKDynamicProxy;

/**
 * @desc 客户类
 */
public class Customer implements ICar {

	public int cash;
	public String name;

	public int getCash() {
		return cash;
	}

	public void setCash(int cash) {
		this.cash = cash;
	}

	
	public String getName() {
		return name;
	}

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

	@Override
	public void buyCar() {
		System.out.println(this.name+"买车花了：" + this.cash + "元");
	}

}


package com.rj.bd.poxystyle.JDKDynamicProxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

/**
 * @desc   动态代理工具类
 */
public class DymaicProxy  implements InvocationHandler {

public Object obj;//被代理的对象

	
	
	
public DymaicProxy(Object obj)
{
	this.obj = obj;//接受客户
}

/**
 * invoke():回调
 *   参数介绍：
 *         第一个参数：被代理的真实对象
 *         第二个参数：代表被动态代理类调用的方法。从中可得到方法名，参数类型，返回类型等等
 *         第三个参数：代表被调用方法的参数
 *  额外补充：因为是动态代理，所以可以实现一些特殊的功能，可以扩展增强其功能，
 *  怎样实现呢：before:dosomething();after:dosomething()
 */
	@Override
public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
	
		//before:dosomething();
		Object result = method.invoke(this.obj, args);
	    //after:dosomething()
		return result;
	}

}



package com.rj.bd.poxystyle.JDKDynamicProxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;

/**
 * @desc   测试类：测试JDK动态代理模式
 */
public class Test {
	public static void main(String[] args) 
	{
        Customer  customer=new Customer();
        customer.setName("王百万");
		customer.setCash(200000);
		//Java反射之getInterfaces()方法:可以获取某一类对像所所实现的接口
		//System.out.println(customer.getClass().getInterfaces()[0]);
		
	   InvocationHandler  handler=new DymaicProxy(customer);
	   
	   
	   /*
        * 通过Proxy类的newProxyInstance()方法来创建我们的代理对象，我们来看看其三个参数
        * 第一个参数:类加载器,我们这里使用handler这个类的ClassLoader对象来加载我们的代理对象
        * 第二个参数:对象要实现哪些接口:我们这里为代理对象提供的接口是真实对象所实行的接口，表示我要代理的是该真实对象，这样我就能调用这组接口中的方法了
        * 第三个参数:它是一个接口！它的名字叫调用处理器,使用新建的proxy对象调用方法的时候，都会调用到该接口中的invoke方法。 我们这里将这个代理对象关联到了上方的 InvocationHandler 这个对象上
        */
		ICar car = (ICar) Proxy.newProxyInstance(handler.getClass().getClassLoader(), customer.getClass().getInterfaces(), handler);

        //System.out.println("handler.getClass().getClassLoader()---->"+handler.getClass().getClassLoader());//获取到JVM创建的相当于是4S店的代理类

	    //System.out.println("cu.getClass().getInterfaces()---->"+cu.getClass().getInterfaces()[0]);//获取到Icar接口
	    //System.out.println("handler---->"+handler);//通过句柄可以间接的获取到被代理类，即客户类

		car.buyCar();
						
			
	}

}
小结：缺点：可以看出静态代理和JDK代理有一个共同的缺点，就是目标对象必须实现一个或多个接口，假如没有，则
可以使用Cglib代理

3.动态代理-cglib

代理类实现MethodInterceptor接口
定义：
  cglib代理：cglib是针对类来实现代理的，原理是对指定的业务类生成一个子类，并覆盖其中业务方法实现代理。因为采用的是继承，所以不能对final修饰的类进行代理

简而言之：对指定的目标类生成一个子类，并覆盖其中方法实现增强，进行代理的
备注：要想使用cglib代理，则必须额外的引入新的jar包:asm和cglib
PS：sping-core.jar包含了以上二者
代码解释

package com.rj.bd.poxystyle.CglibDynamicProxy;

/**
 * @desc 客户类:目标对象,没有实现任何接口
 */
public class Customer  {

	public int cash;
	public String name;

	public int getCash() {
		return cash;
	}

	public void setCash(int cash) {
		this.cash = cash;
	}

	
	public String getName() {
		return name;
	}

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

	
	public void buyCar() {
		System.out.println(this.name+"买车花了：" + this.cash + "元");
	}

}





package com.rj.bd.poxystyle.CglibDynamicProxy;

import java.lang.reflect.Method;

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

/**
 * @desc   代理类
 */
public class CglibProxy  implements  MethodInterceptor {

public Object  target;//目标对象	**(客户)**
	
//给目标对象创建一个代理对象
public Object getProxyInstance(Object target){
	this.target = target;
    //1.工具类
    Enhancer en = new Enhancer();
    //2.设置父类
    en.setSuperclass(target.getClass());
    //3.设置回调函数
    en.setCallback(this);
    //4.创建子类(代理对象)
    return en.create();
}

	@Override//给目标对象创建一个代理对象之前实现方法增强
public Object intercept(Object arg0, Method method, Object[] arg2,
			MethodProxy arg3) throws Throwable 
{
		    System.out.println("向观众问好");
	        //执行目标对象的方法
	        Object returnValue = method.invoke(target, arg2);
	        System.out.println("谢谢大家");
	        return returnValue;
}

}



package com.rj.bd.poxystyle.CglibDynamicProxy;
/**
 * @desc   测试类：测试Cglib代理
 * @author wyh
 * @time   2018-11-6 下午01:56:06  
 * 
 */
public class Test {
public static void main(String[] args) {
	
	  //1.初始化客户对象，并且给对象中的变量赋值 
	  Customer  target=new Customer();
	  target.setName("王百万");
	  target.setCash(200000);
	  //2.初始化代理类：目的是将初始化获取得到的客户对象传递给cglib代理类
	  CglibProxy  cglib=new CglibProxy();
	  Customer bookCglib=(Customer)cglib.getProxyInstance(target);
	  bookCglib.buyCar();
	
}
}

四.单例模式

单例模式确保某个类只有一个实例，而且自动实例化并向整个系统提供这个实例。在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。这些应用都或多或少具有资源管理器的功能。每台计算机可以有若干个打印机，但只能有一个Printer Spooler（打印区），以避免两个打印作业同时输出到打印机中。每台计算机可以有若干通信端口，系统应当集中管理这些通信端口，以避免一个通信端口同时被两个请求同时调用。总之，选择单例模式就是为了避免不一致状态，避免政出多头

1.单例模式有一下特点：

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

2.单例模式的优缺点

优点：该类只存在一个实例，节省系统资源；对于需要频繁创建销毁的对象，使用单例模式可以提高系统性能。
缺点：不能外部实例化（new），调用人员不清楚调用哪个方法获取实例时会感到迷惑，尤其当看不到源代码时

3.使用场景：

1）框架中：例如Spring框架
2）例如产生：商品订单号，保险单号

1.懒汉式单例模式

懒汉式：第一次调用的时候才初始化 小结：如果要用懒汉式实现单例的话 最好是结果双重判断的方式（双重加锁机制）实现
饿汉式：类加载的时候就初始化实例

package com.rj.bd.pattern.singles.lazyman;
/**
 * @desc   用户订单类（目的是为了模拟出多线程环境）
 */
public class OrderThread implements Runnable {

	@Override
	public void run() {

    GoodsNum onlyOneGoodsNum = GoodsNum.getInstance();
	System.out.println(onlyOneGoodsNum.hashCode());	
		
	}

}

package com.rj.bd.pattern.singles.lazyman;
/**
 * @desc   懒汉式单例应用之订单类
 */
public class GoodsNum {

private static GoodsNum goodsNum;
public static int i =1;//设定一个全局变量用来记录同步锁的判断次数
public GoodsNum() {
}

/**
 * @desc  1.初始化
 * @return
 */
public static GoodsNum getInstance()
{
	
   if (goodsNum == null) 
   {
	synchronized (GoodsNum.class) 
	{
		if (goodsNum == null) 
		{
			goodsNum = new GoodsNum();
		}
		i++;
	} 
}
System.out.println("同步代码块执行的次数："+i);
return goodsNum;
}
}

package com.rj.bd.pattern.singles.lazyman;
/**
 * @desc   测试类：测试在多线程情况下懒汉式单例有问题
 */
public class Test {

	public static void main(String[] args) {

		OrderThread orderThread=new OrderThread();
		/**
		Thread thread01=new Thread(orderThread);
		Thread thread02=new Thread(orderThread);

		thread01.start();
		thread02.start();
		**/
		
		Thread []threads=new Thread[10000];
		for(int i =0;i<threads.length;i++)
		{
			threads[i]=new Thread(orderThread);
			threads[i].start();
		}
		
		
	}

}

二、饿汉式单例模式

饿汉式：类加载的时候就初始化实例
示例代码：
package com.rj.bd.poxystyle.Singletons.hungrystyle;
/**
 * @desc   饿汉式
 */
public class GoodsNum {
	 private static GoodsNum goodsNum = new GoodsNum();
	 
	  private GoodsNum()
	    {
	    }

/**
 * @desc  初始化类对象
 * @return
 */
public static GoodsNum getInstance() {
	        return goodsNum;
	    }
	 
	 
}



package com.rj.bd.poxystyle.Singletons.hungrystyle;
/**
 * @desc   用户的订单模块
 */
public class OrderThread implements Runnable{

	@Override
	public void run() 
	{
			    GoodsNum onlyOnGoodsNum = GoodsNum.getInstance();
				System.out.println(onlyOnGoodsNum.hashCode());
	}

}




package com.rj.bd.poxystyle.Singletons.hungrystyle;
/**
 * @desc   测试：测试懒汉式
 */
public class Test {
	public static void main(String[] args) {
		   OrderThread  orderThread=new OrderThread();
		  /* Thread  thread1=new Thread(orderThread);
		   Thread  thread2=new Thread(orderThread);
           thread1.start();
           thread2.start();*/
           
           Thread []threads=new Thread[10000];
           for (int i = 0; i <threads.length; i++)
           {
        	   threads[i]=new Thread(orderThread);
        	   threads[i].start();
		   }
		    
  
	}

}
L_先生
关注
  • 48
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 76
    评论
专栏目录
单例设计模式-------懒汉式，饿汉式（超详细，附代码）
数字成都
03-15 9035
单例设计模式-------懒汉式，饿汉式 单例设计模式是一种很常见的设计模式 在这里介绍两种单例设计模式 懒汉式与饿汉式 单例设计模式的特点： 1.单例设计模式保证一个类只有一个实例。 2.要提供一个访问该类对象实例的全局访问点。 单例设计模式要点 对一些类来说，只有一个实例是很重要的。例如很多时候对于某个系统只需要拥有一个全局对象，这样有利于我们协调系统的整体行为。 再比如说某个服务器程...
17-Java单例模式的学习笔记1
08-08
Java 单例模式是一种设计模式，它用于保证一个类只有一个实例，并提供全局访问点。这种模式在需要控制类的实例化次数，或者当类的创建是昂贵的操作时非常有用。以下是对不同单例实现方式的详细说明： 1. **懒汉式**...
在JS中总结一下设计模式（单例-懒汉，单例-饿汉，工厂，代理，观察者）
weixin_43835284的博客
03-28 712
1.代理模式 2.单例模式 2.1 懒汉式 2.2 饿汉式 3.工厂模式 4.观察者模式
设计模式：单例模式（懒汉式，饿汉式），工厂模式
XucN_的博客
03-29 546
什么是设计模式• 设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。设计模式就像是经典的棋谱，不同的棋局，我们用不同的棋谱，免去我们自己再思考和摸索。 • 所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。• 实现单例模式需要满足三个条件：• 1、单例类只能有一个实例。• 2...
设计模式——单例模式（懒汉式、饿汉式）
qq_42922647的博客
05-22 3984
单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。它分为懒汉式和饿汉式。 注意： 构造器必须私有化。 对外必须获得一个公有的访问方式来获得实例。 1. 饿汉式： 顾名思义，饿...
设计模式--单例模式（一）懒汉式和饿汉式
liuxinyang666的博客
12-09 272
本文是设计模式学习笔记的第二篇文章，主要分析的是单例模式。包括懒汉式，饿汉式，登记式，以及懒汉式的改进型， 还有一个关于读取propertoes配置文件的实例。预计分为三节。这是第一节，先分析最简单的懒汉式和饿汉式。单例模式是设计模式中比较简单的一种。适合于一个类只有一个实例的情况，比如窗口管理器，打印缓冲池和文件系统， 它们都是原型的例子。典型的情况是，那些对象的类型被遍及一个软件系统的不同对
设计模式学习笔记一 单例模式之饿汉式、懒汉式
qq_41684416的博客
07-11 92
单例模式之饿汉式、懒汉式 核心作用: 保证一个类只有一个实例,并且提供一个访问实例的全局访问点。 单例模式的优点: 由于单例模式只产生一个实例，减少了系统性能的开销，当一个对象的产生需要比较多的资源时，如读取配置，产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后永久驻留内存的方式来解决。 单例模式可以在系统设置全局的访问点，优化共享资源访问，例如可以设计一个单例类，负责所有的数据表的映射处理。 常见的五种单例模式: 模式 特点 饿汉式 线程安全，调用效率高。但是，不能
单例模式学习笔记：饿汉式、懒汉式
Ai_Answer_zr的博客
07-12 99
单例模式学习笔记 单例模式：属于创造型设计模式，单例类自己创造自己的对象，其他类可以直接访问这个对象，不需要实例化单例类的对象。 注意点： 单例类只有一个实例对象。 单例类必须自己创建实例对象。 单例类必须给其他类提供获取实例对象的方法。 思路： 其他类不能创建单例类的对象，即单例类的构造器必须是私有的。 单例类要给其他类提供一个可以访问对象的方法，即定义一个方法，返回单例类的对象，因为无法创建单例类的对象，无法通过对象名调用方法，所以这个给其它类访问单例类的对象的方法必须声明为static，那么单例
iOS学习笔记10-设计模式-单例模式（懒汉式，饿汉式）
小小小的骆驼的前端技术博客
09-13 1876
设计模式有许多中，如观察者模式，单例模式，工厂模式，门面模式，等等。单例模式：1.饿汉式：一进入程序就自动创建一个单例对象，但在移动端不是很适用； 2.懒汉式：当第一次使用到单例对象时，才创建对象；懒汉式：（不使用GCD）#import "HMMusicTool.h"@implementation HMMusicTool static id _instance;//第一步，先定义一个全局静态id变
【设计模式】学习笔记--单例模式（饿汉式、懒汉式、双重检查、静态内部类）
JJJoker_的博客
09-10 46
（披萨订购，由工厂类决定输出）优点：简单，在类装载前完成实例化，避免了线程同步问题（因为静态变量在程序开始运行时就会执行，并且只执行一次）缺点：效率低，每个线程都要实例化，同时存在线程安全问题（因为再给线程赋值之前可能有另一个也会进入赋值步骤）将实例化对象的代码提取出来，放到一个类中维护，达到和主项目的依赖关系解耦，从而提高项目的 扩展性与维护性。缺点：违反设计模式的ocp原则，即对扩展开发，对修改关闭，如果需要新增功能，会修改代码。定义：定义了一个创建对象的抽象方法，有子类据欸的那个要实例化的类。
计算机后端-Java-图解java设计模式笔记.zip
05-23
常见的实现方式有饿汉式、懒汉式和双重检查锁定等。单例模式在缓存、线程池、日志对象等场景中广泛应用。 2. **工厂模式**：提供一个接口来创建对象，但让子类决定实例化哪一个类。工厂方法使类的实例化推迟到子类...
设计模式学习笔记及其模式特点总结
02-23
实现单例有多种方式，如饿汉式（静态常量）、懒汉式（线程不安全）、双重检查锁定（DCL）以及枚举方式，其中DCL和枚举方式是线程安全且性能较好的实现方式。 3. **命令模式**： 命令模式将请求封装为一个对象，...
韩顺平_Java设计模式笔记.docx
09-22
单例设计模式是确保一个类只有一个实例并提供全局访问点的模式，有多种实现方式，如饿汉式、懒汉式、双重检查、静态内部类和枚举等，每种方式都有其优缺点。 课程强调设计模式的重要性，不仅提升了软件的可扩展性...
配置Java开发环境
Broken_x的博客
07-10 1615
Java开发环境配置
java集合工具类
最新发布
药的博客
07-12 472
【代码】java集合工具类。
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 577
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
Java方法练习-双色球彩票系统
T1798218285的博客
07-11 310
红色球号码从1-33中选择；蓝色球号码从1-16中选择。投注号码由6个红色球号码和1个蓝色球号码组成。三等奖 5+1 / 5+0 3000。四等奖4+1 / 4+0 200。六等奖1+1 / 1+0 5。一等奖6+1 1000w。二等奖6+0 500w。五等奖3+1 / 2+1。
Java面向对象（高级）- 单例(Singleton)设计模式
11-19
在Java中，实现单例模式有多种方式，但常见的有两种：饿汉式和懒汉式。 **（1）设计模式概述** 设计模式是经过大量实践和经验积累形成的可重用的解决方案模板，它们代表了解决常见问题的最佳实践。设计模式提供了一...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值