在运行时添加依赖于同一类中具有注释的方法的方法

public class Car{

   public void listener(String e){
      if(e.equals("Honk"))
        this.blowHorn();
   }
   @Honk
   private void blowHorn(){...}
}

*********************参考答案***********************

首先，你会这样声明你的新注释：

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface CarListener{
    public String carAction();
}

因此，在你的课堂上，你会有：

public class Car {
    //Here you´ll be looking at all the methods  you have in the class Car (I´d advice to 
    // put them in another class, so as to keep it clean, I didn´t do it here in order to
    // explain it better. These methods have the corresponding annotation you created
    public void listener(String e) { 
        Method[] methods = Car.class.getMethods();
            for(Method method:methods) {
        //Now that you have all the methods all you need is to figure which one you want
        // you´ll do that according to the "e" string, which represents the car action (for 
        // example "Honk") I´d also advice you to rename that too.
            if(rightMethod(method, e))
                //Now that you have found it, then you invoke the method, "call it"
                // which is what you wre doing in the previos code with "this.blowHorn()"
                return invokeMethod(method);
        }
        //This will help you in case you did NOT find the correct method, it´s just help 
        // if you don´t put it in it won´t break your code
        // fun fact about RuntimExceptions: you don´t have to declare them, meaning
        // you dont have to add them as "throws" or catch
        throw new RuntimeException("No listener found for car Action"+e);
    }
    private boolean rightMethod(Method method, String expression) {
    //First if asks if the method found has an annoation present, and if it does
    // then it asks if it corresponds to the annoation you created
        if (method.isAnnotationPresent(NewAnnotationInterfaceName.class))
    //if the method in fact has the annotation created all you are doing is asking what
    // carAction is associated to that method, you do that with the .carAction()
            return method.getAnnotation(NewAnnotationInterfaceName.class).carAction().equals(expression);
        return false;
    }

    //Now all you have to do is invoke it :) This just follows how to invoke a method
    // I won´t explain it
    private void  invokeMethod(Method method) {
        try {
            return method.invoke(Car.class.newInstance(), new Object[]{});
        } catch (InstantiationException | IllegalAccessException
                 | InvocationTargetException | IllegalArgumentException ex) {
            Logger.getLogger(Car.class.getName()).log(Level.SEVERE, null, ex);
        }
        throw new RuntimeException("Could not invoke method");
    }

    @CarListener(carAction= "Honk")
    public void blowHorn() {  
        ...
    }
     @CarListener(carAction= "SomethingElse")
    public void someOtherAction() {  
        ...
    }
}

希望能有所帮助！

*********************使用Hashmap和命令设计回答***********************

public abstract class CarAction {
    public abstract void execute(Car car){};
}
public class HonkAction extends CarAction{
    @Override
    public void execute(Car car) {
           car.blowHorn();
    }    
}
public class Car {
    private HashMap<String, CarAction> carActions;
    public Car() {
        ...
        initializeCarActions();
    }
    public void initializeCarActions() {
        this.carActions = new HashMap<>();
        this.carActions.put("Honk", new HonkAction());
        ...
    }
    public void listener(String e) {
        CarAction action = this.carActions.get(e);
        if(action!=null) action.execute(this);
    }
}

如果你用这种方式，我建议有人注入HashMap，这样Car就不必依赖CarActions(只是抽象类(，要么使用一个类来实现，要么使用Guice。此外，如果所有carActions只需要"Car"即可执行，则此操作也有效。

祝你好运！

public listener(String e){
      if(e.equals("Honk"))
        this.blowHorn();
   }

如果你真的想用注释来做这件事，你可以用这样的东西来做：

public void listener(String e) {
    for (Method m : this.getClass().getDeclaredMethods()) {
        for (Annotation a : m.getDeclaredAnnotations()) {
            if (a.getClass().getSimpleName().equals(e)) {
                m.setAccessible(true); // Need to do this so we can run private methods
                m.invoke(this);
            }
        }
    }
}

这将使用名称与给定名称匹配的注释来调用每个方法。坚持这个总体设计，我建议两个核心改进：

• 预生成注释<->方法映射，但将其存储在注释名称->方法哈希映射中，而不是调用

• 以注释的实例代替String(listener(Class<? extends Annotation> annotation)代替listener(String e)(，这样您就可以将输入与方法上的注释进行比较，而不必提取名称并比较字符串，这似乎特别令人讨厌。

虽然这不是一个伟大的设计；更典型的情况是，你要么把这些作为一系列简单的if语句(如果有少量选项(，要么如果有相当多的选项，你会使用类似命令模式的东西(将每个可调用的方法封装到一个对象中(，在创建时让每个命令用一个名称注册自己，只需将这些存储在映射中，然后可以从中查找相关命令。