Question

我想创建一个if语句来检查哪个方法调用了辅助方法。

我会用伪代码写出我想要的东西，这样你就可以看出我的意思了。

public static void methodOne() {
    methodToCall();
    }

public static void methodTwo() {
    methodToCall();
    }

public static void methodThree() {
    methodToCall();
    }

public static void methodToCall() {
    if (methodOne made the call == true) {
        execute this
    } else if (methodTwo made the call == true){
        execute this
    } else if (methodThree made the call == true){
        execute this
    } else {
        System.out.println("How did you get here?");
    }
}

这是关于它的要点。我想要一个简单的检查，看看哪个方法进行了调用，这样我就可以选择哪个操作与调用相关。

这可能吗？

如果不可能，有解决方法吗？

Answer 1

这被称为“国家导向”，并在20世纪70年代，甚至可能是20世纪60年代进行了广泛的辩论。结论是，如果你需要知道这种事情，你已经做了一些严重的错误，通过在代码中引入双向依赖。例如，当你添加另一个来电时会发生什么？

Answer 2

使用三种简短的方法，而不是将三种简短方法的逻辑组合成一种更大的方法。一旦创建了短方法，只需从每个调用方法调用适当的方法。

public static void methodOne() {
    methodToCall1();
}

public static void methodTwo() {
    methodToCall2();
}

public static void methodThree() {
    methodToCall3();
}

public static void methodToCall1() {
    int x = 0;
    x = x - 3; //some custom logic to prep argument
    commonLogic(x);
}

public static void methodToCall2() {
    //Method 2 logic
    int x = 0;
    x = x + 3; //some custom logic to prep argument
    commonLogic(x);
}

public static void methodToCall3() {
    //Method 3 logic
    int x = 0;
    x = x * 3; //some custom logic to prep argument
    commonLogic(x);
}

public static void commonLogic(int arg1){
     //peform common logic
}

如果这三种方法包含重复的代码，则将重复的代码抽象为另一种方法，然后从每个较小的方法中调用该方法。我们的想法是准备参数以在三个较小的函数中调用公共函数，然后使用这些参数调用公共函数。

Answer 3

方法提供的大量抽象来自于他们不需要知道谁在调用它们的事实，所以你的问题的答案是“不”。但这并不意味着你无法使其工作：让调用者传递某种令牌（比如enum值）来向被调用者标识自己。这将允许您在方法的实现中发送该标识：

enum CallerContext {CALLER1, CALLER2, CALLER3};
...
public static void methodToCall(CallerContext context) {
    ...
}

这不是最面向对象的服务方式，但是：通常，更好的方法是让调用者提供要执行的逻辑，而不是提供令牌来识别逻辑。有关该方法的详细信息，请参阅Visitor Pattern。

Answer 4

您可以通过Thread.getStackTrace()检查调用堆栈来执行此操作：

public static void methodToCall(Action action) {
    String callingMethod = Thread.currentThread().getStackTrace()[2].getMethodName();
    if (callingMethod.equals("methodOne")) {
        execute this0
    } else if (callingMethod.equals("methodTwo")) {
        execute this
    } else if (callingMethod.equals("methodThree")) {
        execute this
    } else {
        System.out.println("How did you get here?");
    }
}

但你不应该 - 这有点反OO。相反，将方法签名更改为以下内容：

public enum Action {ONE, TWO, THREE}

public static void methodToCall(Action action) {
    if (action == ONE) {
        execute this
    } else if (action == TWO) {
        execute this
    } else if (action == THREE) {
        execute this
    } else {
        System.out.println("How did you get here?");
    }
}

Answer 5

如果您最终使用枚举，那么请确保利用Java中的枚举不少于类的单例实例这一事实。因此，您可以在枚举定义中将该方法声明为抽象，然后在每个实例中覆盖它，而不是将枚举作为参数传递给枚举上下文之外定义的某个方法。

所以它看起来像：

enum Method {

    Mode1 {
            @Override
            void call() {
                    // do stuff 
            }
    }, Mode2 {
            @Override
            void call() {
                    // do stuff differently
            }
    }, Mode3 {
            @Override
            void call() {
                    // do stuff even more differently
            }
    };

    abstract void call();
}

然后你或者不需要你的包装方法，或者，如果他们应该做更多的事情，你写道：

public static void methodOne() {
    // some code
    Method.Mode1.call();
    // some code
}

我可以使用If语句来检查拨打电话的方法吗？

5 个答案: