Java类中调用自己 java如何调用类中的方法

转载

bingfeng 2023-08-16 12:01:43

文章标签 Java类中调用自己 System java 构造器 文章分类 Java 后端开发

使用反射获取类中的方法:

1):获取方法所在类的字节码对象.

2):获取方法.

------------------------------------------------------------------------

Class类中常用方法:

publicMethod[] getMethods():获取包括自身和继承过来的所有的public方法

publicMethod[] getDeclaredMethods():获取自身类中所有的方法(不包括继承的,和访问权限无关)

publicMethod getMethod(StringmethodName,

Class<?>...parameterTypes):表示调用指定的一个公共的方法(包括继承的)

参数:

methodName: 表示被调用方法的名字

parameterTypes:表示被调用方法的参数的Class类型如String.class

publicMethod getDeclaredMethod(String name,

Class<?>... parameterTypes):表示调用指定的一个本类中的方法(不包括继承的)

参数:

methodName: 表示被调用方法的名字

parameterTypes:表示被调用方法的参数的Class类型如String.class

代码：

System.out.println("-----------使用反射调用方法----------------");
		Class clzz = Main.class;
		Constructor<Main> conm = clzz.getConstructor();
		Main instance = conm.newInstance();
		//获取instance对象来调用方法
		instance.getOne();
		//获取所有的方法
		Method[] methods = clzz.getMethods();
		for (Method method : methods) {
			//获取类中方法的全名(eg:public com.test.Main())
			System.out.println(method);
		}

使用反射调用方法:

1):获取方法所在类的字节码对象.

2):获取方法对象.

3):使用反射调用方法.

------------------------------------------------------------------------

如何使用反射调用一个方法:

在Method类中有方法:

publicObject invoke(Object obj,Object... args):表示调用当前Method所表示的方法

参数:

表示被调用方法底层所属对象

Method m =clz.getMethod("sayHi",String.class);

实际参数

底层方法的返回结果

调用私有方法:

在调用私有方法之前:应该设置该方法为可访问的

又因为Method是AccessibleObject子类,所以Method中具有该方法.

sayGoodByeMethod.setAccessible(true);

System.out.println("-----------使用反射调用方法----------------");
		Class<Main> zlz = Main.class;
		//调用public类型方法
		System.out.println("public类型方法");
		Method method = zlz.getMethod("getName",String.class);//第一个参数为方法名、第二个为方法中参数类型
		Object invoke = method.invoke(zlz.newInstance(),"weijie");
		System.out.println(invoke);
		//调用private类型方法
		System.out.println("private类型方法");
		Method method2 = zlz.getDeclaredMethod("getAge",int.class);
		Object invoke2 = method2.invoke(zlz.newInstance(),22);

Output:

-----------使用反射调用方法----------------
public类型方法
我是Main类无参的构造器
weijie
private类型方法
我是Main类无参的构造器
Age:22

练习代码保存：

package com.test;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.Arrays;
import java.util.Date;
import java.util.Scanner;


public class Main {
	//获取指定的一个构造器
	public Main(){
		System.out.println("我是Main类无参的构造器");
	}
	public Main(int num){
		System.out.println(num);
	}
	private Main(final String statement){
		System.out.println("我是带有一个String类型的参数的构造器");
	}
	private Main(String str, int num){
		System.out.println("我是带有两个参数的构造器");
	}
	public static String getName(String str){
		return str;
	}
	private static void getAge(int age){
		System.out.println("Age:"+age);
	}
	private static void getAll(){
		//1:获取构造器所在类的字节码对象
		Class<Main> clz = Main.class;
		//2:获取clz对象中所有的构造器
		Constructor<?>[] cs = clz.getConstructors();
		System.out.println(cs.length);
		for (Constructor<?> c : cs) {
			System.out.println(c);
		}
		cs = clz.getDeclaredConstructors();
		System.out.println(cs.length);
		for(Constructor<?> c : cs){
			System.out.println(c);
		}
	}
	private static void getOne() throws NoSuchMethodException, SecurityException{
		//1:获取构造器所在类的字节码对象
		Class<Main> clz = Main.class;
		//2:获取clz对象中所有的构造器
		//需求1:获取public Main()
		Constructor<Main> con = clz.getConstructor();
		System.out.println(con);
		//需求2:获取public Main(String statement)
		con = clz.getDeclaredConstructor(String.class);
		System.out.println(con);
		//需求3:获取private Main(String str, int num)
		con = clz.getDeclaredConstructor(String.class, int.class);
		System.out.println(con);
	}
	public static void main(String[] args) throws Exception {
		System.out.println("---------类的实例------------------");
		//需求1:获取java.util.Date类的字节码对象
		//方式1:使用class属性
		Class<java.util.Date> clz1 =java.util.Date.class;
		//方式2:通过对象的getClass方法获取，getClass是Object类中的方法
		java.util.Date date = new java.util.Date();
		Class<?> clz2 = date.getClass();
		//方式3:通过Class类中的静态方法foeName(String className)
		Class<?> clz3 = Class.forName("java.util.Date");
		System.out.println(clz1+"\n"+clz2+"\n"+clz3+"\n");
		System.out.println("----------获取类的构造器-----------------");
		getOne();
		System.out.println("-----------获取类的所有的构造器----------------");
		getAll();
		System.out.println("-----------反射调用构造器创建对象----------------");
		//1:获取构造器所在类的字节码对象
		Class<Main> clz = Main.class;
		//2:获取clz对象中所有的构造器
		Constructor<Main> con = clz.getDeclaredConstructor(String.class);
		//3.使用反射创建对象
		//由于main(String..)为私有的因此，设置访问权限
		con.setAccessible(true);
		String str = "hello";
		con.newInstance(str);
		System.out.println("-----------使用反射获取类中的方法----------------");
		Class clzz = Main.class;
		Constructor<Main> conm = clzz.getConstructor();
		Main instance = conm.newInstance();
		//获取instance对象来调用方法
		instance.getOne();
		//获取所有的方法
		Method[] methods = clzz.getMethods();
		for (Method method : methods) {
			//获取类中方法的全名(eg:public com.test.Main())
			System.out.println(method);
		}
		System.out.println("-----------使用反射调用方法----------------");
		Class<Main> zlz = Main.class;
		//调用public类型方法
		System.out.println("public类型方法");
		Method method = zlz.getMethod("getName",String.class);//第一个参数为方法名、第二个为方法中参数类型
		Object invoke = method.invoke(zlz.newInstance(),"weijie");
		System.out.println(invoke);
		//调用private类型方法
		System.out.println("private类型方法");
		Method method2 = zlz.getDeclaredMethod("getAge",int.class);
		Object invoke2 = method2.invoke(zlz.newInstance(),22);
	}
}

在Java反射中Field用于获取某个类的属性或该属性的属性值

一:如何通过Field反射获取类的属性

Field提供如下几种方法：

:1：Class.getDeclaredField(String name);

返回一个 Field 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明字段（包括私有成员）。

2：Class.getDeclaredFields();

数组，该数组包含此 Class 对象所表示的类或接口所声明的所有字段（包括私有成员）。

3:Class.getField(String name);

返回一个 Field 对象，它反映此 Class 对象所表示的类或接口的指定公共成员字段。

4:Class.getFields();

返回一个包含某些 Field 对象的数组，该数组包含此 Class 对象所表示的类或接口的所有可访问公共字段。

package producer;

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.locks.ReentrantLock;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

class Person   
{  
    public String name;  
    private Integer age;  
    private String sex;  
    //省略所有属性的set、get方法  
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
}
public class Main {
	public static void main(String[] args) throws Exception, SecurityException { 
		Person person = new Person();
		// 通过Class.getDeclaredField(String name)获取类或接口的指定已声明字段。
		Field f1 = person.getClass().getDeclaredField("name");
		System.out.println("-----Class.getDeclaredField(String name)用法-------");
		System.out.println(f1);
		System.out.println("-----Class.getDeclaredFields()用法-------");
		// 通过Class.getDeclaredFields()获取类或接口的指定已声明字段。
		Field[] f2 = person.getClass().getDeclaredFields();
		for (Field field : f2) {
			System.out.println(field);
		}
		System.out.println("-----Class.getField(String name)用法-------");
		// 通过Class.getField(String name)返回一个类或接口的指定公共成员字段，私有成员报错。
		Field f3 = person.getClass().getField("name");
		//给属性赋值
		f3.set(person, "hello java");
		System.out.println(f3);
		//获取属性值
		System.out.println(f3.get(person));
		// 如果获取age属性(私有成员) 则会报错
		// Field f3=person.getClass().getField("name");
		System.out.println("-----Class.getFields()用法-------");
		// 通过Class.getField()，返回 Class 对象所表示的类或接口的所有可访问公共字段。
		Field[] f4 = person.getClass().getFields();
		for (Field fields : f4) {
			// 因为只有name属性为共有，因此只能遍历出name属性
			System.out.println(fields);
		}
		

	}
}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。