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

news/2024/5/19 5:19:47 标签: java, 反射, 面向对象

目录

    • 一：背景介绍
    • 二：思路&方案
      • 1.面向过程的实现思路
      • 2.面向对象的实现思路一（封装）
      • **重载版本**
      • 3、事件与委托版（C#版米老师何老师）
      • 多个委托多个事件
      • 4.面向对象的实现思路（封装、反射）

一：背景介绍

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

二：思路&方案

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();
    }
}

在这里插入图片描述

四：总结

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

继续深思吧~


http://www.niftyadmin.cn/n/159404.html

相关文章

层次聚类算法

层次聚类算法

动动发财的小手，点个赞吧！ 层次聚类是一种构建聚类层次结构的聚类算法。该算法从分配给它们自己的集群的所有数据点开始。然后将两个最近的集群合并到同一个集群中。最后，当只剩下一个集群时，该算法终止。可以通过观察树状图来选择…
阅读更多...
《世界棒球》：日本职棒

《世界棒球》：日本职棒

日本职业棒球（日语：日本プロ野球，常称日本职棒或NPB），是日本的最高层级的职业棒球赛事，1950年成立，由日本棒球机构管理。目前分为中央联盟及太平洋联盟，每个球季的例行赛完结后&…
阅读更多...
关键字 const

关键字 const

目录 一、符号常量与常变量 二、const的用法 2.1 const常用方法 2.2 const用于指针 2.2.1 p指针所指的对象值不能改变，但是p指针的指向可以改变 2.2.2 常指针p的指向不能改变，但是所指的对象的值可以改变 2.2.3 p所指对象的指向以及对象的值都不可…
阅读更多...
【BCH码4】BCH码的查找表译码原理详解及MATLAB实现(不使用MATLAB库函数『需要完整代码请先私信』)

【BCH码4】BCH码的查找表译码原理详解及MATLAB实现(不使用MATLAB库函数『需要完整代码请先私信』)

结果预览 理论基础 订阅《信道编码》专栏，首先查阅各子程序的详解 传统的BCH码译码一般会采用迭代或者查找表两种方法。常见的迭代算法有BM、Peterson算法，虽然这些算法硬件资源消耗较少，但是它们设计复杂度较高。前面博客中所分析的正是BM迭代和彼得森译码算法： 【BCH码…
阅读更多...
nginx-http-1

nginx-http-1

HTTP介绍 HTTP协议是Hyper Text Transfer Protocol（超文本传输协议）的缩写,是用于从万维网（WWW:World Wide Web ）服务器传输超文本到本地浏览器的传送协议。HTTP是一个基于TCP/IP通信协议来传递数据（HTML 文件, 图片文…
阅读更多...
计算机专业怎么发表论文？ - 易智编译EaseEditing

计算机专业怎么发表论文？ - 易智编译EaseEditing

期刊的审核周期比较长，如果顺利的情况下可能修复一两次就能顺利接受。 如果不顺利有可能改了几次还可能被拒。你要是拿着论文评优或者作为毕业论文的条件就要仔细斟酌。 这些都不是绝对的，有的期刊审稿时间很快，而期刊水平越高，…
阅读更多...
electron打包vue

electron打包vue

官网：https://www.electronjs.org/zh/docs/latest/tutorial/quick-start 简单使用electron npm install --save-dev electron安装electron，会被墙，，解决： 修改 .npmrc文件 registryhttps://registry.npmmirror.com…
阅读更多...
Web自动化——Selenium元素定位与防踩坑（三）

Web自动化——Selenium元素定位与防踩坑（三）

1. 基本元素定位一 from selenium import webdriver from selenium.webdriver.chrome.service import Service from selenium.webdriver.common.by import By # selenium Service("../../chromedriver.exe") # driver webdriver.Chrome(serviceService) # driver.…
阅读更多...
最新文章

Copyright @ 2022~2023