JAVA设计模式示例代码

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

本文罗列了部分设计模式的简单示例代码，其中有很多框架的底层都是通过动态代理和责任链模式实现的，比如spring和mybatis

文章目录

一：java反射技术

1.1通过反射构造对象

  • 创建 ReflectServiceImpl类
package reflect;

/**
 * @Auther: 洺润Star
 * @Date: 2019/9/12 15:48
 * @Description:
 */
public class ReflectServiceImpl {

        public void sayHello(String name){
            System.out.println("hello,"+name);
        }

}

通过反射生成对象

    public ReflectServiceImpl getInstance() throws ClassNotFoundException, IllegalAccessException, InstantiationException {
        ReflectServiceImpl object = null;
        /*给类加载器注册了一个ReflectServiceImpl的全限定名，然后通过newInstance()构造了一个新的对象*/
        object = (ReflectServiceImpl) Class.forName("reflect.ReflectServiceImpl").newInstance();
        return object;
    }
  • 创建 ReflectServiceImpl2类（含有参数）
package reflect;

/**
 * @Auther: 洺润Star
 * @Date: 2019/9/12 16:21
 * @Description: 构造方法含有参数的类
 */
public class ReflectServiceImpl2 {
    private  String name;

    public ReflectServiceImpl2(String name) {
        this.name = name;
    }

    public void sayHello(){
        System.out.println("hello"+name);
    }
}

生成对象


    /*通过反射生成带有参数的构造方法*/
    public ReflectServiceImpl2 getInstance2() throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        ReflectServiceImpl2 object = null;
        object = (ReflectServiceImpl2) Class.forName("reflect.ReflectServiceImpl2").getConstructor(String.class).newInstance("jack");
        return object;
    }

反射仅需配置就可以生成对象，解除程序的耦合度，缺点就是运行比较慢，但依然比较常用，如Spring Ioc容器

1.2反射方法

/*反射方法*/
    public Object reflectMethod() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        Object returnObject = null;

        ReflectServiceImpl target = new ReflectServiceImpl();

        Method method = ReflectServiceImpl.class.getMethod("sayHello", String.class);//第一个参数是方法名称，第二个参数是方法的参数类型
        returnObject = method.invoke(target,"张三");//第一个参数使用哪个对象调用方法

        return  returnObject;
    }

1.3实例，生成反射对象和反射调度方法

/*实例*/
    public  Object reflect() throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        ReflectServiceImpl object;
        object = (ReflectServiceImpl) Class.forName("reflect.ReflectServiceImpl").newInstance();

        Method method = object.getClass().getMethod("sayHello", String.class);
        method.invoke(object,"张三");
        return object;
    }

二：动态代理模式和责任链模式

代理分两个步骤：

  • 代理对象和真是对象建立代理关系
  • 实现代理对象的代理逻辑方法
    Spring最常使用的动态代理技术是JDK和CGLIB,其中JDK动态代理中必须使用接口

2.1JDK动态代理

  • 建立接口和实现类
package agent;

/**
 * @Auther: 洺润Star
 * @Date: 2019/9/12 17:06
 * @Description:
 */
public interface HelloWorld {
    public void sayHelloWorld();
}


package agent;

/**
 * @Auther: 洺润Star
 * @Date: 2019/9/12 17:08
 * @Description:
 */
public class HelloWorldImpl implements HelloWorld{

    @Override
    public void sayHelloWorld() {
        System.out.println("hello,world");
    }

}
  • 动态代理绑定和代理逻辑实现
package agent;

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

/**
 * @Auther: 洺润Star
 * @Date: 2019/9/12 17:10
 * @Description:
 */
public class JdkProxyExample implements InvocationHandler {

    //真实对象
    private Object target = null;

    /**
     * 建立代理对象和真实的代理关系，并返回代理对象
     * @param target 真是对象
     * @return 代理对象
     */
    public Object bind(Object target){
        this.target = target;
        //第一个参数是类加载器，第二个参数是生成的动态代理对象下挂在那些接口下，第三个是定义实现方法逻辑的代理类
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
    }

    /**
     * 代理方法逻辑
     * @param proxy  代理对象
     * @param method 当前调度方法
     * @param args 当前方法参数
     * @return 代理结果返回
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //真实对象
        System.out.println("进入代理逻辑方法");
        System.out.println("在进入真实对象之前的服务");
        Object obj = method.invoke(target,args); //相当于调用sayhelloworld方法

        System.out.println("在调用真实对象之后的服务");
        return obj;
    }



}
  • 测试jdk动态代理
package agent;

/**
 * @Auther: 洺润Star
 * @Date: 2019/9/12 17:59
 * @Description:
 */
public class Test {
    public static void main(String[] args) {
        JdkProxyExample jdkProxyExample = new JdkProxyExample();
        //绑定关系，因为挂在接口helloworld下所以声明代理接口对象HelloWorld Proxy
        HelloWorld proxy = (HelloWorld)jdkProxyExample.bind(new HelloWorldImpl());
        //注意此时的HelloWorld对象已经是一个代理对象，它会进入代理的逻辑方法invoke里的proxy里的proxy。sayHelloWorld
        proxy.sayHelloWorld();
    }
}

2.2 CGLIB动态代理

代码如下：

package agent.cglib;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import net.sf.cglib.proxy.Proxy;

import java.lang.reflect.Method;

/**
 * @Auther: 洺润Star
 * @Date: 2019/9/12 18:59
 * @Description:
 */
public class CjlibProxyExample  implements MethodInterceptor {

    /**
     * CGLIB生成代理对像
     * @param cls 类
     * @return 类的CGLIB代理对象
     */
    public Object getProxy(Class cls){
        //CGLIB enhancer 增强类对象
        Enhancer enhancer = new Enhancer();
        //设置增强类型
        enhancer.setSuperclass(cls);
        //定义代理对象为当前对象,要求当前对象实现methodInterceptor方法
        enhancer.setCallback(this);
        //生成并返回代理对象
        return enhancer.create();
    }

    /**
     * 代理逻辑方法
     * @param o 代理对象
     * @param method 方法
     * @param objects 参数
     * @param methodProxy 方法代理
     * @return 代理逻辑返回
     * @throws Throwable
     */
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("调用真实对象前");
        //CGLIB 反射调用真实对象方法
        Object result = methodProxy.invokeSuper(o,objects);
        System.out.println("调用真实对象后");
        return result;
    }

}

测试

package agent.cglib;

import reflect.ReflectServiceImpl;

/**
 * @Auther: 洺润Star
 * @Date: 2019/9/12 19:23
 * @Description:
 */
public class Test {
    public static void main(String[] args) {
        CjlibProxyExample cjlibProxyExample = new CjlibProxyExample();
        ReflectServiceImpl obj = (ReflectServiceImpl) cjlibProxyExample.getProxy(ReflectServiceImpl.class);
        obj.sayHello("MR.Zhang");
    }
}

2.3 拦截器

  • 接口与实现
package interceptor;

import java.lang.reflect.Method;

/**
 * @Auther: 洺润Star
 * @Date: 2019/9/12 20:19
 * @Description:
 */
public interface Interceptor {
    /**
     *
     * @param proxy 代理对象
     * @param torget 真实对象
     * @param method 方法
     * @param args 方法参数
     * @return
     */
    public boolean before(Object proxy, Object torget, Method method,Object[] args);

    public void around(Object proxy, Object torget, Method method,Object[] args);

    public void after(Object proxy, Object torget, Method method,Object[] args);

}


package interceptor;

import java.lang.reflect.Method;

/**
 * @Auther: 洺润Star
 * @Date: 2019/9/12 20:24
 * @Description:
 */
public class MyInterceptor implements Interceptor {

    @Override
    public boolean before(Object proxy, Object torget, Method method, Object[] args) {
        System.out.println("反射方法前逻辑");
        return false;//不反射被代理对象原有方法
    }

    @Override
    public void around(Object proxy, Object torget, Method method, Object[] args) {
        System.out.println("取代了被代理对象的方法");
    }

    @Override
    public void after(Object proxy, Object torget, Method method, Object[] args) {
        System.out.println("反射方法后逻辑");
    }
}
  • JDK动态代理与拦截器
package interceptor;

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

/**
 * @Auther: 洺润Star
 * @Date: 2019/9/12 20:30
 * @Description:
 */
public class InterceptorJdkProxy implements InvocationHandler {

    private Object target;//真实对象
    private String interceptorClass =null;//拦截器全限定名

    public InterceptorJdkProxy(Object target, String interceptorClass) {
        this.target = target;
        this.interceptorClass = interceptorClass;
    }

    /**
     * 绑定一个委托对象并返回一个【代理占位】
     * @param target 真实对象
     * @param interceptorClass 代理对象【占位】
     * @return
     */
    public  static Object bind(Object target, String interceptorClass){
        //取得代理对象
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),
                new InterceptorJdkProxy(target,interceptorClass));
    }

    /**
     * 通过代理对象调用方法，首先调用这个方法
     * @param proxy 代理对象
     * @param method 方法，被调用方法
     * @param args 方法的参数
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if (interceptorClass ==null){
            //如果没有拦截器，直接反射原有方法
            return method.invoke(target,args);
        }

        Object result = null;
        //通过反射生成拦截器
        Interceptor interceptor = (Interceptor)Class.forName(interceptorClass).newInstance();
        //调用前置方法
        if (interceptor.before(proxy,target,method,args)){
             result = method.invoke(target,args); //反射原有方法
        }else{//返回false则执行around方法
            interceptor.around(proxy,target,method,args);
        }
        //后置方法
        interceptor.after(proxy,target,method,args);
        return result;
    }


}
  • 测试类
package interceptor;

import agent.jdk.HelloWorld;
import agent.jdk.HelloWorldImpl;

/**
 * @Auther: 洺润Star
 * @Date: 2019/9/12 21:04
 * @Description:
 */
public class Test {
    public static void main(String[] args) {
        HelloWorld proxy = (HelloWorld) InterceptorJdkProxy.bind(new HelloWorldImpl(),"interceptor.MyInterceptor");
        proxy.sayHelloWorld();
    }
}

2.4责任链模式（多拦截器）

  • 创建三个拦截器，继承之前定义好的Interceptor
package interceptor.responsibilitychain;

import interceptor.Interceptor;

import java.lang.reflect.Method;

/**
 * @Auther: 洺润Star
 * @Date: 2019/9/13 10:15
 * @Description:
 */
public class Interceptor1 implements Interceptor {
    @Override
    public boolean before(Object proxy, Object torget, Method method, Object[] args) {
        System.out.println("拦截器一的before方法");
        return true;
    }

    @Override
    public void around(Object proxy, Object torget, Method method, Object[] args) {

    }

    @Override
    public void after(Object proxy, Object torget, Method method, Object[] args) {
        System.out.println("拦截器一的after方法");
    }
}


package interceptor.responsibilitychain;

import interceptor.Interceptor;

import java.lang.reflect.Method;

/**
 * @Auther: 洺润Star
 * @Date: 2019/9/13 10:15
 * @Description:
 */
public class Interceptor2 implements Interceptor {
    @Override
    public boolean before(Object proxy, Object torget, Method method, Object[] args) {
        System.out.println("拦截器二的before方法");
        return true;
    }

    @Override
    public void around(Object proxy, Object torget, Method method, Object[] args) {

    }

    @Override
    public void after(Object proxy, Object torget, Method method, Object[] args) {
        System.out.println("拦截器二的after方法");
    }
}


package interceptor.responsibilitychain;

import interceptor.Interceptor;

import java.lang.reflect.Method;

/**
 * @Auther: 洺润Star
 * @Date: 2019/9/13 10:15
 * @Description:
 */
public class Interceptor3 implements Interceptor {
    @Override
    public boolean before(Object proxy, Object torget, Method method, Object[] args) {
        System.out.println("拦截器三的before方法");
        return true;
    }

    @Override
    public void around(Object proxy, Object torget, Method method, Object[] args) {

    }

    @Override
    public void after(Object proxy, Object torget, Method method, Object[] args) {
        System.out.println("拦截器三的after方法");
    }
}
  • 下面测试责任链模式上的多拦截器
package interceptor.responsibilitychain;

import agent.jdk.HelloWorld;
import agent.jdk.HelloWorldImpl;
import interceptor.InterceptorJdkProxy;

/**
 * @Auther: 洺润Star
 * @Date: 2019/9/13 10:24
 * @Description:
 */
public class Test {
    public static void main(String[] args) {
        HelloWorld proxy1 = (HelloWorld) InterceptorJdkProxy.bind(new HelloWorldImpl(),"interceptor.responsibilitychain.Interceptor1");
        HelloWorld proxy2 = (HelloWorld) InterceptorJdkProxy.bind(proxy1,"interceptor.responsibilitychain.Interceptor2");
        HelloWorld proxy3 = (HelloWorld) InterceptorJdkProxy.bind(proxy2,"interceptor.responsibilitychain.Interceptor3");
        proxy3.sayHelloWorld();
        /*
            拦截器三的before方法
            拦截器二的before方法
            拦截器一的before方法
            hello,world
            拦截器一的after方法
            拦截器二的after方法
            拦截器三的after方法
        */
    }
}

三：观察者（Observer）模式(发布订阅模式)

观察者模式需要同时存在观察者和被观察者双方，其中观察者可以是多个，需要继承的类为java.util.Observable。下面代码定义了被观察 ，一个产品列表

package observer;

import java.util.ArrayList;
import java.util.List;
import java.util.Observable;
import java.util.Observer;

/**
 * @Auther: 洺润Star
 * @Date: 2019/9/13 10:59
 * @Description:
 */
public class ProductList extends Observable {
    private List<String> productList = null;//产品类表
    private static ProductList instance;//类唯一实例

    private ProductList() {
    }//构造方法私有化，避免通过new构造对象，而是通过getInstace方法获得产品列表，这里使用的是单例模式

    /**
     * 取得唯一实例
     * @return 产品列表唯一实例
     */
    public static ProductList getInstance(){
        if (instance == null){
            instance = new ProductList();
            instance.productList = new ArrayList<>();
        }
        return instance;
    }

    /**
     * 增加观察者（电商接口）
     * @param observer 观察着
     */
    public void addProductListObserver(Observer observer){
        this.addObserver(observer);
    }

    public void addProduct(String newProduct){
        productList.add(newProduct);
        System.out.println("产品列表更新了产品"+newProduct);
        this.setChanged();//设置被观察对象发生变化
        this.notifyObservers(newProduct);//通知观察者，并传递新产品
    }


}

下面定义观察者（需要实现java.util.Observer接口的update方法）：

  • 观察者一
package observer;

import java.util.Observable;
import java.util.Observer;

/**
 * @Auther: 洺润Star
 * @Date: 2019/9/13 15:46
 * @Description: 京东电商接口
 */
public class JingDongObserver implements Observer {
    @Override
    public void update(Observable o, Object arg) {
        String newProduct = (String) arg;
        System.out.println("发布新产品【"+newProduct+"】同步到京东商城");
    }
}
  • 观察者二
package observer;

import java.util.Observable;
import java.util.Observer;

/**
 * @Auther: 洺润Star
 * @Date: 2019/9/13 15:49
 * @Description:
 */
public class TaoBaoObserver implements Observer {
    @Override
    public void update(Observable o, Object arg) {
        String newProduct = (String) arg;
        System.out.println("发布新产品【"+newProduct+"】同步到淘宝商城");
    }
}

测试

package observer;

/**
 * @Auther: 洺润Star
 * @Date: 2019/9/13 15:50
 * @Description:
 */
public class Test {
    public static void main(String[] args) {
        ProductList observable = ProductList.getInstance();
        TaoBaoObserver taoBaoObserver = new TaoBaoObserver();
        JingDongObserver jingDongObserver = new JingDongObserver();
        observable.addObserver(taoBaoObserver);
        observable.addObserver(jingDongObserver);
        observable.addProduct("新增产品一");
        /*输出
        * 产品列表更新了产品新增产品一
          发布新产品【新增产品一】同步到京东商城
          发布新产品【新增产品一】同步到淘宝商城
        * */
    }
}

其中主方法中第四行和第五行是对被观察者注册观察者，这样才能让观察者监控到被观察者的变化

四：工厂模式和抽象工厂模式

4.1普通工厂模式

图示如下
在这里插入图片描述
其中IProduct下有五个实现类，其中用户可以通过编号来从工厂管理处获取需要的产品

4.2抽象工厂模式

抽象工厂可以先客户端提供一个接口，使得客户端在不必指定产品的具体情况下，创建多个产品族中的产品对象，其中建立一个工厂，该工厂能够封装和简化使用者的调用，而调用者无需知道具体工厂的规则，示意图如下：
在这里插入图片描述

五：建造者(Builder) 模式

Buidler模式是一种分步构造对象模式，已旅游套票为例，一次性构建套票对象较为困难，所以采用分步构造
在这里插入图片描述
用一个配置类对所有步骤进行统筹，然后将所有的信息交由构造器来完成构建对象
在这里插入图片描述
创建一个实例TicketHelper，作为配置类，它能一步步完成构建对象

package Builder;

/**
 * @Auther: 洺润Star
 * @Date: 2019/9/13 16:55
 * @Description:
 */
public class TicketHelper {
    public void  buildAdult(String info){
        System.err.println("构建成人票逻辑"+info);
    }

    public void buildChildrenForSeat(String info){
        System.err.println("构建有座儿童票逻辑"+info);
    }

    public void buildChildrenNoSeat(String info){
        System.err.println("构建无座儿童票逻辑"+info);
    }

    public void buildElderly(String info){
        System.err.println("构建老年人票逻辑"+info);
    }
    public void buildSoldier(String info){
        System.err.println("构建军人及其家属票逻辑"+info);
    }


}

构建类

package Builder;

/**
 * @Auther: 洺润Star
 * @Date: 2019/9/13 22:10
 * @Description:
 */
public class TicketBuilder {
    public static Object builder(TicketHelper helper){
        System.out.println("通过ticketHelper 构建套票信息");
        return null;
    }
}

测试

package Builder;

/**
 * @Auther: 洺润Star
 * @Date: 2019/9/13 22:13
 * @Description:
 */
public class Test {
    public static void main(String[] args) {
        TicketHelper helper = new TicketHelper();
        helper.buildAdult("成人票");
        helper.buildChildrenForSeat("有座儿童");
        helper.buildChildrenNoSeat("无座儿童");
        helper.buildAdult("成人票");
        helper.buildSoldier("军人及其家属票");
        Object ticket = TicketBuilder.builder(helper);

        /*
        * 构建成人票逻辑成人票
构建有座儿童票逻辑有座儿童
构建无座儿童票逻辑无座儿童
构建成人票逻辑成人票
构建军人及其家属票逻辑军人及其家属票
通过ticketHelper 构建套票信息
*/
    }
}
洺润
关注
专栏目录
韩顺平java源码-DesignPattern:设计模式
06-06
韩顺平java源码 DesignPattern 设计模式. 以java代码为例介绍一下内容 代码设计7个原则和23种设计模式。 采用常规设计 vs 采用设计模式的代码 + JDK中使用该设计模式的源码。 来源：韩顺平老师讲解：图解java设计模式
23种设计模式详解与示例代码（详解附DEMO）
沉淀、分享、成长，让自己和他人都能有所收获！
08-01 2万+
本文将探讨设计模式在Java中的应用与实现。设计模式是一套被广泛接受的解决常见软件设计问题的经典方法。在Java编程中，设计模式是提高代码可读性、可维护性和可扩展性的关键。本文将详细介绍Java中常用的几种设计模式，包括工厂模式、单例模式、观察者模式和装饰器模式，并提供具体的代码示例和解释，帮助读者深入理解和学习这些模式的实现方式。
Java之23种设计模式代码示例
print_helloword的博客
07-30 757
对Java23种设计模式应用场景给出代码示例
23 种设计模式（Java代码演示版）
RichardGeek的博客
08-17 6155
23 种设计模式集合（7万字长文-Java代码演示版）
23 种设计模式详解（全23种，含代码样例）
lgxzzz的博客
05-25 8559
设计模式的分类 总体来说设计模式分为三大类： 创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。 A、创建模式（5种） 工...
23种设计模式（java代码实现案例）
m0_55651862的博客
10-12 2383
23种设计模式（java代码实现案例）
设计模式示例代码(java)
04-18
设计模式示例代码(java)设计模式示例代码(java)v设计模式示例代码(java)设计模式示例代码(java)设计模式示例代码(java)设计模式示例代码(java)设计模式示例代码(java)设计模式示例代码(java)设计模式示例代码(java)...
Java设计模式 pdf 示例代码 刘伟
11-22
这是我见过的最好的设计模式讲解资料。为什么这么说呢？因为它不像其他的书籍那样，只讲解原理，还把每个设计模式的由来动机也讲解得很详细。它的讲解思路为：模式动机->模式定义->模式结构->模式分析（即原理）->...
Java设计模式代码，设计模式系列所有示例代码
04-24
本资源“Java设计模式代码，设计模式系列所有示例代码”为学习者提供了实际操作设计模式的宝贵机会，使理论与实践相结合，提升开发效率和代码质量。 首先，设计模式分为三大类：创建型、结构型和行为型。创建型模式...
读书笔记：java设计模式示例代码《设计模式从入门到精通》.zip
07-19
读书笔记：java设计模式示例代码《设计模式从入门到精通》
基于Java设计模式的示例项目.zip
最新发布
09-06
基于Java设计模式的示例项目 内容概要 本项目是一个基于Java设计模式的示例项目，涵盖了创建型、结构型和行为型设计模式。项目通过多个示例展示了如何使用这些设计模式来解决常见的软件设计问题。每个示例都包含...
23种设计模式及java代码展示
lycheewsh的博客
09-13 252
【代码】23种设计模式及java代码展示。
Java的23种设计模式
初心不忘、始终方得
09-01 5646
大话java23种设计模式，通俗易懂
设计模式代码实现（java）
GTC的博客
10-27 1019
java实现设计模式
设计模式——单例懒汉JAVA代码实现
weixin_44080187的博客
03-19 1002
设计模式——单例懒汉JAVA代码实现
Java中23种设计模式
热门推荐
呜呜老司机的博客家园
10-10 8万+
Java中23种设计模式，包括简单介绍，适用场景以及优缺点等
Java 23种设计模式介绍以及代码示例 第一篇创建型设计模式
小电玩
10-18 248
Java 23种设计模式介绍以及代码示例 第一篇创建型设计模式 创建型模式:单例模式,简单工厂模式,工厂方法模式,抽象工厂模式,原型模式,建造者模式 结构型模式:适配器模式,桥接模式,组合模式,装饰器模式,外观模式,享元模式,代理模式 行为型模式:观察者模式,模板方法模式,命令模式,迭代器模式,解释器模式,中介者模式,备忘录模式,状态模式,策略模式,职责链模式,访问者模式
23种设计模式-最详细篇（附含代码）
qq_43107323的博客
03-12 1041
1.单例模式（Singleton Pattern） 定义：Ensure a class has only one instance, and provide a global point of access to it.（确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。） 通用代码：（是线程安全的） public class Singleton { private s...
java常用的设计模式附代码
beipiao_yizu的博客
03-21 358
设计模式是软件工程中的一种最佳实践，用于解决在软件设计中遇到的常见问题。以下是一些常用的设计模式及其Java示例代码。当然可以，下面是带有中文注释的常用设计模式示例代码。
Java设计模式实战：图解+代码示例
"Java设计模式 图解 附代码" 这篇资料详细介绍了Java设计模式，旨在帮助开发者更好地理解和应用设计模式。设计模式是软件工程中经过长期实践总结出的通用问题解决方案，它们代表了最佳实践，使得代码更具可读性、可...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值