Java进阶13讲__补充2/2

最新推荐文章于 2024-09-13 21:40:38 发布
最新推荐文章于 2024-09-13 21:40:38 发布
阅读量278 收藏 1
点赞数 4
分类专栏： Java进阶13讲 文章标签： java 开发语言 设计模式 饿汉式单例模式 饱汉式单例模式 动态代理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/XiaomeiGuiSnJs/article/details/142200112
版权

1.  设计模式

1.1  什么是设计模式

1.2  单例设计模式

package com.itheima.a_单例_饿汉式;

public class T1 {
    public static void main(String[] args) {

        new Thread(new Runnable() {
            @Override
            public void run() {
                Demo demo = Demo.createDemo();
                System.out.println(Thread.currentThread() + "::" + demo);
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                Demo demo1 = Demo.createDemo();
                System.out.println(Thread.currentThread() + "::" + demo1);
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                Demo demo1 = Demo.createDemo();
                System.out.println(Thread.currentThread() + "::" + demo1);
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                Demo demo1 = Demo.createDemo();
                System.out.println(Thread.currentThread() + "::" + demo1);
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                Demo demo1 = Demo.createDemo();
                System.out.println(Thread.currentThread() + "::" + demo1);
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                Demo demo1 = Demo.createDemo();
                System.out.println(Thread.currentThread() + "::" + demo1);
            }
        }).start();
    }
}

class Demo {
    private static final Demo demo = new Demo();

    public static final Demo createDemo() {
        return demo;
    }

    private Demo() {
    }

    private String name;
    private int age;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

1.3  懒汉式单例设计模式

package com.itheima.b_单例_懒汉式;

/*
单例设计模式
    作用：确保一个类只有一个对象。
    场景：计算机中的回收站、任务管理器、Java中的Runtime类等

懒汉式(第一次获取时创建对象)
    把类的构造器私有（保证别人不能new）
    在类中定义一个类变量用于存储对象(注意:此时只定义,不创建)
    提供一个类方法，在方法中创建并返回对象(要保证只创建一次)

注意
    获取方法需要使用synchronized修饰,以保证只有一个线程可以成功创建出对象
*/
public class Demo {
    //在类中定义一个类变量用于存储对象(注意:此时只定义,不创建)
    private static volatile Demo demo;

    //提供一个类方法，在方法中创建并返回对象(要保证只创建一次)
    public static Demo createDemo() {
        if (demo == null) {
            synchronized (Demo.class) {
                if (demo == null) {
                    demo = new Demo();
                }
            }
        }
        return demo;
    }

    //把类的构造器私有（保证别人不能new）
    private Demo() {
    }
}

package com.itheima.b_单例_懒汉式;

public class T1 {
    public static void main(String[] args) {
        while (true) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    Demo demo = Demo.createDemo();
                    System.out.println(Thread.currentThread() + "::" + demo);
                }
            }).start();
        }


    }
}

1.4  枚举实现单例模式

package com.itheima.c_单例_枚举实现;

import java.sql.SQLOutput;

/*
单例设计模式
    作用：确保一个类只有一个对象。
    场景：计算机中的回收站、任务管理器、Java中的Runtime类等

枚举实现单例
    直接在枚举中提供一个枚举项就可以实现单例

注意
    Google首席Java架构师、(Effective Java》 一书作者Java集合框架的开创者Joshua Bloch在Effective Java一书中提到
        单元素的枚举类型，已经成为实现singleton的最佳方法
        在这种实现方式中，既可以避免多线程同步问题
        还可以防止通过反射和反序列化来重新创建新的对象
        在很多优秀的开源代码中，我们经常可以看到使用枚举方式来实现的单例模式类
*/
public class Demo {
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Animal.SunQing.hashCode());
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Animal.SunQing.hashCode());
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Animal.SunQing.hashCode());
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Animal.SunQing.hashCode());
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Animal.SunQing.hashCode());
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Animal.SunQing.hashCode());
            }
        }).start();
    }
}
enum Animal{
    SunQing
}

2.  动态代理

2.1  入门案例 

ProxyUtil.java

package com.itheima.d_动态代理_入门;

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

/**
 * 代理工具类，生成代理对象
 */
public class ProxyUtil {
    /**
     * 创建zxr代理对象
     *
     * @return
     */
    public static Star returnObject(Star item) {
        //获取被代理类对象//参数传入
        //编写代理类业务逻辑
        InvocationHandler handler = new InvocationHandler() {
            /**
             * @param proxy  生成的代理对象
             * @param method 调用代理对象的方法名字
             * @param args   参数
             * @return
             * @throws Throwable
             */
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                String methodName = method.getName();
                if (methodName.equals("sing")) {
//                执行method唱歌
                    System.out.println("经纪人准备话筒，收钱");
                    Object obj = method.invoke(item, args);
                    return obj;
                } else {
//                执行method跳舞
                    System.out.println("经纪人准备场地，收钱");
                    Object obj = method.invoke(item, args);
                    return obj;
                }
            }
        };
        //生成代理类对象
        Object obj = Proxy.newProxyInstance(
                item.getClass().getClassLoader(),
                item.getClass().getInterfaces(),
                handler
        );
        //返回代理类对象
        return (Star) obj;
    }
}

Star.interface

package com.itheima.d_动态代理_入门;

//明星接口
public interface Star {
    String sing(String name);

    /**
     * 跳舞
     */
    void dancing();
}

ZXR.java

package com.itheima.d_动态代理_入门;

//Sakream实现类
public class ZXR implements Star {

    @Override
    public String sing(String name) {
        System.out.println("zxr开始唱歌，歌名：" + name);
        return name;
    }

    @Override
    public void dancing() {
        System.out.println("zxr开始跳舞");
    }
}

Test.java

package com.itheima.d_动态代理_入门;

public class Test {
    public static void main(String[] args) {
//        创建被代理对象
        ZXR zxr = new ZXR();
//        创建代理对象
        Star star = ProxyUtil.returnObject(zxr);
//        调用代理对象干活
        star.sing("罗生门");
        star.dancing();
    }
}

2.2  业务案例

UserService.interface

package com.itheima.e_动态代理_案例;

/**
 * 用户业务接口
 */
public interface UserService {
    // 登录功能
    void login(String loginName, String passWord) throws Exception;

    // 删除用户
    void deleteUsers() throws Exception;

    // 查询用户，返回数组的形式。
    String[] selectUsers() throws Exception;
}

UserServiceImpl.java

package com.itheima.e_动态代理_案例;

/**
 * 用户业务实现类
 */
public class UserServiceImpl implements UserService {
    @Override
    public void login(String loginName, String passWord) throws Exception {
        if ("admin".equals(loginName) && "123456".equals(passWord)) {
            System.out.println("您登录成功，欢迎光临本系统~");
        } else {
            System.out.println("您登录失败，用户名或密码错误~");
        }
        Thread.sleep(1000);
    }

    @Override
    public void deleteUsers() throws Exception {
        System.out.println("成功删除了1万个用户~");
        Thread.sleep(1500);
    }

    @Override
    public String[] selectUsers() throws Exception {
        System.out.println("查询出了3个用户");
        String[] names = {"张全蛋", "李二狗", "牛爱花"};
        Thread.sleep(500);
        return names;
    }
}

ProxyUtils.java

package com.itheima.e_动态代理_案例;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;
import java.util.Date;

public class ProxyUtils {
    public static UserService createProxy(UserService impl) {
        InvocationHandler invocationHandler = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//                调用代理对象的名字
                String methodName = method.getName();
//                计时
                long begin = System.currentTimeMillis();
//                执行方法
                if (methodName.equals("login")) {
//                    记录用户登录日志
                    System.out.println(new Date() + "--" + Arrays.toString(args) + "用户登录了");
                }
                Object obj = method.invoke(impl, args);
//                结束
                long end = System.currentTimeMillis();
                long longTime = end - begin;
                System.out.println(methodName + "方法执行了：[" + longTime + "毫秒]");
                return obj;
            }
        };
        UserService us = (UserService) Proxy.newProxyInstance(
                impl.getClass().getClassLoader(),
                impl.getClass().getInterfaces(),
                invocationHandler
        );
        return us;
    }
}

Test.java

package com.itheima.e_动态代理_案例;

import java.util.Arrays;

/**
 * 目标：使用动态代理解决实际问题，并掌握使用代理的好处。
 */
public class Test {
    public static void main(String[] args) throws Exception {
        // 1、创建用户业务对象
        UserService userService = new UserServiceImpl();
        UserService proxy = ProxyUtils.createProxy(userService);
        proxy.login("admin", "123456");
        proxy.deleteUsers();
        String[] names = proxy.selectUsers();
        System.out.println("查询到的用户是：" + Arrays.toString(names));
        System.out.println("----------------------------------");
    }
}
不再会有谎言
关注
专栏目录
Java进阶学习
web15185420056的博客
07-29 231
这里的意思是，第五章的那些API你不要去记也没必要，你只要知道它有这么个用途，能决绝什么问题就可以了，具体的API说个名字或者名字说不出来也没关系，面试官一般不会纠结与API的名字，更想提到你对某个知识点自己的理解。——这本书通俗易懂，第5章可以不看，其余建议看。——更重要的是，如果面试官在问你设计模式的时候，你能详细说出几种常用的设计模式，并且给出在JDK或spring或其他框架源码中的应用，以及该模式解决了什么问题之类的，这肯定是加分项，面试官会认为你知识体系结构很完善，对你的印象肯定更加深刻。...
java数据库的量级_Java进阶——亿级网站大数据量下的高并发同步讲解
weixin_34947914的博客
12-31 205
原标题：Java进阶——亿级网站大数据量下的高并发同步讲解对于我们开发的网站，如果网站的访问量非常大的话，那么我们就需要考虑相关的并发访问问题了。而并发问题是绝大部分的程序员头疼的问题，但话又说回来了，既然逃避不掉，那我们就坦然面对吧~今天就让我们一起来研究一下常见的并发和同步吧。为了更好的理解并发和同步，我们需要先明白两个重要的概念:同步和异步1、同步和异步的区别和联系所谓同步，可以理解为在执行...
Java进阶13讲__第十讲
I am the light coursing in the soul of the moon.
09-06 1341
IO流、File
Java进阶13讲__第八讲
I am the light coursing in the soul of the moon.
09-01 1050
集合：单列集合Collection；双列集合Map
Java进阶13讲___第二讲
I am the light coursing in the soul of the moon.
08-04 364
多态- -抽象类- -接口
Java进阶13讲__第12讲_1/2
I am the light coursing in the soul of the moon.
09-09 1099
多线程 线程池 线程通信
java进阶路线_小白学java进阶工程师路线图
weixin_39855796的博客
02-22 1071
原标题：小白学java进阶工程师路线图Java小白如何成长为Java大牛？这9点你做到了几点！给刚进社会的程序员新生一个建议，想成为一个优秀的程序员，高级程序员，不能眼高手低，不能认为开发新项目，技术研发才学到东西，不能看不起基本功的学习，每一个大牛都是一步步的晋级的，本文天津达内Java小编介绍如何成为高级Java工程师。1、Java要想成为Java(高级)工程师肯定要学习Java。一般的程序员...
重学Java - 进阶(1/2)
backups
11-22 638
引言 【因内容较多，将拆分为两篇博文，此为篇一】 本篇博文为 Java 的一些高级特性的常见概念及相关细节梳理，意在重学 Java 查漏补缺。 博文随时会进行更新，补充新的内容并修正错漏，该系列博文旨在帮助自己巩固扎实 Java 基础。 毕竟万丈高楼，基础为重，借此督促自己时常温习回顾。 多线程 概念 程序、进程、线程 **程序(Program)：**为完成特定任务，使用某种编程语言编写的一组指令的集合。即指一段静态的代码，静态对象 **进程(Process)：**指程序的一次执行过程，或是正在运行的一个程
java架构师进阶之路
henhenha的博客
03-30 3690
包含了计算机基础、算法和数据结构、常用工具、java核心知识、性能优化、基础框架、数据库、消息队列、缓存中间件、搜索引擎、大数据、RPC、网关、容器、面试等知识
JAVA进阶必看目录
helloGirl
03-03 291
JAVA 面试题总览1. JAVA 基础 1. JAVA 中的几种基本数据类型是什么，各自占用多少字节。 2. String 类能被继承吗，为什么。 3. String，Stringbuffer，StringBuilder 的区别。 4. ArrayList 和 LinkedList 有什么区别。 5. 讲讲类的实例化顺序，比如父类静态数据，构造函数，字段，子类静态数据，构造函数，字...
spring事务详细讲解-深入浅出
小电玩
09-08 519
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1504
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
自动生成不重复的订单id
ClaireCheney的博客
09-13 132
【代码】自动生成不重复的订单id。
Java集合：Stack详解
yang_brother的博客
09-10 568
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
币安/OK现货合约量化系统APP开发
I592O929783的博客
09-08 599
后端：考虑系统需要处理大量实时数据和高频交易的特点，选择高性能的编程语言和技术框架，如Python的Django或Flask框架，Java的Spring Boot等。用户交互界面：设计直观易用的用户交互界面，包括交易界面、策略配置界面、风险管理界面等，方便用户进行交易操作、策略配置和风险管理。市场数据接入：开发市场数据接入模块，从币安等交易所或数据服务商获取实时的市场数据，包括行情数据、订单簿数据、成交数据等。前端：选择适合开发复杂界面的前端框架，如React、Vue.js等，以提供用户友好的交互界面。
基于SpringBoot的考研资讯平台设计与实现
最新发布
linzhongshu的专栏
09-13 511
对于本次的系统开发来看，它主要是把我以前所学的知识进行了一次综合的应用。经过这次毕业设计的制作它主要是把我以前所学的理论知识应用到社会实践当中。通过这一次的考研资讯平台的设计与实现它能够有效把计算机知识与实际问题相互应用，通过计算机网络技术来解决学生生活当中的实际问题，从而提高我的编程能力。虽然在这次毕业设计当中我遇到了很多的问题和困难，但是通过不断的调试和老师的帮助让我圆满的完成了这次毕业设计。
Linux服务器Java启动脚本
Jack魏
09-08 568
本文章介绍了如何在Linux服务器上执行Java并启动jar包，通常我们会使用nohup直接启动，但是还是需要手动停止然后再次启动，那如何更优雅的在服务器上启动jar包呢，让我们一起探讨一下吧。
MyBatis面试
Tony_yitao的博客
09-09 769
MyBatis面试
springboot数据库连接由localhost改成IP以后访问报错500（2024/9/7
不起眼小菜菜的博客
09-07 362
步骤很详细，直接上教程……
Java TCP/IP Socket编程全面指南：从基础到进阶
本资源主要涵盖了Java TCP/IP套接字编程的全面教程，分为五个章节，深入讲解了计算机网络基础知识、套接字原理以及在Java中的具体应用。 第1章介绍了计算机网络的基本概念，包括分组报文和协议，以及客户端与服务器...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值