(54)Java学习笔记——反射 / 动态代理

反射

通过Class文件对象，去使用该文件中的成员变量，构造方法，成员方法

要想这样使用，首先你必须得到Class文件对象，其实也就是得到Class类的对象。

Class类：

成员变量：Field

构造方法 : Constructor

成员方法 : Method

获取Class文件对象的方式：

A /  Object类的getClass方法

B / 数据类型的静态属性Class

C / Class类中的静态方法   public static Class forName(String classname)

使用的选择：

推荐第三种方式！

范例：

package cn.itcast_01;
/*
* 反射
通过Class文件对象，去使用该文件中的成员变量，构造方法，成员方法
要想这样使用，首先你必须得到Class文件对象，其实也就是得到Class类的对象。
Class类：
成员变量：Field
构造方法 : Constructor

成员方法 : Method
获取Class文件对象的方式：
A /  Object类的getClass方法
B /  数据类型的静态属性Class
C /  Class类中的静态方法
public static Class forName(String classname)

*/
public class PersonDemo {
public static void main(String[] args) throws ClassNotFoundException {
//方式一：Object类的getClass方法获取Class文件对象
Person p = new Person();
Class c = p.getClass();

Person p2 = new Person();
Class c2 = p2.getClass();

System.out.println(p==p2);  //false
System.out.println(c==c2);  //true  同一个东西

//方式二：数据类型的静态属性Class
Class c3 = Person.class;
System.out.println(c==c3);   //true  同一个东西

//方式三：Class类中的静态方法
//		cn.itcast_01.Person  //全路径
Class c4 = Class.forName("cn.itcast_01.Person"); // 要写类的全路径
System.out.println(c==c4);  //true  同一个东西
}
}

通过反射获取无参构造方法并使用

获取构造方法：

public Constructor [] getConstructors()  //所有公共构造方法

public Constructor<?>[] getDeclaredConstructors()  //所有构造方法

public Constructor<T> getConstructor(Class<?>... parameterTypes) //获取单个构造方法   //可变参数...

public T newInstance(Object... initargs) 

使用此 Constructor 对象表示的构造方法来创建该构造方法的声明类的新实例，并用指定的初始化参数初始化该实例。

范例：

package cn.itcast_01;
/*
* Person
*
*/
public class Person {
private String name;
int age;
public String address;
public Person() {

}

private Person(String name){

}

public Person(String name,int age){

}

public Person(String name, int age, String address) {
super();
this.name = name;
this.age = age;
this.address = address;
}

public void show(){
System.out.println("show");

}

public void method(String s){
System.out.println("method"+s);
}

public String getString(String s, int i){
return s+"-----"+i;
}

private void function(){
System.out.println("function");
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + ", address=" + address + "]";
}

}

package cn.itcast_02;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

/*
* 通过反射获取构造方法并使用
*/
public class ReflectDemo {
public static void main(String[] args) throws Exception {
//获取字节码文件对象
Class c = Class.forName("cn.itcast_01.Person"); // 字符串可以做成配置文件

/*		//获取构造方法
//public Constructor [] getConstructors()  //所有公共构造方法
//public Constructor<?>[] getDeclaredConstructors()  //所有构造方法
Constructor[]  cons = c.getDeclaredConstructors();	//获得所有构造方法
for (Constructor con : cons){
System.out.println(con);
}
*/

//获取单个构造方法对象
//public Constructor<T> getConstructor(Class<?>... parameterTypes) //获取单个构造方法
//参数表示的是构造方法的构造参数个数及Class字节码文件对象
Constructor con = c.getConstructor();  //返回构造方法对象

//创建构造器对象
//public T newInstance(Object... initargs)
//使用此 Constructor 对象表示的构造方法来创建该构造方法的声明类的新实例，并用指定的初始化参数初始化该实例。
Object obj = con.newInstance();  //那到的是Person的对象（无参构造）

}
}

通过反射获取带参构造方法并使用

范例：

package cn.itcast_01;
/*
* Person
*
*/
public class Person {
private String name;
int age;
public String address;
public Person() {

}

private Person(String name){

}

public Person(String name,int age){

}

public Person(String name, int age, String address) {
super();
this.name = name;
this.age = age;
this.address = address;
}

public void show(){
System.out.println("show");

}

public void method(String s){
System.out.println("method"+s);
}

public String getString(String s, int i){
return s+"-----"+i;
}

private void function(){
System.out.println("function");
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + ", address=" + address + "]";
}

}

package cn.itcast_02;

import java.lang.reflect.Constructor;

/*
* 需求：通过反射去获取该构造方法并使用
* public Person(String name, int age, String address)
*/
public class ReflectDemo2 {
public static void main(String[] args) throws Exception {
//获取字节码文件对象
Class c = Class.forName("cn.itcast_01.Person");

//获取带参构造器
Constructor con = c.getConstructor(String.class,int.class,String.class);

//通过带参构造方法对象创建对象
Object obj = con.newInstance("唐僧",25,"大唐");

System.out.println(obj);

}
}

通过反射获取私有构造方法并使用

反射，可以访问私有内容！

范例：

package cn.itcast_01;
/*
* Person
*
*/
public class Person {
private String name;
int age;
public String address;
public Person() {

}

private Person(String name){

}

public Person(String name,int age){

}

public Person(String name, int age, String address) {
super();
this.name = name;
this.age = age;
this.address = address;
}

public void show(){
System.out.println("show");

}

public void method(String s){
System.out.println("method"+s);
}

public String getString(String s, int i){
return s+"-----"+i;
}

private void function(){
System.out.println("function");
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + ", address=" + address + "]";
}

}

package cn.itcast_02;

import java.lang.reflect.Constructor;

/*
* 通过反射获取私有构造方法并使用
*
*/
public class ReflectDemo3 {
public static void main(String[] args) throws Exception {
//获取字节码文件对象
Class c = Class.forName("cn.itcast_01.Person");

//获取私有构造方法
Constructor con = c.getDeclaredConstructor(String.class);  //用获取全部构造方法的方法

//用该私有构造方法创建对象
con.setAccessible(true);  //setAccessible 为true则取消java语言访问检查
Object obj = con.newInstance("孙悟空");

System.out.println(obj);

}
}

通过反射获取成员变量并使用

获取所有成员：

getFields.getDeclaredFields

获取单个成员

getField.getDeclaredField

修改成员的值

set (Object obj , Object value)

获取成员变量的方法：

Field[] fields = c.getFields();   //访问公共的成员变量

Field[] fields = c.getDeclaredFields();    ////访问所有的的成员变量

获取单个成员变量并对其赋值：

赋值：

public void
set(Object obj,Object value)
 指定对象变量上此

Field

对象表示的字段设置为指定的新值

范例：

package cn.itcast_01;
/*
* Person
*
*/
public class Person {
private String name;
int age;
public String address;

public Person() {

}

private Person(String name){

}

public Person(String name,int age){

}

public Person(String name, int age, String address) {
super();
this.name = name;
this.age = age;
this.address = address;
}

public void show(){
System.out.println("show");

}

public void method(String s){
System.out.println("method"+s);
}

public String getString(String s, int i){
return s+"-----"+i;
}

private void function(){
System.out.println("function");
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + ", address=" + address + "]";
}

}

package cn.itcast_03;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;

/*
* 通过反射获取成员变量并使用
*
*/
public class ReflectDemo {
public static void main(S
b7be
tring[] args) throws Exception {
//获取字节码文件对象
Class c = Class.forName("cn.itcast_01.Person");

/*		//获取所有的成员变量
//Field[] fields = c.getFields();   //访问公共的成员变量
Field[] fields = c.getDeclaredFields();    ////访问所有的的成员变量
for(Field field : fields){
System.out.println(field);
}*/

//通过无参构造方法创建对象
Constructor con = c.getConstructor();
Object obj = con.newInstance();

//获取单个的成员变量
//获取address并对其赋值
Field addressField = c.getField("address");
//public void set(Object obj, Object value)  指定对象变量上此 Field 对象表示的字段设置为指定的新值
addressField.set(obj, "开封");  //给obj对象的addressField字段设置为“开封”
System.out.println(obj);

//获取name并对其赋值
Field nameField = c.getDeclaredField("name");   //private String name;是私有的
nameField.setAccessible(true);   //是私有的,取消访问检查
nameField.set(obj, "猪八戒");
System.out.println(obj);

//获取age并对其赋值
Field ageField = c.getDeclaredField("age");
nameField.setAccessible(true);
ageField.set(obj, 300);
System.out.println(obj);

}
}

通过反射获取成员方法并使用

获取所有方法：

getMethods

getDeclaredMethods

获取单个方法

getMethod

getDeclaredMethod

暴力访问

method.setAccessible(true)

获取所有构造方法

Method[] methods = c.getMethods();  //获取自己的包括父亲的公共方法

Method[] methods = c.getDeclaredMethods();  //获取自己的所有方法

范例：

package cn.itcast_04;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

public class ReflectDemo {
public static void main(String[] args) throws Exception {
//获取字节码文件对象
Class c = Class.forName("cn.itcast_01.Person");

/*		//获取所有构造方法
//Method[] methods = c.getMethods();  //获取自己的包括父亲的公共方法
Method[] methods = c.getDeclaredMethods();  //获取自己的所有方法
for(Method method : methods){
System.out.println(method);
}*/

Constructor con = c.getConstructor();
Object obj = con.newInstance();

//获取单个方法并使用
//public void show()  无参无返回值
//public Method getMethod(String name,Class<?>... parameterTypes)
//第一个参数表示方法名，第二个表示方法参数是Class类型
Method m1 = c.getMethod("show");
//public Object invoke(Object obj,Object... args)
//返回值Object，第一个参数表示对象是谁，第二个参数表示调用该方法的实际参数
m1.invoke(obj);  //调用obj对象的m1方法
System.out.println();
}
}

——————————————————————————————————

中介