java基础-反射3（反射，反射创建对象，操作对象属性，调用对象方法）

java基础-反射3（反射，反射创建对象，操作对象属性，调用对象方法）

前面通过学习，我们了解的运行时类型信息的基本原理，以及通过Class对象和反射来获取运行时类型信息。下面来了解通过反射来创建对象，以及操作对象的属性和方法

首先还是创建一个person类

@Service
public class Person1 extends PersronParent implements PersonInterfance ,Cloneable{
public  String name;
public  double weight;
protected  double height;
private Integer age;

public Person1(){}

protected Person1(String name){
}
public void publicShow() throws Exception{
System.out.println("publicShow（）");
}
protected void disPlay(){
System.out.println("disPlay（）");

}

private String privateShow(String paramter1,String paramter2) throws NullPointerException{
StringBuffer stringBuffer  = new StringBuffer(paramter1);
return stringBuffer.append(paramter2).toString();
}
@Deprecated
private int testParamter(String paramter1,String paramter2) throws NullPointerException{
return 1;
}

@Deprecated
public int testPublicParamter(String paramter1,String paramter2) throws NullPointerException{
return 1;
}

@Override
public void parentSay(){
super.parentSay();
}

public String getName() {
return name;
}

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

public double getWeight() {
return weight;
}

public void setWeight(double weight) {
this.weight = weight;
}

public double getHeight() {
return height;
}

public void setHeight(double height) {
this.height = height;
}

public Integer getAge() {
return age;
}

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

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

通过反射来创建对象

通常在java中我们有以下4中方式创建对象

通过new 关键字 创建对象

通过Object clone();方法

通过反序列化

通过反射创建

这里我们来了解通过反射来创建对象和调用方法

首先我们来看通过反射来创建对象

我们通过newInstance（）来创建对象，如果对于无参数的构造方法我们直接用Class的对象的newInstance（）就可以创建对象

如果对于有参数的构造方法，我们需要先获取带参数的构造器（注意权限修饰符），然后通过构造器的newInstance()方法创建对象。

public class TestReflect {

public static void main(String[] agrs){

Class<Person> personClass = Person.class;
try {
/**
* 通过无参数的构造方法创建对象
*/
Person personOne =   personClass.newInstance();
/**
* 通过有参数的构造方法创建对象
*/
Constructor constructor = personClass.getDeclaredConstructor(String.class);
Person personTwo =   (Person) constructor.newInstance("带参数");

} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}

}

}

运行结果如下



这样我们就可以通过反射来创建对象。

通过反射创建对象后可以通过反射来给操作对象的属性

通过反射操作对象属性

上一篇文章说过，类的属性在反射中使用java.lang.reflect.Field表示，当然也使用这个类来操作对象的属性，在java中属性的访问涉及到权限修饰的修饰，具体如下：



所以在操作对象的属性的需要注意对目标类属性访问的权限，如下

如果当前类对目标对象有访问的权限（如目标类属性为public）

通过Class对象的getField()获取Field。

然后通过Field的set（）方法对目标对象赋值。

如果当前类对目标对象没有访问的权限（如目标类属性为private）

通过Class对象的getDeclaredField()获取Field。

调用Field 的setAccessible（true）方法，设置为可访问（如果不设置为true,则在当前类中不能访问目标类的属性，在为目标对象赋值时会报错）

然后通过Field的set（）方法对目标对象赋值。

调用Field 的setAccessible（false）方法复原。

具体操作如下

public class TestFileId2 {
public static void main(String agrs[]) throws NoSuchFieldException {
try {
//获取Class 对象
Class<Person> personClass  = Person.class;
//创建目标对象(注意，我们这里直接用的object,更体现了运行时类型信息)
Object person = personClass.newInstance();
//在没有通过反射赋值之前
System.out.println("person对象在没有赋值之前");
System.out.println(person.toString());
System.out.println();

System.out.println("当前类可以操作目标类的属性:比如public权限的属性");
//获取有权限操作的属性（当前类可以操作目标对象的属性:比如public）
Field name = personClass.getField("name");
//为person 对象 的 name属性赋值为 TestName
name.set(person,"TestName");
System.out.println(person.toString());
System.out.println();

System.out.println("当前类不能够操作目标类的属性:比如private权限的属性");
Field age = personClass.getDeclaredField("age");
//为person 对象 的 age 属性设置为可访问
age.setAccessible(true);
//为person 对象 的 age属性赋值为 10
age.set(person,10);
age.setAccessible(false);
System.out.println(person.toString());
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
}

运行结果如下

通过反射调用对象方法

反射能够操作对象的属性，当然也可以操作对象的方法，方法通过java.lang.reflect.Method表示，由于访问权限的限制，对于方法也有如下操作

如果当前类对目标对象有访问的权限（如目标类方法为public）

通过Class对象的getMethod()获取Method。

然后通过Method的invoke（）方法对目标对象赋值。

如果当前类对目标对象没有访问的权限（如目标类方法为private）

通过Class对象的getDeclaredMethod()获取Method。

调用Method的setAccessible（true）方法，设置为可访问（如果不设置为true,则在当前类中不能访问目标类的方法，在调用目标类的方法时会报错）

然后通过Method的invoke（）方法对目标对象赋值。

调用Method的setAccessible（false）方法复原。

具体操作如下:

public class TestMethod2 {
public static void main(String agrs[]) throws NoSuchFieldException, NoSuchMethodException, InvocationTargetException {
try {
//获取Class 对象
Class<Person> personClass = Person.class;
//创建目标对象
Object person = null;
person = personClass.newInstance();

System.out.println("当前类可以操作目标类的方法:比如public权限的方法");
//获取有权限操作的方法（当前类可以操作目标对象的方法:比如public）
Method publicShow = personClass.getMethod("publicShow");
//通过Method 的invoke 调用person 的 publicShow方法
publicShow.invoke(person);

System.out.println("当前类不能够操作目标类的方法:比如private权限的方法");
Method privateShow = personClass.getDeclaredMethod("privateShow", String.class, String.class);
//为person 对象 的 privateShow 方法设置为可访问
privateShow.setAccessible(true);
//通过Method 的invoke 调用person 的 privateShow方法
String result = (String) privateShow.invoke(person, "参数1", "参数2");
System.out.println(result);
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}

}

运行结果如下：



以上就是通过反射操作对象的基本方式。

反射的基础知识就是以上几篇文章，反射相对于其他知识来说比较简单，但是反射应用很多，比如很多框架，以及java中的动态代理等都涉及到了，所以反射在java中还是很重要的。