反射
什么是反射？
在不实例化对象的情况下，可以获取一个类中所有字段以及方法的技术
反射：一般作用于编写框架上，比如java 中的 Spring框架
-
在不实例化对象的情况下，可以获取一个类中所有字段以及方法的技术
-
反射的效率执行效率低
-
反射破坏了面向对象的思想
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；对于这种动态的获取信息以及动态调用对象的方法的功能称为：java语言的反射机制。
反射理解：
可以通你这个对象拿到字节码文件，通过子节码文件还原到类的本身（也就是说你拿到类的Class对象去使用这个类的成员方法，成员变量，构造方法）
获取Class类对象的三种方式
-
类名.class属性
-
对象名.getClass()方法
-
Class.forName(全限定类名)方法
反射对象的获取：
public static void main(String[] args) throws ClassNotFoundException {
//获取类的反射对象一：根据类名的字符串获取反射对象
Class cls = Class.forName("demo1.Student");
//获取类的反射对象二：使用类名.class
Class cls1 = Student.class;
//获取类的反射对象三：使用类的实例获取类的反射对象
Student student = new Student();
Class cls2 = student.getClass();
System.out.println(cls == cls1); //true
System.out.println(cls2==cls1); //true获取构造方法
用于创建对象的方法
Student类：
public class Student {
public int id;
public String name;
protected String address;
/***************构造*****************/
public Student(int id) {
this.id = id;
}
Student(int id, String name) {
this.id = id;
this.name = name;
}
public Student() {
System.out.println("创建对象");
}
private Student(int id, String name, String address) {
this.id = id;
this.name = name;
this.address = address;
}
public void say(){
}
}获取类中的构造方法后的使用：
先获取一个Class类对象
再通过getConstructors();方法获取类中所有public修饰的构造方法
eg：Constructor[] constructors = cls.getConstructors();
再通过遍历该数组进行下列操作
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
Class cls = Class.forName("demo1.Student");
/*************************检测类中的构造方法***************************/
//获取类中的所有public 修饰的构造方法
Constructor[] constructors = cls.getConstructors();
for (Constructor constructor : constructors) {
//获取构造方法名称
String name = constructor.getName();
System.out.println(name);
//获取构造方法的修饰符
int modifiers = constructor.getModifiers();
System.out.println(modifiers);
//获取形参
int count = constructor.getParameterCount();
//获取所有的形参
Parameter[] parameters = constructor.getParameters();
for (Parameter parameter : parameters) {
System.out.println(parameter.getName());
}
System.out.println("**********************************");
}
//获取单个public修饰的构造方法
Constructor constructor = cls.getConstructor();
System.out.println(constructor.getParameterCount());
Constructor constructor1 = cls.getConstructor(int.class, String.class);
System.out.println(constructor1.getParameterCount());
//获取类中所有的构造方法
Constructor[] dcs = cls.getDeclaredConstructors();
for (Constructor dc : dcs) {
System.out.println(dc.getName());
System.out.println(dc.getParameterCount());
System.out.println(dc.getModifiers());
System.out.println("****************************");
}
//根据参数类型获取单个构造方法
Constructor dc = cls.getDeclaredConstructor(int.class,String.class,String.class);
System.out.println(dc.getParameterCount());
//运行构造对象对应的构造方法
Constructor dc1 = cls.getDeclaredConstructor();
Object o = dc1.newInstance();
Constructor dc2 = cls.getDeclaredConstructor(int.class, String.class, String.class);
//暴力破解访问限制
dc2.setAccessible(true);
Object o = dc2.newInstance(1, "张三", "郑州");
Student st = (Student)o;
System.out.println(st.name);注意：即使Student类中的满参的构造方法不是public修饰的
也可以使用反射暴力破解访问限制
Constructor dc2 = cls.getDeclaredConstructor(int.class, String.class, String.class);
//暴力破解访问限制
dc2.setAccessible(true);
Object o = dc2.newInstance(1, "张三", "郑州");
Student st = (Student)o;
System.out.println(st.name);这样就可以在构造方法被私有化时，依旧可以使用该构造方法创建类的对象，并传入参数
通过反射操作类中的属性：
Class类获取成员方法对象的方法
代码示例：
public class FiledDemo {
/**
* 检测类中属性，并进行操作
*/
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException {
//获取类的反射对象
Class cls = Class.forName("demo1.Student");
//获取类中所有public修饰的属性
Field[] fields = cls.getFields();
for (Field field : fields) {
//获取属性名
String name = field.getName();
//获取属性类型
Class type = field.getType();
//获取修饰符
int modifiers = field.getModifiers();
System.out.println("属性名为："+name+"类型为："+type+"修饰符"+modifiers);
//属性名为：id类型为：int修饰符1
//属性名为：name类型为：class java.lang.String修饰符1
}
//获取public修饰的单个属性
Field name = cls.getField("name");
System.out.println(name.getName()+" "+name.getType());
//name class java.lang.String
//获取类中所有属性
Field[] declaredFields = cls.getDeclaredFields();
for (Field declaredField : declaredFields) {
System.out.println(declaredField.getName()+" 类型"+declaredField.getType()+" 修饰符");
//id 类型int 修饰符
//name 类型class java.lang.String 修饰符
//address 类型class java.lang.String 修饰符
//height 类型double 修饰符
}
//忽略修饰符，获取一个属性
Field address = cls.getDeclaredField("address");
System.out.println(address.getName()+" "+address.getType());
//address class java.lang.String
//对对象的属性进行操作
Field f1 = cls.getField("name");
Field f2 = cls.getDeclaredField("height");
Student stu1 = new Student();
Student stu2 = new Student();
f1.set(stu1,"张三");
f1.set(stu2,"李四");
//暴力破解属性的私有化封装
f2.setAccessible(true);
f2.set(stu1,178.3);
f2.set(stu2,184.2);
//通过反射获取属性值
Object o = f2.get(stu1);
Object o1 = f2.get(stu2);
System.out.println(o+" "+o1);
//178.3 184.2
}
}通过反射，操作类中的方法：
代码示例：
public class MethodDemo {
/**
* 通过反射检测类中方法
* @param args
*/
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
//获取类的反射对象
Class cls = Class.forName("demo1.Student");
//获取类中的所有public修饰的方法
Method[] methods = cls.getMethods();
for (Method method : methods) {
//获取方法名
String name = method.getName();
//获取返回值类型
Class<?> returnType = method.getReturnType();
//获取修饰符
int modifiers = method.getModifiers();
//获取形参的总数
int parameterCount = method.getParameterCount();
System.out.println("方法名："+name+" 返回值："+returnType+" 修饰符"+modifiers+" 形参总数："+parameterCount);
//会返回类中所有的方法，即使是父类的方法也会返回出来
}
//获取public修饰的单个方法
Method m1 = cls.getMethod("say");
// Method m2 = cls.getMethod("eat", String.class);
// System.out.println(m2.getName());
//获取类中的所有方法
Method[] dm = cls.getDeclaredMethods();
for (Method method : dm) {
System.out.println(method.getName()+" "+method.getReturnType()+" "+method.getModifiers()+method.getParameterCount());
}
//忽略访问修饰符，获取单个方法
Method eat = cls.getDeclaredMethod("eat", String.class);
System.out.println(eat.getName());
//暴力去除限制
eat.setAccessible(true);
//通过获取的方法执行方法
Constructor declaredConstructor = cls.getDeclaredConstructor(int.class, String.class, String.class);
declaredConstructor.setAccessible(true);
//创建对象
Object o = declaredConstructor.newInstance(1, "张三", "河南");
//调用方法
eat.invoke(o,"粽子"); //张三吃粽子
}
}案例-通过反射获取配置文件内容
-
创建一个Student类：
package com.yunhe.Pojo;
public class Student {
private int id;
private String name;
private String sex;
private int age;
public Student() {
}
public Student(int id, String name, String sex, int age) {
this.id = id;
this.name = name;
this.sex = sex;
this.age = age;
}
public int getId() {
return id;
}
public 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;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}-
创建配置文件 pojo.properties
className=com.yunhe.Pojo.Student
propertyName1=id
value1=21
propertyName2=name
value2=??
propertyName3=sex
value3=?-
创建实现类获取配置文件中的信息：
package com.yunhe.Util;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.util.Properties;
public class CreateObjectUtil {
public static Object createObject(String path) throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
//创建一个propertier集合
Properties properties = new Properties();
//加载配置文件中的内容
FileReader reader = new FileReader(path);
properties.load(reader);
//获取类名
String className = properties.getProperty("className");
//创建类的反射对象
Class cls = Class.forName(className);
//获取类中的无参构造方法
Constructor c = cls.getDeclaredConstructor();
//忽略访问限制
c.setAccessible(true);
//创建该类的对象
Object o = c.newInstance();
//获取属性
String pname1 = properties.getProperty("propertyName1");
//获取属性值
String v1 = properties.getProperty("value1");
//给第一个属性赋值
Field f1 = cls.getDeclaredField(pname1);
f1.setAccessible(true);
f1.set(o,Integer.valueOf(v1));
//获取第二个属性
String pname2 = properties.getProperty("propertyName2");
//获取属性值
String v2 = properties.getProperty("value2");
//给第二个属性赋值
Field f2 = cls.getDeclaredField(pname2);
f2.setAccessible(true);
f2.set(o,v2);
//获取第三个属性
String pname3 = properties.getProperty("propertyName3");
//获取属性值
String v3 = properties.getProperty("value3");
//给第二个属性赋值
Field f3 = cls.getDeclaredField(pname3);
f3.setAccessible(true);
f3.set(o,v3);
return o;
}
}Main方法中通过实现 类获取配置文件中对student类内容的赋值操作
import com.yunhe.Pojo.Student;
import com.yunhe.Pojo.Teacher;
import com.yunhe.Util.CreateObjectUtil;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
public class Main {
public static void main(String[] args) throws IOException, NoSuchFieldException, ClassNotFoundException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchMethodException {
Object object = CreateObjectUtil.createObject("src/pojo.properties");
Student stu = (Student)object;
System.out.println(stu.getId()+" "+stu.getName()+" "+stu.getSex());
}
}枚举
枚举的概述
是指将变量的值一一的列出来，变量的值只限于列举出来的值的范围内。举例：一周只有7天，一年只有12个月等。
枚举格式
public enum 枚举类名（）{
枚举项1，枚举项2，枚举项3，枚举4。。。；
}
在枚举类中可以创建成员变量，成员方法，构造方法等，但是创建的这些只能在本类中使用
枚举类中创建本类对象时，必须将对象创建放在最前面
代码示例：
public enum Colors {
//创建枚举类的对象 必须写在类的最前面
red("红色"),green("绿色"),blue("蓝色"),yello("黄色"),white("白色");
//这里的red其实就是 Colors red = new Colors(); 是创建的对象
//成员变量
public String message;
//成员方法
public void hello(){
System.out.println("hello 枚举类");
}
//构造方法 注意，构造方法不能使用public修饰
Colors(){
System.out.println("无参构造方法");
}
Colors(String message){
this.message = message;
}
}
1551
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
