java 基础之反射技术

1. java代码

在 java 语言中最核心的就是代码的运行，按照面向对象的思想，在调用java代码时往往需要先创建对象，再调用方法，而写在方法中的即所谓的java 代码

一段java代码在程序运行期间会经历三个阶段： source-->class-->runtime

2. Class 对象

在java中用一个Class对象来表示一个java类的class阶段

Class对象封装了一个java类中定义的成员变量、成员方法、构造方法、类名、包名等

获得class对象的三种方式和区别

// 1. 根据给定的类名来获得用于类加载

String classname ="cn.itcast.reflect.Person"; //来自配置文件

Class clazz = Class.forName(classname); // 此对象代表Person.class

// 2. 如果拿到了对象，不知道是什么类型用于获得对象的类型

Object obj = new Person();

Class clazz1 = obj.getClass(); // 获得对象具体的类型

// 3. 如果是明确地获得某个类的Class对象主要用于传参

Class clazz2 = Person.class;

// 在java中所有的类型都会对应一个Class对象 int Integer

Class intClazz = int.class;

Class intarrClazz = int[].class;

Class voidClazz = void.class;

3. 反射的概念

反射就是获得一个java类的各个组成部分

// 反射类的成员方法

Class clazz = Person.class;

Method method =clazz.getMethod(methodName, new Class[]{paramClazz1, paramClazz2});

method.invoke();

// 反射类的构造函数

Constructor con =clazz.getConstructor(new Class[]{paramClazz1, paramClazz2,...})

con.newInstance(params...)

// 反射类的属性

Field field =clazz.getField(fieldName);

field.setAccessible(true);

field.setObject(value);

4. 反射用在哪里

到底框架是什么？框架就是将开发中大量重复的代码集中起来写个通用的程序

框架就是用反射来实现的

框架需要现在的类调用将来写的类

框架是将来的程序员调用的，框架不能实现完整的功能，框架只是一些一些通用的代码

框架要运行一定会依赖将来写的类

现在写的类要调用将来写的类，我们先针对接口进行调用，将来的类需要实现接口，那么方法就固定了

但是将来写的类的类名我们无法获知，这时就需要调用者通过配置文件告诉框架具体的类名

Person.java

// 1. 根据给定的类名来获得用于类加载

package xgp_reflect;

import java.awt.List;

import java.io.InputStream;

public class Person {

publicString name= "aaaa";

privatestatic int password=123;

//1、类构造函数

publicPerson(){

System.out.println("无参数构造函数！");

}

publicPerson(String name){

System.out.println(name);

}

publicPerson(String name, int password){

System.out.println(name+password);

}

privatePerson(List list){

System.out.println("list");

}

//2、方法

publicvoid aa1(){

System.out.println("aa1无参数方法");

}

publicvoid aa1(String name, int password){

System.out.println(name+":"+password+"两个参数的方法");

}

publicvoid aa1(InputStream in){

System.out.println(in);

}

publicClass[] aa1(String name, int[] password){

returnnew Class[]{String.class} ;

}

privatestatic void aa1(int num){

System.out.println(num+"静态方法");

}

public static void main(String[] args){

System.out.println("main");

}

Demo01.java

package xgp_reflect;

public class Demo01 {

/**

* 反射，加载类，获得类的字节码

* @throws ClassNotFoundException

publicstatic void main(String[] args) throws ClassNotFoundException {

//方法1

Classclazz = Class.forName("/stringjava/src/xgp_reflect/Person.java");

//方法2

Classclazz2 = new Person().getClass();

//方法3

Classclazz3 = Person.class;

}

Demo02.java

// package xgp_reflect;

import java.awt.List;

importjava.lang.reflect.Constructor;

importjava.lang.reflect.InvocationTargetException;

import java.util.ArrayList;

import org.junit.Test;

public class Demo02 {

/**

* 反射类的构造函数，创建类的对象

@Test

//反射构造函数publicPerson()

publicvoid test1() throws Exception{

Classclazz = Class.forName("xgp_reflect.Person");

Constructorc = clazz.getConstructor(null);

Personp = (Person) c.newInstance(null);

System.out.println(p.name);

}

//反射构造函数publicPerson(String name)

@Test

publicvoid test2() throws Exception{

Classclazz = Class.forName("xgp_reflect.Person");

Constructorc = clazz.getConstructor(String.class);

Personp = (Person) c.newInstance("xxxx");

System.out.println(p.name);

}

//反射构造函数publicPerson(String name, int password)

@Test

publicvoid test3() throws Exception{

Classclazz = Class.forName("xgp_reflect.Person");

Constructorc = clazz.getConstructor(String.class, int.class);

Personp = (Person) c.newInstance("xiaoguoping",25);

System.out.println(p.name);

}

//反射构造函数publicPerson(List list)

@Test

publicvoid test4() throws Exception{

Classclazz = Class.forName("xgp_reflect.Person");

Constructorc = clazz.getDeclaredConstructor(List.class);

c.setAccessible(true);

Personp = (Person) c.newInstance(new List());

System.out.println(p.name);

}

//无参数构造函数的另一种方法

@Test

publicvoid test5() throws Exception{

Classclazz = Class.forName("xgp_reflect.Person");

Personp = (Person) clazz.newInstance();

System.out.println(p.name);

}

Demo03.java

// package xgp_reflect;

import java.io.FileInputStream;

import java.io.InputStream;

import java.lang.reflect.Method;

import org.junit.Test;

public class Demo3 {

/**

* 反射类的方法

@Test

//反射类的方法--publicvoid aa1()

publicvoid test1() throws Exception{

Personp = new Person();

Classclazz = Class.forName("xgp_reflect.Person");

Methodmethod = clazz.getMethod("aa1", null);

method.invoke(p,null);

}

@Test

//反射类的方法--publicvoid aa1(String name, int password)

publicvoid test2() throws Exception{

Personp = new Person();

Classclazz = Class.forName("xgp_reflect.Person");

Methodmethod= clazz.getMethod("aa1", String.class,int.class);

method.invoke(p,"xiaoguoping",25);

}

@Test

//反射类的方法--publicClass[] aa1(String name, int[] password)

publicvoid test3() throws Exception{

Personp = new Person();

Classclazz = Class.forName("xgp_reflect.Person");

Methodmethod= clazz.getMethod("aa1", String.class,int[].class);

Classcs[] = (Class[]) method.invoke(p, "xiaoguoping", new int[]{1,2});

System.out.println(cs[0]);

}

@Test

//反射类的方法--publicvoid aa1(InputStream in)

publicvoid test4() throws Exception{

Personp = new Person();

Classclazz = Class.forName("xgp_reflect.Person");

Methodmethod= clazz.getMethod("aa1",InputStream.class);

method.invoke(p,newFileInputStream("C:\\unknow.log"));

}

@Test

//反射类的方法--privatestatic void aa1(int num)

publicvoid test5() throws Exception{

//Personp = new Person();静态方法可以不传对象

Classclazz = Class.forName("xgp_reflect.Person");

Methodmethod= clazz.getDeclaredMethod("aa1",int.class);

method.setAccessible(true);

method.invoke(null,23);

}

@Test

//反射类的方法--publicstatic void main(String[] args)

publicvoid test6() throws Exception{

Classclazz = Class.forName("xgp_reflect.Person");

Methodmethod= clazz.getMethod("main",String[].class);

//method.invoke(null,newString[]{"aa","bb"});//JDK1.4 main(string s1,string s2)拆开参数赋值

//method.invoke(null,(Object)new String[]{"aa","bb"});

method.invoke(null,new Object[]{new String[]{"aa","bb"}});

}

Demo04.java

// package xgp_reflect;

import java.lang.reflect.Field;

import java.lang.reflect.Method;

import org.junit.Test;

public class Demo04 {

/**

* 反射类的字段--属性，封装数据

@Test

//反射类的字段--publicString name= "aaaa";

publicvoid test1() throws Exception{

Personp = new Person();

Classclazz = Class.forName("xgp_reflect.Person");

Fieldfield = clazz.getField("name");

//获取字段的值

Objectvalue= field.get(p);

//获取字段的类型

Classtype = field.getType();

if(type.equals(String.class)) {

Stringsvalue = (String) value;

System.out.println(svalue);//aaaa

}

//设置字段的值

field.set(p,"xxxx");

System.out.println(p.name);//xxxx

}

@Test

//反射类的字段--privatestatic int password=123;

publicvoid test2() throws Exception{

Personp = new Person();

Classclazz = Class.forName("xgp_reflect.Person");

Fieldfield = clazz.getDeclaredField("password");

field.setAccessible(true);

Objectvalue = field.get(p);

System.out.println(value);

}