这种方法的错误之处在于:

class Example {
    FileOutputStream fileOutputStream;

    public Example() {
        //System.out.println("Example.Example()");

        debug("Example.Example()",false); // toggle

        try {
            fileOutputStream = new FileOutputStream("debug.txt");
        } catch (Exception exception) {
             debug(exception + Calendar.getInstance().getTime());
        }
    }

    private boolean was911AnInsideJob() {
        System.out.println("Example.was911AnInsideJob()");
        return true;
    }

    public boolean shouldGWBushBeImpeached(){
        System.out.println("Example.shouldGWBushBeImpeached()");
        return true;
    }

    public void setPunishment(int yearsInJail){
        debug("Server.setPunishment(int yearsInJail=" + yearsInJail + ")",true);
    }
}

在人们疯狂地使用System.out.println(…)之前，你总是可以，也应该，创建一些方法，这样输出就可以被重定向，例如:

    private void debug (Object object) {
        debug(object,true);
    }

    private void dedub(Object object, boolean debug) {
        if (debug) {
            System.out.println(object);

            // you can also write to a file but make sure the output stream
            // ISN'T opened every time debug(Object object) is called

            fileOutputStream.write(object.toString().getBytes());
        }
    }

我把maklemenz的回答重写了一下

private static Method m;

static {
    try {
        m = Throwable.class.getDeclaredMethod(
            "getStackTraceElement",
            int.class
        );
    }
    catch (final NoSuchMethodException e) {
        throw new NoSuchMethodUncheckedException(e);
    }
    catch (final SecurityException e) {
        throw new SecurityUncheckedException(e);
    }
}


public static String getMethodName(int depth) {
    StackTraceElement element;

    final boolean accessible = m.isAccessible();
    m.setAccessible(true);

    try {
        element = (StackTraceElement) m.invoke(new Throwable(), 1 + depth);
    }
    catch (final IllegalAccessException e) {
        throw new IllegalAccessUncheckedException(e);
    }
    catch (final InvocationTargetException e) {
        throw new InvocationTargetUncheckedException(e);
    }
    finally {
        m.setAccessible(accessible);
    }

    return element.getMethodName();
}

public static String getMethodName() {
    return getMethodName(1);
}

从技术上讲，这是可行的……

String name = new Object(){}.getClass().getEnclosingMethod().getName();

但是，在编译时将创建一个新的匿名内部类(例如YourClass$1.class)。这将为每个部署这个技巧的方法创建一个。class文件。此外，在运行时的每次调用上都会创建一个未使用的对象实例。因此，这可能是一个可接受的调试技巧，但它确实带来了巨大的开销。

这种技巧的一个优点是getEnclosingMethod()返回java.lang.reflect.Method，该方法可用于检索方法的所有其他信息，包括注释和参数名。这使得区分具有相同名称的特定方法成为可能(方法重载)。

注意，根据getEnclosingMethod()的JavaDoc，这个技巧不应该抛出SecurityException，因为内部类应该使用相同的类装入器装入。因此，即使有安全管理人员在场，也不需要检查访问条件。

请注意:对于构造函数，必须使用getEnclosingConstructor()。在(命名)方法之外的块中，getEnclosingMethod()返回null。

使用以下代码:

    StackTraceElement[] stacktrace = Thread.currentThread().getStackTrace();
    StackTraceElement e = stacktrace[1];//coz 0th will be getStackTrace so 1st
    String methodName = e.getMethodName();
    System.out.println(methodName);

我不知道获取当前执行的方法名称背后的意图是什么，但如果只是为了调试目的，那么像“logback”这样的日志框架可以在这里提供帮助。例如，在logback中，您只需要在日志配置中使用模式“%M”。但是，应该谨慎使用，因为这可能会降低性能。

MethodHandles.lookup().lookupClass().getEnclosingMethod().getName();