uml基础依赖关系的体现

业务前提

有一个人要去上班，但是到公司后需要确保门是打开的，也就是说上班的这个人要发消息通知另一个人开门，现在用代码实现这个场景

具体类

一个发送消息的类、一个接收消息的类，这是主要的两个业务类，然后就是通过一个类组合这两个类的关系。

代码实现

package com.openDoor;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class SendMessager {
    public   void getClassAndMethod(String classNameParam,String methodNameParam) throws ClassNotFoundException,
            InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchMethodException {
        sendMessage(classNameParam,methodNameParam);
    }
    private void sendMessage(String classNameParam,String methodNameParam) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
        System.out.println("发消息者：请给我开门");
        //ReceiveMessager 的class对象
        Class recMessagerClass = Class.forName(classNameParam);
        //调用ReceiveMessager的无参构造函数创建ReceiveMessage对象
        Object object =recMessagerClass.newInstance();
        System.out.println(object.getClass());
        //通过反射，获得ReceiveMessager类的public方法-receiveMessage（）
        Method receiveMessage =recMessagerClass.getMethod(methodNameParam);
        receiveMessage.invoke(object,null);
        //无参构造函数，参数null可以不传

    }

}package com.openDoor;

public class ReceivedMessager {
    private void openDoor(){
        System.out.println("开门了");
    }
    public void receiveMessage(){
        this.openDoor();
    }
}package com.openDoor;

import java.util.Scanner;

public class Notice  {
    private void getParam() throws Exception {
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入类名");
        String className=scanner.nextLine();
        System.out.println("请输入方法名");
        String methodName=scanner.nextLine();
        this.businessMethod(className,methodName);

    }
    private void businessMethod(String paramOne,String paramTwo) throws Exception {
        SendMessager sendMessager=new SendMessager();
        sendMessager.getClassAndMethod(paramOne,paramTwo);
    }

    public void notice() throws Exception{
        this.getParam();
    }
}package com.openDoor;

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

    }

}

这里提供的代码是使用了反射，解开了类图上SendMessager和ReceivedMessager依赖关系，如果没有解开依赖关系，那么代码应该是

public class SendMessager {
    public   void getClassAndMethod(ReceivedMessager receivedMessager)  {
        sendMessage(receivedMessager);
    }
    private void sendMessage(ReceivedMessager receivedMessager) {
        System.out.println("发消息者：请给我开门");
    }

}

public class Notice  {

    private void businessMethod() {
        SendMessager sendMessager=new SendMessager();
	ReceivedMessager receivedMessager=new ReceivedMessager();
        sendMessager.getClassAndMethod(receivedMessager);
    }

    public void notice() throws Exception{
        this.businessMethod();
    }
}

这里notice的调用和sendmessager的方法内部也就不一样了，需要用到ReceiveMessager，这样在编码阶段就已经绑定了是要用哪个类的，如果我现在想更换接收消息的人就没有办法了，所以需要使用上面提供的代码，反射的方式解决这个依赖关系。