//java反射机制
允许运行中的 java程序对自身进行检测，
可以直接操作程序内部的属性
Class类与java反射
Class类常用方法
//强制转换Class对象，以表示指定的类对象所表示的类的一个子集
public <U> Class<? extends U> asSubclass(Class <U> clazz)
//将一个对象强制转换成此 Class对象所表示的类或接口
public T cast(Object obj)
.....
//使用Object类中的getClass()方法
package org.com.classdemo;
class SuperClass
{
public void show()
{
System.out.println("这是SuperClass类的show()方法");
}
}
class SubClass extends SuperClass
{
public void show()
{
System.out.println("这是SubClass类的show()方法");
}
}
public class Hi
{
public static void main(String[] args)
{
SuperClass sup = new SuperClass();
SubClass sub = new SubClass();
Class c1 = sup.getClass();
Class c2 = sub.getClass();
System.out.println("类名："+c1.getName());
System.out.println("类名："+c2.getName());
}
}
编译： javac -d . Hi.java
运行：java org.com.classdemo.Hi
/*
类名：org.com.classdemo.SuperClass
类名：org.com.classdemo.SubClass
*/
// ============
//使用 forName()方法加载对象
//其中forName()返回的是Class实例，不是所加载类的实例
package org.com.classdemo;
class LocaderClass
{
static
{
System.out.println("这是LocaderClass类的静态代码块");
}
}
public class Hi
{
public static void main(String[] args)
{
Class c = null;
try
{
// 加载LocaderClass对象
c = Class.forName("org.com.classdemo.LocaderClass");
}catch(ClassNotFoundException e)
{
e.printStackTrace();
}
// 输出对象所在类的名称
System.out.println("类名："+c.getName());
}
}
/*
E:javap>javac -d . Hi.java
E:javap>java org.com.classdemo.Hi
这是LocaderClass类的静态代码块
类名：org.com.classdemo.LocaderClass
*/
// -------------
使用用类标记
package org.com.classdemo;
class LocaderClass
{
static
{
System.out.println("这是locaderclass类的静态代码块");
}
}
public class Hi
{
public static void main(String[] args)
{
// 声明Class对象 c
Class c = LocaderClass.class;
System.out.println("类名："+c.getName());
}
}
/*
E:javap>javac -d . Hi.java
E:javap>java org.com.classdemo.Hi
类名：org.com.classdemo.LocaderClass
*/
// ===============
使用反射机制生成并操作对象
通过无参构造实例化对象
package org.com.classdemo;
class Student
{
private String name;
private int age;
public Student(){}
public void setName(String name)
{
this.name = name;
}
public String getName()
{
return name;
}
public void setAge(int age)
{
this.age = age;
}
public int getAge()
{
return age;
}
public String toString()
{
return "姓名："+getName()+",年龄："+getAge();
}
}
public class Hi
{
public static void main(String[] args)
{
// 定义 Class对象
Class<?> c = null;
// 定义 Student 对象
Student stu = null;
try
{
// 加载LocaderClass对象,必须要完整的，包.类名
c = Class.forName("org.com.classdemo.Student");
}catch(ClassNotFoundException e)
{
e.printStackTrace();
}
try
{
//向下转型为 Student对象
stu = (Student)c.newInstance();
}catch(InstantiationException e)
{
e.printStackTrace();
}catch(IllegalAccessException e)
{
e.printStackTrace();
}
stu.setName("小二");
stu.setAge(20);
System.out.println("对象信息："+stu);
}
}
/*
E:javap>javac -d . Hi.java
E:javap>java org.com.classdemo.Hi
对象信息：姓名：小二,年龄：20
*/
// ============
调用有参构造方法
提供了使用java.lang.reflect.Constructor类根据类的
指定构造方法创建对象.使用Constructor类操作时，根据明确地
调用类中的构造方法，并将参数传递进去，即可实例化操作
具体如下：
获取类 Class对象，再通过 Class类中的 getConstructor()方法
取得Constructor类的实例
通过Constructor类的实例，调用 newInstance()方法并传
入指定构造方法所需要的参数创建对象
调用类中指定的构造方法
package org.com.classdemo;
import java.lang.reflect.Constructor;
class Student
{
private String name;
private int age;
// 必须显示写无构构造方法
public Student()
{
this.name = "小二";
this.age = 21;
}
// 必须显示写无构构造方法
public Student(String name)
{
this.name = name;
}
public Student(String name, int age)
{
this.name = name;
this.age = age;
}
public Student(int age)
{
this.age = age;
}
public void setName(String name)
{
this.name = name;
}
public String getName()
{
return name;
}
public void setAge(int age)
{
this.age = age;
}
public int getAge()
{
return age;
}
public String toString()
{
return "姓名："+getName()+"，年龄："+getAge();
}
}
public class Hi
{
public static void main(String[] args)
{
Class<?> c = null;
Student stu1 = null;
Student stu2 = null;
Student stu3 = null;
Student stu4 = null;
Constructor<?> con[] = null;
try
{
// 加载LocaderClass对象
c = Class.forName("org.com.classdemo.Student");
}catch(ClassNotFoundException e)
{
e.printStackTrace();
}
// 实例化Constructor
con = c.getConstructors();
for(int i=0; i<con.length;i++)
{
// 输出con数组，代表各个构造方法
System.out.println(i+"--------"+con[i]);
}
try
{
stu1 = (Student) con[0].newInstance(20);
stu2 = (Student) con[1].newInstance("小二",21);
stu3 = (Student) con[2].newInstance("小一");
stu4 = (Student) con[3].newInstance();
}catch(Exception e)
{
e.printStackTrace();
}
System.out.println("对象信息1："+stu1);
System.out.println("对象信息2："+stu2);
System.out.println("对象信息3："+stu3);
System.out.println("对象信息4："+stu4);
}
}
/*
E:javap>javac -d . Hi.java
E:javap>java org.com.classdemo.Hi
0--------public org.com.classdemo.Student(int)
1--------public org.com.classdemo.Student(java.lang.String,int)
2--------public org.com.classdemo.Student(java.lang.String)
3--------public org.com.classdemo.Student()
对象信息1：姓名：null，年龄：20
对象信息2：姓名：小二，年龄：21
对象信息3：姓名：小一，年龄：0
对象信息4：姓名：小二，年龄：21
*/
// ==============
反射机制的应用
反射机制主要运用java.lang.reflect包，这个包常用的类有：
Constructor类：用于表示类中的构造方法
Field类：用于表示类中的成员属性
Method类：用于表示类中的成员方法
//获取类所实现的全部接口
package org.com.classdemo;
interface FirstInterface{}
interface SecondInterface{}
interface ThirdInterface{}
class Demo implements FirstInterface,SecondInterface,ThirdInterface
{
}
public class Hi
{
public static void main(String[] args)
{
// 定义Class类型的数组
Class<?> inter[] = null;
try
{
// 获取全部实现的接口
inter = Class.forName("org.com.classdemo.Demo").getInterfaces();
}catch(ClassNotFoundException e)
{
e.printStackTrace();
}
for(Class<?> c:inter)
{
System.out.println(c.getName());
}
}
}
/*
E:javap>javac -d . Hi.java
E:javap>java org.com.classdemo.Hi
org.com.classdemo.FirstInterface
org.com.classdemo.SecondInterface
org.com.classdemo.ThirdInterface
*/
// ==============
获取父类
通过 Class类的 getSuperclass()方法获取一个类的父类，再通过getName()方法返回父类的名称
package org.com.classdemo;
class SuperClass
{
}
class SubClass extends SuperClass
{
}
public class Hi
{
public static void main(String[] args)
{
Class<?> c1 = null;
Class<?> c2 = null;
try
{
// 实例化 Class
c1 = Class.forName("org.com.classdemo.SubClass");
c2 = Class.forName("org.com.classdemo.SuperClass");
}catch(ClassNotFoundException e)
{
e.printStackTrace();
}
// 取得父类的名称
System.out.println("SubClass的父类："+c1.getSuperclass().getName());
System.out.println("SuperClass父类："+c2.getSuperclass().getName());
}
}
/*
E:javap>javac -d . Hi.java
E:javap>java org.com.classdemo.Hi
SubClass的父类：org.com.classdemo.SuperClass
SuperClass父类：java.lang.Object
*/
// =============
访问成员变量
Class类中提供了一系列的方法可以访问类中的全部属性，
并返回Field对象或数组