[TOC]
# 类加载机制与反射
## 反射机制的概念
反射是 Java 中一个非常强大的工具，能够方便我们创建更加灵活的代码，这些代码可以在运行时进行装载。
类中有什么信息，利用反射机制就能获得什么信息，不过有前提，必须知道类的全名。
> 但是使用反射对系统的开销是比较大的。
## 反射机制的作用
1. 在运行时判断一个对象所属的类；
2. 在运行时获取类的对象；
3. 在运行时访问 Java 对象的属性、方法、构造器等等。
## 反射机制的优点和缺点
* 静态编译：在编译时就确定类型，绑定对象；
* 动态编译：运行时确定类型，绑定对象。动态编译极大限度的发挥了Java的灵活性，体现了多态的概念，用于降低类之间的耦合；
* 反射机制的优点：可以实现动态创建对象和编译；
* 反射机制的缺点：对性能有影响。反射基本上是一种解释性的操作。我们告诉JVM，希望它做什么并满足我们的要求，这类操作总是慢于只直接执行相同的操作。
## 反射机制的示例
**通过一个对象获得一个完整的包名和类名**
~~~
public class Client2 {
public static void main(String[] args) {
Demo demo = new Demo();
// 根据对象获取完整的包名和类名
System.out.println(demo.getClass().getName());
}
}
class Demo2 {
}
~~~
**实例化Class类对象**
~~~
public class Client3 {
public static void main(String[] args) throws ClassNotFoundException {
// Class类是所有对象的元数据的类对象
Class<?> demo1 = null;
Class<?> demo2 = null;
Class<?> demo3 = null;
demo1 = Class.forName("com.ntqingniao.reflect.Demo3");
demo2 = new Demo3().getClass();
demo3 = Demo3.class;
System.out.println(demo1.getName());
System.out.println(demo2.getName());
System.out.println(demo3.getName());
}
}
class Demo3 {
}
~~~
**通过Class实例化其他类的对象**
~~~
package com.ntqingniao.reflect;
public class Client4 {
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
Class<?> demo = null;
// 通过类全名创建Class对象（类型的工厂）
demo = Class.forName("com.ntqingniao.reflect.Person");
// 调用工厂的newInstance()方法创建对象
Person per = (Person)demo.newInstance();
per.setName("Tom");
System.out.println(per);
}
}
class Person {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person [" + (name != null ? "name=" + name + ", " : "") + "age=" + age + "]";
}
}
~~~
> 如果把Person类中的无参构造函数取消，就会出现错误。
> 所以在编写使用Class实例化其他类对象的时候，一定要定义一个无参的构造器。
**通过Class调用类中的构造器**
~~~
// 获取该类的所有构造器对象
Constructor<?> cons[] = demo.getConstructors();
// 通过构造器对象的newInstance(Object.. params)可变参数方法构建对象
Person per1 = (Person)cons[0].newInstance();
Person per2 = (Person)cons[1].newInstance("Tom", 20);
System.out.println(per1);
System.out.println(per2);
~~~
**返回一个类实现的接口和继承的父类**
~~~
// 获取类的所有接口和直接父类方法
Class<?> inters[] = demo.getInterfaces();
Class<?> supers = demo.getSuperclass();
~~~
**获取类的全部属性**
~~~
// 获取类的全部属性
Field[] fields = demo.getDeclaredFields();
for (int i = 0; i < fields.length; i++) {
// 获取权限修饰符
int mo = fields[i].getModifiers();
String priv = Modifier.toString(mo);
// 数据类型
Class<?> type = fields[i].getType();
// 属性变量名
String name = fields[i].getName();
System.out.println(priv + " " + type.getName() + " " + name ) ;
}
~~~
**调用类的方法**
~~~
Method method = demo.getMethod("getName");
method.invoke(demo.newInstance());
Person p = new Person();
Method method2 = demo.getMethod("getName", String.class);
method2.invoke(p, "Reflect");
p.getName("Reflect");
~~~
**调用类的Getter和Setter**
~~~
public class Client5 {
public static void main(String[] args) throws Exception {
Human tom = new Human();
setter(tom, "Name", "Tom", String.class);
getter(tom, "Name");
System.out.println(tom);
}
public static void setter(Object obj, String attr, Object value, Class<?> type) throws Exception {
Method method = obj.getClass().getMethod("set" + attr, type);
method.invoke(obj, value);
}
public static void getter(Object obj, String attr) throws Exception {
Method method = obj.getClass().getMethod("get" + attr);
System.out.println(method.invoke(obj));
}
}
class Human {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Human [" + (name != null ? "name=" + name + ", " : "") + "age=" + age + "]";
}
}
~~~
## IOC原理
**设计模式之—工厂模式**
带配置文件的工厂模式设计
~~~
//生产水果的工厂
public class FactoryReflect2 {
public static Fruit getInstance(String key) {
Fruit fruit = null;
try {
fruit = (Fruit) Class.forName(Init.getValue(key)).newInstance();
} catch (Exception e) {
e.printStackTrace();
}
return fruit;
}
public static void main(String[] args) {
Fruit fruit = FactoryReflect2.getInstance("orange");
fruit.eat();
}
}
class Init {
private static Properties pro = null;
static {
pro = new Properties();
try {
pro.load(Init.class.getClassLoader().getResourceAsStream("fruit.properties"));
} catch (Exception e) {
// pro.setProperty("apple", "com.ntqingniao.ioc.Apple");
// pro.setProperty("orange", "com.ntqingniao.ioc.Orange");
// pro.setProperty("banana", "com.ntqingniao.ioc.Banana");
}
}
public static String getValue(String key) {
return pro.getProperty(key);
}
}
~~~
- 前言
- 计算机概论
- 数据库
- 数据库介绍
- MySQL的安装
- SQL
- 表基本操作
- 修改数据语句
- 数据检索操作
- 多表数据操作
- 表结构设计
- 综合应用
- JAVA
- JAVA 介绍
- JAVA 运行原理
- JDK 配置
- 类和对象
- 数据类型
- 变量
- 直接量
- 运算符
- 流程控制
- 数组结构
- 面向对象
- 隐藏和封装
- 深入构造器
- 类的继承
- 多态
- 包装类
- final 修饰符
- 抽象类
- 接口
- 集合框架
- 常用类学习
- 异常处理
- 设计模式-单例模式
- JDBC
- JSP&Servlet
- Web应用
- Tomcat
- JSP
- Scriptlet
- Page 指令
- 包含指令
- 跳转指令
- 用户注册实例
- JSP练习
- 内置对象
- Servlet
- 过滤器
- Web分层思想
- EL表达式
- JSTL
- 分页实现
- AJAX&JSON
- 开发步骤
- 路径问题
- Log4j
- Java 高级
- 文件操作
- 泛型
- 类加载机制和反射
- 注解 Annotation
- 教学管理
- 学员名录
- 缺勤记录