反射
反射:是指在程序运行期间,能够观察和修改类或者类的对象的属性和行为的特性
项目开发中常见的使用反射的场景:
①使用JDBC连接数据库
②Servlet在Web容器中的加载和运行
反射的作用:
Java反射机制提供了以下的功能
①在运行时获取类的修饰符,包名,类名,实现的接口,继承的父类
②在运行时获取类的所有属性名,修饰符,属性类型
③在运行时获取所有方法,方法的返回值类型,方法名,方法参数数量,方法参数类型
④在运行时调用加载类的方法
Java反射API常用的类
①java.lang.Class
②java.lang.reflect.Method
③java.lang.Constructor
④java.lang.Field
⑤java.lang.Modifier
反射使用示例
首先我们先新建一个类,我们对类的访问修饰符稍微修改,接下来都会以对这个类操作为例
// 新建Student类
public class Student {
public int id;
private String name;
String sex;
private Student() {
}
private Student(int id, String name, String sex) {
this.id = id;
this.name = name;
this.sex = sex;
}
private int getId() {
return id;
}
private void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
@Override
public String toString() {
return "Student{" +
"id=" + id +
", name='" + name + '\'' +
", sex='" + sex + '\'' +
'}';
}
}
①使用Java反射获取类的信息
获取类的信息方式有三种,下面为大家一一介绍
// 新建Test类
public class TestStudent<T> {
public static void main(String[] args){
// 方式一:实例化一个对象,通过对象.getClass()获取信息
Test t = new Test();
Class c = t.getClass();
// 方式二: 通过类名.class获取
Class<Student> stu = Student.class;
// 方式三: 通过Class.forName(类全路径)获取
Class stu = Class.forName("demo.Student");
}
②使用Java反射获取类的构造函数的参数列表,并通过构造函数实例化类
由于Student类的构造方法为私有的,故通过new的方式无法实例化对象,下面为读者介绍获取Student的操作
public class TestStudent<T> {
public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, ClassNotFoundException {
TestStudent ts = new TestStudent();
Student student = (Student) ts.getObject("demo.Student");
student.id = 1;
student.sex = "男";
student.setName("张三");
System.out.println(student);
}
// 泛型方式获取Student对象,参数为类全路径
public T getObject(String classPath){
T t = null;
try {
// 通过类路径获取类信息
Class<T> tClass = (Class<T>) Class.forName(classPath);
// getDeclaredConstructor()方法可以获取对象私有化的构造器(包括其他类型的)
Constructor<T> c = tClass.getDeclaredConstructor();
// 构造方法为private时,要通过 setAccessible(boolean flag)方法获取访问权限,默认为false,我们将参数设为true即可获取权限
c.setAccessible(true);
// newInstance()创建对象
t = c.newInstance();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
return t;
}
// 跟上一个方法类似,只是参数直接传递的是类的信息
public T getObject2(Class<T> tClass){
T t = null;
try {
Constructor<T> c = tClass.getDeclaredConstructor();
c.setAccessible(true);
t = c.newInstance();
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
return t;
}
// 指定类型,获取Student对象
public static Student getStudent(){
Class<Student> s = Student.class;
Student stu = null;
try {
Constructor<Student> c = s.getDeclaredConstructor();
c.setAccessible(true);
stu = c.newInstance();
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
return stu;
}
}
③使用Java反射获取类的所有方法的信息,并调用类的setter方法进行属性的赋值
public class TestMethod {
public static void main(String[] args) throws Exception {
// 调用TestStudent静态方法获取Student对象
Student stu = TestStudent.getStudent();
// 获取类信息
Class<Student> c = Student.class;
// 这里跟构造器的区别是构造器用Constructor,方法用Method
// getDeclareMethod方法第一个参数为要获取的方法名,后面为方法参数列表的类信息,多个参数可通过,参数类型.class分隔
Method setId = c.getDeclaredMethod("setId", int.class);
// 私有化方法要设设置
setId.setAccessible(true);
// invoke调用方法,第一个参数要调用的方法的具体对象,后面为要设置的参数值
setId.invoke(stu,3);
// 带返回值的方法
Method getId = c.getDeclaredMethod("getId");
getId.setAccessible(true);
// 设置接收返回值
Object obj = getId.invoke(stu);
System.out.println(stu);
System.out.println(obj);
}
}
④使用Java反射获取类的所有属性的名称和类型,并为其中一个属性赋值
public class TestField {
public static void main(String[] args) throws Exception{
// 调用TestStudent静态方法获取Student对象
Student stu = TestStudent.getStudent();
// 获取类信息
Class<Student> c = Student.class;
// 属性用Field
// getField方法参数为要获取的属性名
Field id = c.getField("id");
// set方法用于赋值,第一个参数为要赋值属性的具体对象,第二个为要赋的值
id.set(stu,5);
Field name = c.getDeclaredField("name");
// 私有属性要设置访问权限
name.setAccessible(true);
name.set(stu,"王五");
// getDeclaredFields获取全部属性,返回值为Field类型数组
Field[] fields = c.getDeclaredFields();
for (Field field : fields) {
field.setAccessible(true);
System.out.println(field.get(stu));
}
}
}
单例对象
单例对象顾名思义就是一个系统中只能有一个对象,他不允许随意创建对象
public class Teacher {
private static Teacher t = null;
private Teacher(){
// 不允许随意创建对象
}
/*// 懒汉式
public static Teacher getInstance(){
if(t==null){
t = new Teacher();
}
return t;
}*/
// 饿汉式 加载类时就创建好对象,且仅创建一次,无需考虑线程安全问题
static {
t = new Teacher();
}
public static Teacher getInstance(){
return t;
}
}
懒汉式如果不添加synchronized可能会产生线程不安全问题而饿汉式由于一开始就创建了对象,线程是安全的,但也正因为如此,无论用不用都会创建对象,可能会产生垃圾对象。