案例18-案例开门小例子面向对象演化

已于 2023-07-26 17:33:31 修改
阅读量453 收藏 1
点赞数
分类专栏： AR项目总结 文章标签： java 反射 面向对象
于 2023-03-17 21:02:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45706856/article/details/129627465
版权

目录

一：背景介绍

现在公司对高端人才的需求越来越大，我们不止需要如何写面向过程的代码，还要知道面向对象的代码怎么写，于是以一个简单的业务场景来理解由面向过程到面向对象是如何进行转换的
在这里插入图片描述

二：思路&方案

1.面向过程的实现思路

在这里插入图片描述

public class Client {
    public static void main(String[] args) {
        System.out.println("我是米老师，我需要开门");
        System.out.println("好的，米老师，我马上给您开门");
    }
}

在这里插入图片描述

2.面向对象的实现思路一（封装）

首先进行封装，这个开门业务可以抽象出来两个角色，发消息人类和收消息人类，为了业务需要，我们还有一个业务隔离类，还有一个客户端，下图是两种依赖方式。被依赖的人都是自由的。
在这里插入图片描述
举例子：
接收人依赖于发消息人

发送消息人：

public class sendMessager {
    public void sendMessage(){
        System.out.println("我是米老师：我需要开门");
    }
}

接收消息人：

public class receiveMessager {
    private void openDoor(){
        System.out.println("我是何老师：我来开门了");
    }
    public void receiveMessage(sendMessager teacherMi){
        teacherMi.sendMessage();
        this.openDoor();
    }
}

业务封装类：

1、进行业务封装。这个类中的private方法只能通过public方法对外使用，保证了安全，客户端只能访问对外公的方法。
2、可扩充（运算符重载）
3、安全性。

public class Notice {
    private void business(){
        receiveMessager teacherHe = new receiveMessager();
        teacherHe.receiveMessage(new sendMessager());
    }
    public void notice(){
        this.business();
    }
}

客户端类：

public class Client {
    public static void main(String[] args) {
        Notice notice = new Notice();
        notice.notice();
    }
}

实现效果：

在这里插入图片描述

重载版本

发消息人

public class Mi {
    public  void  sendMessage(Object object)
    {
        He he = new He();
        //米老师给何老师发消息，米老师依赖何老师
        System.out.println("何老师过来开门");
        he.getMessage(object);
    }

}

接收消息人

public class He {
    private  void  openDoor()
    {
        System.out.println("跑着开门");
    }
    private  void  openDoor(String doorName)
    {
        System.out.println("跑着开"+doorName);
    }
    private  void  openDoor(int once)
    {

        System.out.println("第"+once+"次跑着开门");
    }

    public  void getMessage(Object object)
    {
        if (!object.equals(" ") )
        {
            //如果包含数字
            if (object.toString().matches("[0-9]")){
                object = Integer.parseInt(object.toString());
            }
            String type = object.getClass().getTypeName();
            switch(type)
            {
                case"java.lang.String":this.openDoor(object.toString());
                break;
                case"java.lang.Integer":this.openDoor(Integer.parseInt(object.toString()));
                break;
            }
        }
        //要是没有输入就直接开门，调用无参的方法
        else
        {
            this.openDoor();
        }

    }
}

业务封装类

public class Process {

    private  void start(Object object)
    {
       Mi mi = new Mi();
       mi.sendMessage(object);
    }
    public  void notice(Object object)
    {
        this.start(object);
    }
}

客户端类

public class Client {
    public static void main(String[] args) {
        System.out.println("请输入门的信息");
        Scanner scanner = new Scanner(System.in);
        //可以读空格  next是没有办法读空格的
        Object data = scanner.nextLine();
        Process process = new Process();
        process.notice(data);

    }
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

3、事件与委托版（C#版米老师何老师）

在这里插入图片描述

委托类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ebtrust1
{
    public class CatShoutEventArgs : EventArgs
    {
        private string name;
        public string Name
        {
            get { return name; }
            set { name = value; }
        }
    }
}

接收消息类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ebtrust1
{
    public  class GetMessager
    {
        private string name;
        public GetMessager(string name)
        {
            this.name = name;
        }

        public void getMessage(object sender,CatShoutEventArgs args)
        {
            Console.WriteLine("{0}来了,{1}来开门",args.Name,name);
        
        }
        
    }
}

业务封装类


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ebtrust1
{
    public  class Notice
    {
        private void process()
        {
            SendMessager Mi = new SendMessager("米老师");
            GetMessager He = new GetMessager("何老师");

          //  PrentendGetMessager deaf = new PrentendGetMessager("聋子");

            Console.WriteLine("第一个委托---------------------------------------------------");
            Mi.openDoorEvent += new SendMessager.openDoorEventHandler(He.getMessage);
            Mi.sendMessage();


            Console.Read();

        }

        public void notice()
        {
            this.process();
        
        }

    }


}

发送消息人类


using ebtrust1;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ebtrust1
{
    public class SendMessager
    {
        private string name;
        public SendMessager(string name)
        {
            this.name = name;
        }

        public delegate void openDoorEventHandler(object sender, CatShoutEventArgs args);
        public openDoorEventHandler openDoorEvent;
     
        private void sendMessage1Formly()
        {
            Console.WriteLine("我是{0}，请给我开门", name);
            if (openDoorEvent != null)
            {
              CatShoutEventArgs e = new CatShoutEventArgs();
                e.Name = this.name;
                openDoorEvent(this,e);
            }

        }

        public void sendMessage()
        {
            this.sendMessage1Formly();
        }

       

    }
}

客户端：

namespace ebtrust1
{
    class Program
    {
        public static void Main(string[] args)
        {
            Notice notice = new Notice();
            notice.notice();

        }

    }
}

多个委托多个事件

在这里插入图片描述

在这里插入图片描述

接收消息类：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace entrust
{
    public class GetMessager
    {
        private string name;
        public GetMessager(string name)
        {
            this.name = name;
        }
        private void openDoor1Formly()
        {
            Console.WriteLine("有人请求开门1，{0}来开门1",name);
        }
        private void openDoor2Formly()
        {
            Console.WriteLine("有人请求开门2，{0}来开门2", name);
        }
        private void closeDoor1Formly()
        {
            Console.WriteLine("有人请求关门1，{0}来关门1", name);
        }

        private void closeDoor2Formly()
        {
            Console.WriteLine("有人请求关门2，{0}来关门2", name);
        }

        public void openDoor1()
        {
            this.openDoor1Formly();
        }

        public void openDoor2()
        {
            this.openDoor2Formly();
        }
        public void closenDoor1()
        {
            this.closeDoor1Formly();
        }


        public void closenDoor2()
        {
            this.closeDoor2Formly();
        }



    }
}

发送消息人类：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace entrust
{
    public  class SendMessager
    {
        private string name;
        public SendMessager(string name)
        {
            this.name = name;
        }
        //第一个委托有多个事件
        public delegate void SendMessagerOpenDoorHandler();
        public event SendMessagerOpenDoorHandler sendMessagerOpenDoor1;
        public event SendMessagerOpenDoorHandler sendMessagerOpenDoor2;

        //第二个委托
        public delegate void SendMessagerCloseDoorHandler();
        public event SendMessagerCloseDoorHandler sendMessagerCloseDoor1;
        public event SendMessagerCloseDoorHandler sendMessagerCloseDoor2;
        private void noticeOpenDoor1Formly()
        {
            Console.WriteLine("我是{0}，给我开门1", name);
            if (sendMessagerOpenDoor1 != null)
            {
                sendMessagerOpenDoor1();

            } 
        }
        private void noticeOpenDoor2Formly()
        {
            Console.WriteLine("我是{0}，给我开门2", name);
            if (sendMessagerOpenDoor2 != null)
            {
                sendMessagerOpenDoor2();

            }

        }
        private void noticeCloseDoor1Formly()
        {
            Console.WriteLine("我是{0}，帮我关门1", name);
            if (sendMessagerCloseDoor1 != null)
            {
                sendMessagerCloseDoor1();

            }

        }

        private void noticeCloseDoor2Formly()
        {
            Console.WriteLine("我是{0}，帮我关门2", name);
            if (sendMessagerCloseDoor2 != null)
            {
                sendMessagerCloseDoor2();

            }

        }
        public void noticeOpenDoor1()
        {
            this.noticeOpenDoor1Formly();
        }
        public void noticeOpenDoor2()
        {
            this.noticeOpenDoor2Formly();
        }

        public void noticeCloseDoor1()
        {
            this.noticeCloseDoor1Formly();
        }
        public void noticeCloseDoor2()
        {
            this.noticeCloseDoor2Formly();
        }

    }
}


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace entrust
{
    public class Rabbit
    {
        public string name;
        public Rabbit(string name)
        {
            this.name = name;
        }
        private void noOpenDoor1Formly()
        {
            Console.WriteLine("有人请求开门1，{0}害怕我就跑，我不给你开门1", name);
        }
        private void noOpenDoor2Formly()
        {
            Console.WriteLine("有人请求开门2，{0}害怕我就跑，我不给你开门2", name);
        }
        private void noClosenDoor1Formly()
        {
            Console.WriteLine("有人请求关门1，{0}害怕我就跑，我不给你开门1", name);
        }

        private void noClosenDoor2Formly()
        {
            Console.WriteLine("有人请求关门2，{0}害怕我就跑，我不给你开门2", name);
        }



        public void noOpenDoor1()
        {
           this.noOpenDoor1Formly();
        }
        public void noOpenDoor2()
        {
            this.noOpenDoor2Formly();
        }
        public void noClosenDoor1()
        {
            this.noClosenDoor1Formly();
        }

        public void noClosenDoor2()
        {
            this.noClosenDoor2Formly();
        }
    }


}

事件类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ebtrust1
{
    public class CatShoutEventArgs : EventArgs
    {
        private string name;
        public string Name
        {
            get { return name; }
            set { name = value; }
        }
    }
}

业务封装类


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace entrust
{
    public class Notice
    {
        private void process()
        {
            Rabbit rbWhite = new Rabbit("小白兔");
            SendMessager teacherFan = new SendMessager("饭老师");
            SendMessager teacherMi = new SendMessager("米老师");
            GetMessager studentZhao = new GetMessager("赵媛");
            GetMessager studentLi = new GetMessager("李媛");
            GetMessager studentDeng = new GetMessager("邓媛");

            Console.WriteLine("第一个委托有两个事件--------------这里的每个事件都对应两个对象的方法");
            teacherMi.sendMessagerOpenDoor1 += new SendMessager.SendMessagerOpenDoorHandler(studentZhao.openDoor1);
            teacherMi.sendMessagerOpenDoor1 += new SendMessager.SendMessagerOpenDoorHandler(studentLi.openDoor1);
            teacherMi.sendMessagerOpenDoor1 += new SendMessager.SendMessagerOpenDoorHandler(rbWhite.noOpenDoor1);
            teacherMi.sendMessagerOpenDoor2 += new SendMessager.SendMessagerOpenDoorHandler(studentZhao.openDoor2);
            teacherMi.sendMessagerOpenDoor2 += new SendMessager.SendMessagerOpenDoorHandler(studentLi.openDoor2);
            teacherMi.sendMessagerOpenDoor2 += new SendMessager.SendMessagerOpenDoorHandler(rbWhite.noOpenDoor2);

            teacherFan.sendMessagerOpenDoor1 += new SendMessager.SendMessagerOpenDoorHandler(studentZhao.openDoor1);
            teacherFan.sendMessagerOpenDoor1 += new SendMessager.SendMessagerOpenDoorHandler(studentLi.openDoor1);
            teacherFan.sendMessagerOpenDoor2 += new SendMessager.SendMessagerOpenDoorHandler(studentZhao.openDoor2);
            teacherFan.sendMessagerOpenDoor2 += new SendMessager.SendMessagerOpenDoorHandler(studentLi.openDoor2);
            teacherFan.sendMessagerOpenDoor1 += new SendMessager.SendMessagerOpenDoorHandler(studentDeng.openDoor1);
            teacherFan.sendMessagerOpenDoor2 += new SendMessager.SendMessagerOpenDoorHandler(studentDeng.openDoor2);

            teacherMi.noticeOpenDoor1();
            teacherMi.noticeOpenDoor2();
            teacherFan.noticeOpenDoor1();
            teacherFan.noticeOpenDoor2();

            Console.WriteLine("第二个委托有2个事件---------------这里的每个事件都对应两个对象的方法");
            teacherMi.sendMessagerCloseDoor1 += new SendMessager.SendMessagerCloseDoorHandler(studentZhao.closenDoor1);
            teacherMi.sendMessagerCloseDoor1 += new SendMessager.SendMessagerCloseDoorHandler(studentLi.closenDoor1);
            teacherMi.sendMessagerCloseDoor2 += new SendMessager.SendMessagerCloseDoorHandler(studentZhao.closenDoor2);
            teacherMi.sendMessagerCloseDoor2 += new SendMessager.SendMessagerCloseDoorHandler(studentLi.closenDoor2);

            teacherMi.noticeCloseDoor1();
            teacherMi.noticeCloseDoor2();

            Console.Read();
        }

        public void notice()
        {
            this.process();
        }
    }
}


namespace entrust
{
    class Program { 
    public static void Main(string[] args)
    {
        Notice notice = new Notice();
        notice.notice();

    }

    }
}

在这里插入图片描述

4.面向对象的实现思路（封装、反射）

在这里插入图片描述

public class SendMessager {
    public void sendMessage(String className,String methodName) throws Exception{
        System.out.println("米老师发消息======");
        //通过反射获取对象和方法
        Class classObj = Class.forName(className);
        Object teacherHe = classObj.newInstance();
        Method methodObj = classObj.getMethod(methodName);
        methodObj.invoke(teacherHe,null);
    }
}


public class ReceiveMessager {
    private void openDoor(){
        System.out.println("接收消息的人：好的，已开门");
    }
    public void receiveMessage(){
        this.openDoor();
    }
}


public class Notice {
    private void business(String className,String methodName) throws Exception{
        SendMessager sendMessager = new SendMessager();
        sendMessager.sendMessage(className, methodName);
    }
    private void getParam() throws  Exception{
        //通过new Scanner(System.in)创建一个Scanner类型的名叫scanner的对象，
        //控制台会一直等待输入，直到敲回车键结束，把所输入的内容传给scanner
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入类名");
        //nextLine()方法的作用时获取当前行的输入内容，
        //返回得到的是回车键之前的所有字符，包括空格
        String className = scanner.nextLine();
        System.out.println("请输入方法名");
        String methodName = scanner.nextLine();
        this.business(className, methodName);
    }
    public void notice() throws Exception{
        this.getParam();
    }
}


public class Client {
    public static void main(String[] args) throws Exception {
        Notice notice = new Notice();
        notice.notice();
    }
}

在这里插入图片描述

四：总结

面向过程写法只能满足两个人
封装类以后可以通过实例化实现多个人发消息，多个人监听
使用反射以后可以再运行时传参，更加灵活。
“我们关注的是谁来干事，而不是怎么干事”
“我们关注的是多少人来干事，而不是干多少事”

继续深思吧~

使用事件与委托（Events and Delegates）是面向对象编程中常用的设计模式之一，它有许多好处，让我们来看看其中一些主要的优点：

解耦合（Decoupling）: 事件与委托模式可以实现对象之间的解耦合。当一个对象需要通知其他对象发生了某个事件时，它只需要触发相应的事件，而不需要关心哪些对象会响应这个事件以及如何处理。其他对象也只需要订阅感兴趣的事件，而不需要关心事件是由哪个对象触发的。这样，对象之间的依赖关系得到了简化，使得代码更加灵活和可维护。

扩展性（Extensibility）: 通过事件与委托，我们可以很容易地在不修改已有代码的情况下添加新的功能。当需要添加新的处理逻辑时，只需要编写一个新的方法来处理相应的事件，并订阅这个事件即可。这样，我们可以在不破坏原有功能的基础上，实现功能的扩展和定制。

灵活性和可复用性（Flexibility and Reusability）: 事件与委托模式提供了一种灵活的机制来处理事件和回调逻辑。通过委托，我们可以在运行时动态地将方法绑定到事件上，使得事件处理逻辑可以更加灵活和通用。这样，我们可以在不同的场景中复用同一个事件，并为每个场景提供不同的处理逻辑。

代码可读性（Code Readability）: 事件与委托模式可以使代码更加简洁和可读。当一个对象触发一个事件时，我们可以直接看到该事件的处理逻辑是通过委托调用的，而不需要详细了解事件的具体实现细节。这样，代码的逻辑更加清晰，易于理解和维护。

事件驱动（Event-Driven）编程: 事件与委托模式是事件驱动编程的基础。在事件驱动编程中，程序的执行流程由事件的发生和处理驱动，而不是通过顺序执行的方式。这种编程方式更加符合现实世界的行为模式，使得代码更加灵活和响应性。

总的来说，事件与委托是一种强大的编程模式，它提供了一种灵活、松耦合的方式来处理事件和回调逻辑。通过使用事件与委托，我们可以实现解耦合、扩展性、灵活性、可复用性和代码可读性等优点，使得代码更加优雅、高效和易于维护。

Circ.
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 6
    评论
专栏目录
java芝麻开门博客网
06-16
Java芝麻开门博客网项目是一种基于Java语言开发的在线博客分享平台。该平台拥有多种功能，包括博客发布、文章分类、评论互动等，旨在促进用户信息共享、社交互动。该博客平台采用Java基础框架，对个性化的博客模板和界面进行了定制化，提供高效、便捷、舒适的写作体验。 Java芝麻开门博客网适用于喜欢写作及分享的个人、博客作者等用户。可以在该平台上发布自己的博客、分享观点、参与评论和互动，建立私人或专业博客，并通过博客吸引访问者与更多读者互动。 该平台的使用场景包括：博客写作、博客信息分享、博客评论等。用户可以利用该平台发布文章获取较多流量和关注度，增加自己的个人品牌影响力。 Java芝麻开门博客网的目标是为作者提供一个安全、高效地撰写发表和互动的平台，同时为广大读者提供更多高质量的文章和内容资源，促进博客作者和读者之间的信息交流和互动。
开门动画
12-09
开门动画
案例18-面向对象之开门小例子
武梓龙 廊坊师范学院信息技术提高班 十七期
03-11 383
面向过程和面向对象没有好坏之分，只是应用的场景不同。我们之所以要用面向对象的思想是因为我们要为后期的维护考虑，这样我们就需要写出来的代码容易扩展，复用性强。在面向对象的基础上使用反射，使我们的系统更加的灵活，在运行的过程中我们可以让给来开门都可以。
项目实战18—面向对象的开门小例子
qq_44685392的博客
03-16 279
1.利用抽象、封装、消息监听、事件和委托的形式，抽象出来的四个类分别是：发消息人类、收消息人类、业务处理类、客户端。1.一个现实中常见的业务场景：米老师需要进入办公室，需要何老师帮忙开门，或者说需要一个开门的人。对于这个业务场景进行抽象的话，可以抽象出四个类：发消息人类、收消息人类、业务处理类、客户端。2.面向过程的思路：何老师告诉米老师钥匙在哪里，然后米老师去取了钥匙，最后去开门。2.面向对象加入反射的形式（不再被人所局限，更加灵活），同样抽象出四个类。2.我们注重的是有多少人干事，而不是干多少事。
《面向对象分析与设计》重点内容总结之《面向对象的基本概念》
weixin_45928161的博客
12-15 1190
本博客只描述当前作者《面向对象分析与设计》课程的重点内容，博客中如果存在不正确地方麻烦大家指正 如果你觉得本博客有所帮助的话，记得点个赞，お願いします！ 核心内容面向对象基本概念一、Object、Class、Message1. Object（对象）2. Class（类）3. Message（消息）二、Basic Principles of Object Orientation1. Abstraction（抽象）2. Encapsulation（封装）3. Inheritance（继承）4. Pol..
数据仓库基本知识
热门推荐
直到世界的尽头
10-31 2万+
数据仓库是什么 根据统计，每个企业的数据量每2～3年时间就会成倍增长，这些数据蕴含着巨大的商业价值，而企业所关注的通常只占在总数据量的2%～4%左右。 因此，企业仍然没有最大化地利用已存在的数据资源，以至于浪费了更多的时间和资金，也失去制定关键商业决策的最佳契机。 于是，企业如何通过各种技术手段，并把数据转换为信息、知识避免各种无知状态和瞎猜行为，已经成了提高其核心竞争力的主要瓶颈。 ...
吉林大学软件需求分析 Software Requirement Analysis
weixin_42117120的博客
01-27 5154
吉林大学软件需求分析 Software Requirement Analysis 缩写/术语 RE：Requirements Engineering 需求工程 SRS：Software Requirements Specification 软件需求规范 SRA：Software Requirements Analysis 软件需求分析 SDM：Strategic Dependency Model 战略依赖模型 SRM：Strategic Rationale Model 战略理论模型 CIO:chief i
SSM 学习笔记
小贺的博客
06-09 2055
六、SSm框架 1.1Spring Framwork框架 Day03 1.1.1何为框架 Mvc 结构 1.1.1.1何为软件? 软件:是程序和文档的一个集合,是用来解决问题. 例如: 为了方便购物:电子商务系统(京东,天猫) 为了解决打车难的问题(滴滴) 为了解决最后一公里问题(OFO,摩拜,…) …….. 从软件编程角度分析,软件具体解决了那些问...
软件工程知识点总结——第一、二部分
yyh520025的博客
07-03 2197
软件工程知识点总结，可用作为期末复习资料。
我眼中的面向对象方法和结构化方法
02-27
系统的分析、设计必然要为技术管理提供方便，而且从程序的设计方法不断演化（过程式程序设计-〉模块化的程序设计-〉面向对象程序设计）的过程来看，先进的分析和设计方法为技术管理提供更大的便利。我认为反之亦然。...
计算机研究 -演化聚类算法研究.pdf
07-04
计算机研究 -演化聚类算法研究.pdf
面向对象的需求建模复合技术研究
03-03
作者在比较、分析其用例与原型法的基础上，引入基于面向对象的演化原型，提出了一种新的用例与演化原型法相结合的需求应用模型，并对该需求模型的实现进行了详细地描述。关键词：用例原型法面向对象软件需求模型复合...
java知识点汇总
weixin_45636230的博客
09-15 2867
文章目录面试前的工作礼貌常识公司及岗位了解自我介绍充足的知识储备提问环节面试后的总结javaSEjdk1.8新特性java语言的特征如何实现跨平台谈谈你对面向对象的认识理解聊聊面向对象的特征,封装,继承,多态访问权限对象创建过程? 从jvm的角度出发,延伸到对象在内存中的存储空间Java类初始化顺序java中创建对象的方式对象克隆,浅克隆,深克隆构造方法对象与引用静态static抽象类和接口ObjectString特征为什么不可变String类不可变性的好处? 为什么设计为不可变.String的值不可
淘宝帝国是如何创建的连载02
jackbon8的博客
09-29 1621
第一部分 淘宝技术发展——Java时代 脱胎换骨 我的师父黄裳曾经说过“好的架构图充满美感”。一个架构好不好，从审美的角度就能看出来。后来我看了很多系统的架构，发现这个言论基本成立。反观淘宝以前两个版本的架构，如 下图所示，你看哪个比较美？ 显然，第一个比较好看，第二个显得头重脚轻，这也注定了它不是一个稳定的版本，只存活了不到半年的时间。2004年初， SQL Relay的问题解决不了，数据库必须...
jar包增量更新分析
junlaiyan的专栏
05-16 369
借助jdeps分析出jar包的增量文件
分布式锁2-Zookeeper分布式锁实战
最新发布
qq_43676797的博客
05-19 206
使用curator操作Zookeeper进行实战；：Apache Curator包含一套高级API框架和工具类，它 是Apache ZooKeeper 的Java 客户端库。
命令执行漏洞（二）
XLbb的博客
05-15 998
POST方法，S2-045-bypass-2漏洞存在！,程序更改为S2-045-bypass-2漏洞测试模式, 响应码: 200。POST方法，S2-046-bypass漏洞存在！POST方法，S2-045-bypass漏洞存在！POST方法，S2-046-1漏洞存在！POST方法，S2-046-2漏洞存在！POST方法，S2-046-3漏洞存在！POST方法，S2-045-1漏洞存在！POST方法，S2-045-3漏洞存在！POST方法，S2-045-2漏洞存在！POST方法，S2-045-4漏洞存在！
java数据结构与算法(验证二叉搜索树)
磐门的博客
05-17 331
节点返回空为ture,节点的值不在对应数据大小范围内返回false。将验证二叉搜索树计算同样可以转换为相同子问题，所以比较适合用递归。node为root的左节点时，max更新为root.val。node为root的右节点时，min更新为root.val。
面向对象的分析和设计booch pdf
01-31
作者通过深入浅出的方式，以通俗易懂的语言讲解了面向对象的思维方式和设计方法，并通过实例和案例分析，展示了如何将面向对象的思想应用于软件开发的整个过程中。 《面向对象的分析和设计》从需求分析开始，通过...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Circ.

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值