Java 我可以使用If语句来检查哪个方法进行了调用吗？

我想做一个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?");
    }
}

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

这可能吗

---

如果不可能，是否有解决办法？

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

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
}

---

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

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

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
}

---

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

方法提供的大量抽象来自这样一个事实，即它们不需要知道谁在调用它们，因此您的问题的答案是“否”。但这并不意味着您无法使其工作：让调用者向被调用者传递某种标识自己的令牌（例如，

enum

值）。这将允许您在方法的实现中分派该标识：

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

---

然而，这并不是最面向对象的方法：通常，更好的方法是让调用方提供要执行的逻辑，而不是提供标识该逻辑的令牌。有关该方法的详细信息，请参见。

方法提供的大量抽象来自这样一个事实，即它们不需要知道是谁在调用它们，因此您的问题的答案是“否”。但这并不意味着您无法使其工作：让调用者向被调用者传递某种标识自己的令牌（例如，

enum

值）。这将允许您在方法的实现中分派该标识：

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

---

然而，这并不是最面向对象的方法：通常，更好的方法是让调用方提供要执行的逻辑，而不是提供标识该逻辑的令牌。有关这种方法的详细信息，请参见。

这被称为“国家导向”，在20世纪70年代，甚至可能在20世纪60年代，人们对其进行了广泛的辩论。结论是，如果您需要知道这类事情，那么您已经在做一些严重错误的事情，在代码中引入了双向依赖关系。例如，当您添加另一个调用者时会发生什么情况？

这被称为“国家导向”，在20世纪70年代，甚至可能在20世纪60年代，人们对此进行了广泛的讨论。结论是，如果您需要知道这类事情，那么您已经在做一些严重错误的事情，在代码中引入了双向依赖关系。例如，添加另一个调用方时会发生什么情况？

您可以通过以下方式检查调用堆栈：

但你不应该——这有点反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?");
    }
}

---

您可以通过以下方式检查调用堆栈：

但你不应该——这有点反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?");
    }
}

---

如果最终使用的是枚举，那么请确保利用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
}

---

如果最终使用的是枚举，那么请确保利用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
}

---

为什么不只是传递一个参数？为什么要先将三个方法调用委托给一个方法调用，然后再将其分离？耦合方法（或函数、类、程序…）是必要的，但必须在可能的情况下加以控制和避免。全局变量可能重复？你来自哪里？1970年，我们别无选择，但今天，使用面向对象语言，全局变量被禁止！为什么不只是传递一个参数？为什么要先将三个方法调用委托给一个方法调用，然后再将其分离？耦合方法（或函数、类、程序…）是必要的，但必须在可能的情况下加以控制和避免。全局变量可能重复？你来自哪里？1970年，我们别无选择，但今天，使用面向对象语言，全局变量被禁止！这不是答案，因为问题不是问题…；-）@奥宾OP确实询问是否有解决方案。顺便说一句，谢谢你的编辑。解决方法是存在的（StckTre），但我不想写它，因为这个问题太模糊了，动机也很复杂