紧急求助，给分100

Question

各位大侠，请问一个问题：
比如有下面一个类
public class Test {
   public void get() {
    //获得自己所在的方法名
    。。
   }
}我如何在get方法中，获得自己所在的方法名字(get方法)呢？
好像反射做不到
谢谢！

Answer 1

可以的import java.lang.reflect.Method;public class Test {
private static final long serialVersionUID = 1L; public static void main(String args[]) {
Test test=new Test();
System.out.println(test.go());
}

public String go(){
Class c = null;
try {
c = Class.forName("Test");
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
Method m[] = c.getDeclaredMethods();
return m[0].getName();
}
}

Answer 2

如果你方法很多的话，你还是不知道方法名吧！
m[0].getName();
已经写死了！
还有其他的办法吗？

Answer 3

如果知道你要调用的是这个类第几个方法,还好说,但是什么信息都不知道,好象不能做,不过你可以
去看看,Class类的原代码,看他内部的实现,看有什么方法可以实现的,其实就3楼的得到一个Class类的
对象,没他写的那么麻烦.
直接Class c = this.getClass()就可以得到该方法所处的类的Class对象

Answer 4

m[0].getName(); 
这个就是调用当前方法的名称
试过了吗？

Answer 5

不需要用反射
如果是jdk1.5以上的，可以通过Thread的getStackTrace()获得当前的StackTraceElement，在通过其getMethodName() 获得方法名
如public   class   Test   { 
      public   String   get()   { 
            StackTraceElement[] stack = Thread.currentThread().getStackTrace();
            System.out.println(stack[0].getMethodName()); //stack[0]是当前堆栈层，如果有某个方法调用get，那么stack[1]就是那个调用get的方法的堆栈层，依此类推
            return stack[0].getMethodName();
      } 
} 
如果是jdk1.4或以下的，可以通过Throwable或Exception
public   class   Test   { 
      public   String   get()   { 
            StackTraceElement[] stack = new Exception().getStackTrace();
            System.out.println(stack[0].getMethodName());
            return stack[0].getMethodName();
      } 
} 

Answer 6

public   class   Test   {
      public   void   get()   {
        //获得自己所在的方法名
           Test t = new Test();
           t.get();
      }
}

Answer 7

在jc里面运行
import java.lang.reflect.Method;public class Test 
{   
       public String get()
    {
        Class c = null;
        try
         {
            c = Class.forName("Test");
         } 
        catch (ClassNotFoundException e) 
        {
            
            e.printStackTrace();
        }
        Method m[] = c.getDeclaredMethods();
        return m[1].getName();
    }    public static void main(String args[]) 
    {
        Test test=new Test();
        System.out.println(test.get());
    }
    }

Answer 8

Class temp=Test.Classs;
....

Answer 9

Class temp=Test.Classs;
....

Answer 10

package src.T3;public class Test { public String toString(){
return this.getClass().toString();
}

public static void main(String[] args){
Test test=new Test();
System.out.println(test.toString());
}
}// class src.T3.Test
之后对字符串的处理,不知道你说的是不是这个意思!

Answer 11

6楼
m[0].getName();   
这个就是调用当前方法的名称 
试过了吗？－－－－－－－－－－－－－
你这样是可以，但是如果我方法很多的话，我要定位这个方法，需要先数一下在第几个方法，好像比较麻烦哈！！或者我在这个方法之前又加了一个方法，那m[0].getName();又要改成m[1].getName();

Answer 12

使用 new Exception()，
然后通过stackTrace的第一个元素，必定是当前类的当前方法，而且连多少行都拿的到。

Answer 13

18楼
使用   new   Exception()， 
然后通过stackTrace的第一个元素，必定是当前类的当前方法，而且连多少行都拿的到。－－－－－－－－－－－－－－－－－
在方法中new Exception好像不太好，不过业能解决问题，谢谢大家！！

Answer 14

你这样是可以，但是如果我方法很多的话，我要定位这个方法，需要先数一下在第几个方法，好像比较麻烦哈！！或者我在这个方法之前又加了一个方法，那m[0].getName();又要改成m[1].getName();
------------------------------------------------------------
我怀疑你是不是有试过才下这个结论的 我自己试了 貌似不用改成m[1]啊
import java.lang.reflect.Method;public class Test {
private static final long serialVersionUID = 1L; public static void main(String args[]) {
Test test=new Test();
System.out.println(test.go());
}

public void a(){

}

public void b(){

}
public String go(){
Class c = null;
try {
c = Class.forName("Test");
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
Method m[] = c.getDeclaredMethods();
return m[0].getName();
}

public void c(){

}

public void d(){

}

public void e(){

}
}/*
go
*/
楼主可以试下，难道你运行的结果和我不一样？

Answer 15

1.4
StackTraceElement[] sts = new Exception().getStackTrace();
for(int i=0;i<sts.length;i++)
{
StackTraceElement st = sts[i];
System.out.println(st);
}Map map = Thread.getAllStackTraces();
StackTraceElement[] sts = (StackTraceElement[])map.get(Thread.currentThread());
for(int i=0;i<sts.length;i++)
{
StackTraceElement st = sts[i];
System.out.println(st);
}

Answer 16

1.5
StackTraceElement[] sts = Thread.currentThread().getStackTrace();
for(int i=0;i<sts.length;i++)
{
StackTraceElement st = sts[i];
System.out.println(st);
}
大概就这个意思
自己整理吧

Answer 17

楼主的意思不就是这样吗,我想上面已经说的很明白了...
package com.lan;
public class Test { public String test(){
return this.getClass().getMethods()[0].getName();
}
public static void main(String[] args) {
Test test=new Test();
System.out.println(test.test()); }
}

Answer 18

import java.lang.reflect.*;public class PrivateOverride { private void f() {
System.out.println(" ");
}

public static void main(String[] args) {
Derived po = new Derived("");
po.a();
}
} class Derived extends PrivateOverride {
Derived()
{
System.out.println("");
} Derived(String str)
{
System.out.println("");
}

public void a() {f();} public void f() {
Class c = null;
try
{
c = Class.forName("Derived");
} catch(Exception e)
{
System.out.println(e);
}
Method m[] = c.getDeclaredMethods();
System.out.println(m[0].getName()); //这个方法也是不可行的如果同时有多个方法的话
System.out.println("---");

StackTraceElement[] stack = Thread.currentThread().getStackTrace();
System.out.println(stack[0].getMethodName());   //取的是dumpThreads
System.out.println("---");
System.out.println(stack[2].getMethodName());   //所以应该取第三个数组元素才是正确的
System.out.println("---");

for (int i = 0; i < stack.length; i++)
System.out.println(stack[i]); 
}

} ///:~
运行结果
a
---
dumpThreads
---
f
---
java.lang.Thread.dumpThreads(Native Method)
java.lang.Thread.getStackTrace(Unknown Source)
Derived.f(PrivateOverride.java:43)
Derived.a(PrivateOverride.java:27)
PrivateOverride.main(PrivateOverride.java:12)

Answer 19

LS说的确实也有道理，JRE版本不同，Thread.currentThread().getStackTrace()返回的结果不同，比如1.6返回的stack[0]就不是dumpThreads，而是tStackTrace
即1.6的运行结果是
a
---
getStackTrace
---
a
---
java.lang.Thread.getStackTrace(Unknown Source)
Derived.f(ShowSelf.java:41)
Derived.a(ShowSelf.java:26)
ShowSelf.main(ShowSelf.java:11)因为1.4及以前Thread是没有getStackTrace的，1.5及以后改进了，但是每个版本的实现不一样，所以，最好的方法还是通过Throwable或Exception，这样得到的应该就是当前堆栈了。
借用LS的代码import java.lang.reflect.*;public class PrivateOverride {    private void f() {
        System.out.println(" ");
    }
    
    public static void main(String[] args) {
        Derived po = new Derived("");
        po.a();
    }
}    class Derived extends PrivateOverride {
        Derived()
        {
            System.out.println("");
        }        Derived(String str)
        {
            System.out.println("");
        }
        
        public void a() {f();}        public void f() {
            Class c = null;
            try
            {
                c = Class.forName("Derived");
            } catch(Exception e)
            {
                System.out.println(e);
            }
            Method m[] = c.getDeclaredMethods();
            System.out.println(m[0].getName()); //这个方法也是不可行的如果同时有多个方法的话
            System.out.println("---");
            
            //StackTraceElement[] stack = Thread.currentThread().getStackTrace(); //不要用这个了
              StackTraceElement[] stack = new Throwable().getStackTrace(); //这样得到的stack[0]就肯定是当前堆栈了
            System.out.println(stack[0].getMethodName());   //取的是dumpThreads
            System.out.println("---");
            System.out.println(stack[2].getMethodName());   //所以应该取第三个数组元素才是正确的
            System.out.println("---");
            
            for (int i = 0; i < stack.length; i++)
                System.out.println(stack[i]); 
        }
        
    } ///:~