怎么获取一个java对象中的全部方法

用java中的反射机制就可以完成：

获取类成员方法

Method getMethod(String name,Class<>parameterTypes):返回此class对象对应类的带指定形参的public方法

Method[] getMethods():返回此class对象所表示的类的所有public方法

Method getDeclaredMethod(string name,Class<>parameterTypes):返回此class对象对应类的带指定形参的方法，与方法访问权限无关

Method[] getDeclaredMethods():返回此class对象对应类的全部方法，与方法的访问权限无关

如果你所说的对象的名字是否是指对象所属类型的名字，那么假设我有一个类：

class MyClass { }

现在我实例化这个类：

MyClass o = new MyClass();

透过从 SystemObjectGetType 继承的方法可以获得这个对象所属类的名字：

ConsoleWriteLine(oGetType()ToString());

输出将会是：MyClass。

Method类中的方法的使用（含代码和注释）：

getMethods()获得本类及父类中的public权限修饰符方法

getDeclaredMethods()专门获得调用该方法的对象的本类中的所有方法包括private权限修饰符的方法

getDeclaredMethod(String name,class<>parameterTypes)

第一个参数：方法的名称

第二个参数：可变长度，写你要查找的那个方法的参数类型列表class

getParameterCount()得到方法的参数个数123456

package LessonForReflection03;import javalangreflectMethod;import javalangreflectModifier;abstract class Card{

private void creatRandomNumbers(int count)//private关键字

{

}

public void getFullCardsNumbers(String[] random, String pre_numbers)

{

}

public static void getUserInfor()

{

}

public abstract void getUserInfor(String tel);

public abstract void getUserInfor(int sal1, int sal2) throws ArrayIndexOutOfBoundsException,ArithmeticException;}public class MethodInforGetter {

public static void main(String[] args) 

{

Class<> c1 = Cardclass;

Systemoutprintln("-------------------------");

Method[] m1 = c1getMethods();//getMethods()获得本类及父类中的public方法！

for (Method m:m1)

{

Systemoutprintln(m);

}

Systemoutprintln("-------------------------");

Method[] m2 = c1getDeclaredMethods();//getDeclaredMethods()专门获得本类中的所有方法包括private！

for (Method m:m2)

{

Systemoutprintln(m);

}

Systemoutprintln("-------------------------");

/

getDeclaredMethod(String name,class<>parameterTypes)

第一个参数：方法的名称

第二个参数：可变长度，写你要查找的那个方法的参数类型列表

 getParameterCount()得到方法的参数个数

/

try 

{

Method m3 = c1getDeclaredMethod("getUserInfor");

Systemoutprintln(m3);

//getParameterCount()方法,获得方法参数个数

Systemoutprintln(m3getParameterCount());

Systemoutprintln(ModifiertoString(m3getModifiers()));//获得方法修饰符

Systemoutprintln(m3getReturnType());

Systemoutprintln("-------------------------");

Method m4 = c1getDeclaredMethod("getUserInfor", intclass,intclass);

//getExceptionTypes()可以获得初始化当前Method对象的给Class对象初始化的那个类的那个指定方法抛出的异常类型

Class<>[] exception = m4getExceptionTypes();

for (Class<> e:exception)

{

Systemoutprintln(e);

}

} catch (NoSuchMethodException | SecurityException e) 

{

eprintStackTrace();

}

}}12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788

Constructor类中的方法的使用>

javalangreflectConstructor:

Constructor[] getConstructor()获得本类里的public权限修饰符构造函数，不能获取父类的！

Constructor[] getDeclaredConstructor()获得本类中的所以构造函数！

Constructor<T> getConstructor(ClassparameterType)用参数决定获得本类中的某个的构造方法,只能获得public的

Constructor<T> getDeclaredConstructor(ClassparameterType)用参数决定获得本类中的某个构造方法

附：

JDK80之后新增的类：

Executable：

它是Method和Constructor的父类

常用方法：

getParameter()获得类中方法参数

getExceptionTypes()获得类中某个方法抛出异常类型

getMoidfiers()获得方法权限修饰符

Parameter:

封装并代表了参数实例123456789101112131415

package LessonForReflection03;import javalangreflectConstructor;import javalangreflectModifier;import javalangreflectParameter;/

 javalangreflectConstructor

 Constructor[] getConstructor();获得本类里的public权限修饰符构造函数，不能获取父类的

  Constructor[] getDeclaredConstructor();得本类里的全部构造

  Constructor<T> getConstructor(ClassparameterType);用参数决定获得哪个构造方法

  Constructor<T> getDeclaredConstructor(ClassparameterType);

/public class ConstructorInforGetter {

public static void main(String[] args) 

{

Systemoutprintln("获得Cricle本类里的public权限修饰符构造函数，不能获取父类的Constructor[] getConstructor()");

Systemoutprintln("子类继承不了父类中的构造方法和private");

//Constructor[] getConstructor()获得Cricle本类里的public权限修饰符构造函数，不能获取父类的

//子类继承不了父类中的构造方法和private

Class<Circle> c1 = Circleclass;

Constructor<>[] cons1 = c1getConstructors();

for (Constructor<> cons:cons1)

{

Systemoutprintln(cons);

//Systemoutprintln(consgetName());

}

Systemoutprintln("-----------------------");

Systemoutprintln("方法获得本类中的所有构造函数getDeclaredConstructor()");

Constructor<>[] cons2 = c1getDeclaredConstructors();

for (Constructor<> cons:cons2)

{

Systemoutprintln(cons);

}

Systemoutprintln("-----------------------");

try 

{

Systemoutprintln("方法用参数指定获得本类！构造方法,只能获取public的Constructor<T> getConstructor(ClassparameterType)");

Constructor<> cons3 = c1getConstructor(intclass);

Systemoutprintln(ModifiertoString(cons3getModifiers()));

Systemoutprintln(cons3);

Systemoutprintln("-----------------------");

Systemoutprintln("方法用参数指定获得本类！构造方法任何权限修饰符的都可以获得Constructor<T> getDeclaredConstructor(ClassparameterType)");

Constructor<> cons4 = c1getDeclaredConstructor(Stringclass);

Systemoutprintln(cons4);

Systemoutprintln("-----------------------");

/

 JDK80之后新增的类

 Executable：

 是Method和Constructor的父类

 方法：

 getParameter();

 getExceptionTypes();

 getModifiers();

          getTypeParameters();

  Parameter:

  封装并代表了参数实例

/

Systemoutprintln("获取类中方法的参数getParameters()");

Constructor<> cons5 = c1getDeclaredConstructor(intclass,Stringclass);

Parameter[] p1 = cons5getParameters();

for (Parameter p:p1)

{

Systemoutprintln(p);

}

} catch (NoSuchMethodException | SecurityException e) 

{

eprintStackTrace();

}

}}123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687

代码中提到的Circle类和Shape类二者为继承关系：

package LessonForReflection03;public class Circle extends Shape{

private int r;

private String color;

public Circle(int r, String color) 

{

super();

thisr = r;

thiscolor = color;

}

public Circle(int r) 

{

super();

thisr = r;

}

protected Circle(String color) 

{

super();

thiscolor = color;

}

Circle()

{

super();

}}12345678910111213141516171819202122232425262728293031

package LessonForReflection03;public class Shape {

private int per;

public Shape(int per) 

{

super();

thisper = per;

}

public Shape() 

{

super();

}}1234567891011121314151617

部分文字来源于：

咕嘟咖啡杨海滨老师 — 《java编程语言高级特性》

轻量化研习Java相关技术倡导者

“爱码学院”联合创始人自适应教学理念提出者践行者；多年开发及项目管理经历；出版《JavaEE企业级应用与开发》一书；10余年高校项目实践毕设指导经验；企业软培经验丰富

java在当前方法内部想得到当前方法参数类型列表，可以通过对该方法所在的类进行反射来得到当前方法的参数列表。对当前对象进行反射可以得到类中所有成员变量和方法的对象数组，对当前方法的名字与方法数组进行比较，得到相同名字的方法（即当前方法），然后通过使用该方法对象的方法来获得参数列表。

使用getClass方法可以获取一个对象的类型类，然后在调用该类的方法可以获取该类的相关信息，比如父类的名字，该类的名字等等：

package test;

import javalangreflectField;

import javalangreflectMethod;

public class Demo2 {

String username = "sss";

public static void main(String[] args) throws IllegalArgumentException, IllegalAccessException, NoSuchFieldException, SecurityException, NoSuchMethodException {

Demo2 t = new Demo2();

if (Demo2class == tgetClass()) {

Systemoutprintln("equal");

}

// 获取类名

Systemoutprintln(tgetClass()getName());

// 获取父类名

Systemoutprintln(tgetClass()getSuperclass());

//获取类中某个属性

Field f = tgetClass()getField("username");

//获取类中某个方法

Method m = tgetClass()getDeclaredMethod("main", String[]class);

} 

}

基于这样一个假设，那就是客户端已经知道了服务端的地址，这部分会由后续的服务发现机制完善。通用接口

hello方法需要传递一个对象，HelloObject对象，定义如下：

注意这个对象需要实现 Serializable 接口，因为它需要在调用过程中从客户端传递给服务端。

接着我们在服务端对这个接口进行实现，实现的方式也很简单，返回一个字符串就行：

服务端需要哪些信息，才能唯一确定服务端需要调用的接口的方法呢？

那么服务端知道以上四个条件，就可以找到这个方法并且调用了。我们把这四个条件写到一个对象里，到时候传输时传输这个对象就行了。即 RpcRequest 对象：

那么服务器调用完这个方法后，需要给客户端返回哪些信息呢？

如果调用成功的话，显然需要返回值，如果调用失败了，就需要失败的信息，这里封装成一个 RpcResponse 对象：

这里还多写了两个静态方法，用于快速生成成功与失败的响应对象。其中，statusCode属性可以自行定义，客户端服务端一致即可。

客户端方面，由于在 客户端这一侧我们并没有接口的具体实现类，就没有办法直接生成实例对象 。这时，我们可以 通过动态代理的方式生成实例，并且调用方法时生成需要的RpcRequest对象并且发送给服务端 。

这里我们采用JDK动态代理，代理类是需要实现 InvocationHandler 接口的。

我们需要传递host和port来指明服务端的位置。并且使用getProxy()方法来生成代理对象。

InvocationHandler 接口需要实现invoke()方法，来指明代理对象的方法被调用时的动作。 在这里，我们显然就需要生成一个RpcRequest对象，发送出去，然后返回从服务端接收到的结果即可：

生成RpcRequest很简单，我 使用Builder模式来生成这个对象 。发送的逻辑我使用了一个RpcClient对象来实现，这个对象的作用， 就是将一个对象发过去，并且接收返回的对象。

我的实现很简单，直接使用Java的序列化方式，通过Socket传输。 创建一个Socket，获取ObjectOutputStream对象，然后把需要发送的对象传进去即可，接收时获取ObjectInputStream对象，readObject()方法就可以获得一个返回的对象。

服务端的实现就简单多了， 使用一个ServerSocket监听某个端口，循环接收连接请求，如果发来了请求就创建一个线程，在新线程中处理调用。 这里创建线程采用线程池：

这里简化了一下， RpcServer暂时只能注册一个接口，即对外提供一个接口的调用服务，添加register方法，在注册完一个服务后立刻开始监听：

这里向工作线程WorkerThread传入了socket和用于服务端实例service。

WorkerThread实现了Runnable接口，用于接收RpcRequest对象，解析并且调用，生成RpcResponse对象并传输回去。 run方法如下：

其中，通过classgetMethod方法，传入方法名和方法参数类型即可获得Method对象。如果你上面RpcRequest中使用String数组来存储方法参数类型的话，这里你就需要通过反射生成对应的Class数组了。通过methodinvoke方法，传入对象实例和参数，即可调用并且获得返回值。

服务端侧，我们已经在上面实现了一个HelloService的实现类HelloServiceImpl，我们只需要创建一个RpcServer并且把这个实现类注册进去就行了：

服务端开放在9000端口。

客户端方面，我们需要通过动态代理，生成代理对象，并且调用，动态代理会自动帮我们向服务端发送请求的：

我们这里生成了一个HelloObject对象作为方法的参数。

首先启动服务端，再启动客户端,测试结果：

构造函数和method类似，介绍一下获取method的方法。首先定义个类，里面定义两个方法。

public class TestRflectionFather {

public void showarray(String[] str){

for(String ss:str){

Systemoutprintln(ss);

}

}

public void showarray(){

Systemoutprint("this is no param method");

}

}

获取并运行String[]为参的方法

import javalangreflectMethod;

public class Testmain {

public static void main(String[] args) throws Exception {

Class clazz = ClassforName("TestRflectionFather");

Object fa= clazznewInstance();

Class[] cla = new Class[1];

Object[] obj= new Object[1];

String[] str ={"aaa","bbb","ccc"};

cla[0]=String[]class;

Method me=clazzgetMethod("showarray", cla);

obj[0]=str;

meinvoke(fa, obj);

}

}

获取并运行无参的方法

import javalangreflectMethod;

public class Testmain {

public static void main(String[] args) throws Exception {

Class clazz = ClassforName("TestRflectionFather");

Object fa= clazznewInstance();

Method me=clazzgetMethod("showarray");

meinvoke(fa);

}

}

import javalangreflectMethod;

public class Test

{

    public int add(int param1, int param2)

    {

        return param1 + param2;

    }

    public String echo(String message)

    {

        return "hello: " + message;

    }

    public static void main(String[] args) throws Exception

    {

        / 常规方法，先生成对象，然后通过对象的引用来调用相应的方法 /

        // Test test = new Test();

        // Systemoutprintln(testadd(1, 2));

        // Systemoutprintln(testecho("tom"));

        / 通过反射的方式 /

        

        //获取类的class对象

        Class<> classType = Testclass; 

        //生成class对象的实例

        Object test = classTypenewInstance();  

        //获取method对象

        Method addMethod = classTypegetMethod("add", new Class[] { intclass,

                intclass });

        

        //调用invoke方法，传入要调用方法所对应的class对象， 传入实参

        Object result = addMethodinvoke(test, new Object[]{1, 2});

        

        Systemoutprintln((Integer)result);

        

        Systemoutprintln("---------------------");

        

        //以下同理

        Method echoMethod = classTypegetMethod("echo", new Class[]{Stringclass});

        

        Object result2 = echoMethodinvoke(test, new Object[]{"tom"});

        

        Systemoutprintln((String)result2);

        

        

    }

}

通过例子来给你讲解，希望采纳

以上就是关于怎么获取一个java对象中的全部方法全部的内容，包括:怎么获取一个java对象中的全部方法、在C#中如何得到当前对象的名字、java中的反射机制是什么，有什么作用啊等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！