java反射

最新推荐文章于 2024-07-14 22:18:32 发布

熬夜复习

最新推荐文章于 2024-07-14 22:18:32 发布

阅读量94

点赞数

分类专栏： JAVA基础文章标签： java 反射

本文链接：https://blog.csdn.net/weixin_48530729/article/details/119966431

版权

JAVA基础专栏收录该内容

9 篇文章 0 订阅

订阅专栏

在这里插入图片描述

一个类在内存中只有一个Class对象

加载类的几种方式

//反射
public class TestPC {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
        //获得Class类的第一种方式
        Class<?> aClass = Class.forName("thread.Productor");
        //第二种方式
        Class<Productor> productorClass = Productor.class;
        //第三种
        Productor productor = new Productor();
        Class aClass1 = productor.getClass();

        //一个类里只有一个Class对象
        //一个类被加载后，类的所有结构都会被封装在Class对象中
        System.out.println(aClass.hashCode());
        System.out.println(productorClass.hashCode());
        System.out.println(aClass1.hashCode());
    }
}

class Productor{
    private String name;
    private int age;

    public Productor() {
    }

    public Productor(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Productor{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

字节码对象

每个类被加载之后，系统就会为该类生成一个对应的字节码对象，通过该字节码对象就可以访问到JVM中的对应的类。在Java中获得Class对象通常有三种方式。
1.使用类的.class属性
2.通过Class类中的静态方法forName(String className)，传入类的全限定名（必须添加完整包名）比较常用
3.通过对象的getClass方法来实现，其中，getClass()是Object类中的方法，所有的对象都可以调用该方法

public class ClassTest {
	public static void main(String[] args) throws Exception {
		/*
		 Class:运行的接口或类
		 forName(String className)  返回与给定字符串名称的类或接口相关联的 类对象(返回对象)
		 */		
		//字节码对象
		Class<?> class1 = Class.forName("reflector3.Person");
		System.out.println(class1);
		
		//.class 获得字节码对象
		Class<?> class2 = Person.class;
		System.out.println(class2);
		
		//利用反射创建对象（真正的对象）
		Person newInstance = (Person) class2.newInstance();
		System.out.println(newInstance);
  
            //class1和class2和class3是一样的  
		Class<? extends Person> class3 = newInstance.getClass();
		System.out.println(class3);
	}
}

获取类的运行时结构

Constructor

Class类
Constructor[] getDeclaredConstructors() 返回一个反映 Constructor对象表示的类声明的所有 Constructor对象的数组类

方法：
getParameterCount：返回构造器的形参个数
getName() 以字符串形式返回此构造函数的名称
getParameterTypes() 返回一个类对象的数组，类以声明顺序表示由该对象表示的可执行文件的形式参数类型
getConstructors() 返回public修饰的构造器

public class TestContructors {
	public static void main(String[] args) {
		//获取运行中的Person字节码文件对象
		Class<?> class1 = Person.class;
		//获取这个类的所有构造器(包括所有的构造器，与访问权限无关）
		Constructor<?>[] constructors = class1.getDeclaredConstructors();
		
		//遍历所有构造器
		//getParameterCount:返回构造器中参数的个数
		//Parameter：参数
		for(Constructor ct:constructors) {
			System.out.println(ct.getName() + ",参数个数:"+ct.getParameterCount());
			
			System.out.println("********************");
			
			//构造器形参的数据类型
			//getParameterTypes:返回构造器形参类型
			Class[] parameterTypes = ct.getParameterTypes();
			for(Class c:parameterTypes) {
				System.out.println("type:" + c);
			}
		}
		System.out.println("+++++++++++++++++++++++++++");
		//返回public修饰的构造器
		Constructor<?>[] constructors2 = class1.getConstructors();
		for(Constructor<?> c:constructors2) {
			System.out.println(c);
		}	
	}
}

public class TestConstrutors2 {
	public static void main(String[] args) throws Exception {
		//获取运行中的Person字节码文件对象
		Class<?> class1=Person.class;
		//指定使用两个参数的构造器
		Constructor<?> constructor = class1.getDeclaredConstructor(String.class,String.class);
		//利用反射创建实例
		Person p = (Person) constructor.newInstance("admin","666");
		System.out.println(p);
		
		//私有的构造器用new不能创建，可以用反射创建
		//Person p1=new Person();
		
		//用反射可以创建私有的构造器
		Constructor<?> privateCon = class1.getDeclaredConstructor();	
		System.out.println(privateCon);
		//修改构造器的访问权限
		//can not access a member of class com.gec.reflect04.Person with modifiers "private"
		privateCon.setAccessible(true);
		//创建对象
		Person p2 = (Person) privateCon.newInstance();
		System.out.println("p2:" + p2);
	}
}

public class Person {
	private String name;
	private String password;
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	
	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}

	//构造器
	private Person() {
		System.out.println("空空空");
	}
	
	public Person(String name) {
		this.name = name;
	}
	protected Person(String name,String password) {
		this.name = name;
		this.password = password;
	}

	@Override
	public String toString() {
		return "Person [name=" + name + ", password=" + password + "]";
	}
}

Method

getDeclaredMethod(String name, 类<?>… parameterTypes) 返回一个方法对象，它反映此表示的类或接口的指定声明的方法类对象
调用:
invoke(Object obj, Object… args) 在具有指定参数的方法对象上调用此方法对象表示的底层方法

public class TestMethod {
	public static void main(String[] args) {
		Class<?> class1 = Person.class;
		//获取这个类的所有构造器(包括所有的构造器，与访问权限无关）
		//Constructor<?>[] constructors = class1.getDeclaredConstructors();
		
		//获取所有的方法，与访问权限无关 private/默认/protected/public都可以获得
		Method[] methods = class1.getDeclaredMethods();
		
		//循环
		for(Method m:methods) {
			System.out.print("方法名:" + m.getName() + "\t");
			System.out.print(" 形参个数:" + m.getParameterCount() + "\t");
			System.out.println(" 方法的返回类型:" + m.getReturnType());
			System.out.println("************************");
			Class<?>[] parameterTypes = m.getParameterTypes();
			for(Class c:parameterTypes) {
				System.out.println(c);
			}
			System.out.println("************************");
		}
	}
	}

public class TestMethod2 {
	public static void main(String[] args) throws Exception {
		//获取Person字节码文件对象
		Class<Person> class1 = Person.class;
		System.out.println(class1);
		//创建person实例 
		Person p = class1.newInstance();
		System.out.println(p);
				
		//指定sing方法
		Method sing = class1.getDeclaredMethod("sing");
		//方法.invoke(对象实例)
		//对象.方法名
		sing.invoke(p);
				
		//获取sing(String name)
		Method sing2 = class1.getDeclaredMethod("sing", String.class);
		sing2.invoke(p, "王阳");
	}
}

public class Person {
	private String name;
	private String password;
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	
	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}

	//构造器
	public Person() {
		System.out.println("空空空");
	}
	
	public Person(String name) {
		this.name = name;
	}
	protected Person(String name,String password) {
		this.name = name;
		this.password = password;
	}
	
	public void sing() {
		System.out.println("唱一首歌");
	}
	
	public void sing(String name) {
		System.out.println(name + "唱一首歌");
	}

	@Override
	public String toString() {
		return "Person [name=" + name + ", password=" + password + "]";
	}
}

Field

A Field提供有关类或接口的单个字段的信息和动态访问
方法：
getDeclaredFields() :返回的field数组反映了这个类或集合中的所有字段
getDeclaredField(String name) ：返回一个 Field对象，表示指定的字段
getName() 获得字段名称
getType() 返回一个类对象标识了此表示的字段的声明类型 Field对象

public class TestField {
	public static void main(String[] args) {
		//运行中的Person字节码文件对象 ,这个时候是一个文件
		Class<Person> class1=Person.class;
		
		//获取所有的字段
		Field[] fields = class1.getDeclaredFields();
		for(Field f:fields) {
			System.out.println(f.getName()+",类型："+f.getType());
		}
	}
}

public class TestField2 {
	public static void main(String[] args) throws Exception, SecurityException {
		//获取Person字节码文件对象
		Class<Person> class1=Person.class;
		//获取指定的字段
		Field field = class1.getDeclaredField("name");
		System.out.println(field);
		//修改name的访问权限 不推荐，不赞成，破坏封装
		field.setAccessible(true);			
		//创建Person实例
		Person p = class1.newInstance();
		//设置这个name
		//private String name;  在类以外 使用 p.name = "王阳";
		//can not access a member of class com.gec.reflect06.Person with modifiers "private"
		field.set(p,"王阳");	
		System.out.println("p:" + p);
		
		
		//不破坏封装
		//括号中第一个是方法的名字，第二个是方法形参的类型
		Method setName = class1.getDeclaredMethod("setName", String.class);
		setName.invoke(p, "王阳");
		System.out.println(p);
	}
}

public class Person {
	private String name;
	private String password;
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	
	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}

	//构造器
	public Person() {
		System.out.println("空空空");
	}
	
	public Person(String name) {
		this.name = name;
	}
	protected Person(String name,String password) {
		this.name = name;
		this.password = password;
	}
	
	public void sing() {
		System.out.println("唱一首歌");
	}
	
	public void sing(String name) {
		System.out.println(name + "唱一首歌");
	}

	@Override
	public String toString() {
		return "Person [name=" + name + ", password=" + password + "]";
	}
}

熬夜复习

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java反射

一个类在内存中只有一个Class对象加载类的几种方式//反射public class TestPC { public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException { //获得Class类的第一种方式 Class<?> aClass = Class.forName("thread.Productor"); /..
复制链接

扫一扫