反射机制
目录
前言（导入）
反射最初学习的时候你在哪儿接触的？是覆写equals方法还是学习JDBC的时候？
支线问题：java类为何要写无参构造？Class.forName 和直接写 DriverManager.registerDriver(new Driver) 两者功能是否等同？Java设计模式中工厂模式是什么呢？
让小咲带着回顾一下吧，开上小火车启程了。
Ⅰ、覆写equals方法，见到的getClass();
class People{
String name;
@Override
public boolean equals(Object obj) {
//比较对象相等
if (this == obj)
return true;
//对象为空
if (obj == null)
return false;
//反射？instanceof 也可以，在相同的一个大类里
if (getClass() != obj.getClass())
return false;
//强制类型转换
People other = (People) obj;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}Ⅱ、JDBC的学习过程中Class.forName("") ;
学习反射的时候，看到了一份资料，正好解答了学习JDBC时的一个疑问Class.forName 和直接写 DriverManager.registerDriver(new Driver) 两者功能是否等同？
public class JdbcDemo {
public static void main(String[] args) throws SQLException, ClassNotFoundException {
String url = "jdbc:mysql://127.0.0.1:3306/test3";//端口号一般为3306，url统一资源定位符
String username = "root";//用户名一般设置为root
String password = "";
//Class.forName("com.mysql.jdbc.Driver");
DriverManager.registerDriver(new Driver());
Connection connection = DriverManager.getConnection(url, username, password);
String sql = "SELECT * FROM student";
PreparedStatement prepareStatement = connection.prepareStatement(sql);
ResultSet resultSet = prepareStatement.executeQuery();
resultSet.next();
String address = resultSet.getString("address");
System.out.println(address);
}
}结论：相同，可以从源码中发现静态代码块执行速度优先于构造方法，这里如果忘记了类加载执行比较速度的，建议复习一下类加载机制等相关知识。
public class Driver extends NonRegisteringDriver implements java.sql.Driver {
static {
try {
java.sql.DriverManager.registerDriver(new Driver());
} catch (SQLException E) {
throw new RuntimeException("Can't register driver!");
}
}
public Driver() throws SQLException {
// Required for Class.forName().newInstance()
}
}具体请参考：https://www.runoob.com/w3cnote/java-class-forname.html
补充知识：Class.forName() 方法的含义：将驱动类的 class 文件装载到内存中，并且形成一个描述此驱动类结构的 Class 类实例，并且初始化此驱动类，这样 jvm 就可以使用它。说白了做了两件事情，第一加载参数指定的类，第二初始化。
说了那么多，还是赶紧进入主题吧。
概念
什么叫做反射？
反射指的时对象的反向处理操作，举个例子，java日常代码中import java.util.Date,我们就可以用Date这个类了，现在反射就是反向操作，已知Date，反求getClass（）。
import java.util.Date;
public class Solution {
public static void main(String[] args) {
Date date=new Date();
System.out.println(date.getClass());
}
}
三种实例化对象
- 任何类的实例例化对象可以通过Object类中的getClass()⽅方法取得Class类对象。
- "类.class":直接根据某个具体的类来取得Class类的实例例化对象。
- 使⽤Class类提供的方法:public static Class<?> forName(String className) throws ClassNotFoundException
方案1示例：上面介绍的就是方案1
import java.util.Date;
public class Solution {
public static void main(String[] args) {
Date date=new Date();
System.out.println(date.getClass());
}
}方案2示例:学习JavaWeb web.xml中加入这段代码后，项目结构发生改变，原先没有servlet和LoginServlet
<servlet>
<servlet-name>loginServlet</servlet-name>
<servlet-class>servlet.LoginServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>loginServlet</servlet-name>
<url-pattern>/login</url-pattern><!-- 登录接口 -->
</servlet-mapping>
方案3示例：
输出结果：java.util.Date
public class Test {
public static void main(String[] args) throws ClassNotFoundException {
Class<?> cls = Class.forName("java.util.Date") ;
System.out.println(cls.getName());
}
}结论：除了第⼀种方法会产生Date类的实例化对象之外，其他的两种都不会产生Date类的实例例化对象。于是取得了Class类对象有⼀个最直接的好处:可以通过反射实例化对象（核心作用）；
根据这个结论，实际写一段代码，输出结果和上面一样，注意第5行cls.newInstance();这里起到了与new java.util.Date();一样的效果。所以我们说Class对象就意味着取得了⼀个指定类的操作权。
public class Test {
public static void main(String[] args) throws ClassNotFoundException,
InstantiationException, IllegalAccessException {
Class<?> cls = Class.forName("java.util.Date") ;
Object obj = cls.newInstance() ;
System.out.println(obj);
}
}三种工厂模式
工厂模式，简单工厂模式，抽象工厂模式的区别：以Animal类为例，假设要开一个宠物店，工厂模式是建立不同类别的宠物工厂，有🐕工厂，有🐱工厂，有🐦工厂等等，这个时候如果我想要一个对象兔子，只需要再开一个🐇工厂；简单工厂模式其实是简化了工厂模式，现在经济环境不太好或者市场只风靡养🐱和🐕，这个时候没必要开那么多的工厂，直接建立一个🐱🐕宠物店不就可以了，但是聪明的你会想到如果市场经济恢复了，又风靡养🐦了，那么就需要直接把关于宠物店的代码在内部改变成🐱🐕🐦宠物店（现实中至少店的招牌需要每次改个名吧）；抽象工厂模式主要表述的是一个类别，比如雄性和磁性；
总结来说，就是工厂模式：开若干个工厂，解决不同事物，在调用代码的时候使用多态的知识，来将事物更好的分类（可以看作链表插入方便快捷）；而简单工厂模式，则是简化工厂数量，（就类似与顺序表虽然建立方便，但是插入就需要全部修改）；抽象工厂模式我的理解中其实最复杂，因为抽象两个字意味着描述的事物的一个类别，在工厂方法模式中，一个具体的工厂负责生产一类具体的产品，即一对一的关系，但是，如果需要一个具体的工厂生产多种产品对象，那么就需要用到抽象工厂模式了。
当然也有网上看到的核心区别：
- 工厂方法模式利用继承；抽象工厂模式利用组合
- 工厂方法模式产生一个对象；抽象工厂模式产生一族对象
- 工厂方法模式利用子类创造对象；抽象工厂模式利用接口的实现创造对象
反射机制的应用
反射vs工厂模式
如果我们想要一个苹果🍎，这个时候怎么办呢 ？
interface IFruit {
public void eat() ;
}
class Apple implements IFruit {
@Override
public void eat() {
System.out.println("[Apple] 吃苹果 ");
}
}
class FruitFactory {
private FruitFactory() {}
public static IFruit getInstance(String className) {
if ("apple".equals(className)) {
return new Apple() ;
}
return null ;
}
}
public class Test {
public static void main(String[] args) {
IFruit fruit = FruitFactory.getInstance("apple") ;
fruit.eat() ;
}
}如果这个时候又想要一个橙子🍊，这个时候又怎么办？
interface IFruit {
public void eat() ;
}
class Apple implements IFruit {
@Override
public void eat() {
System.out.println("[Apple] 吃苹果 ");
}
}
class Orange implements IFruit {
@Override
public void eat() {
System.out.println("[Orange] 吃橘子 ");
}
}
class FruitFactory {
private FruitFactory() {}
public static IFruit getInstance(String className) {
if ("apple".equals(className)) {
return new Apple() ;
}else if ("orange".equals(className)) {
return new Orange() ;
}
return null ;
}
}
public class Test {
public static void main(String[] args) {
IFruit fruit = FruitFactory.getInstance("orange") ;
fruit.eat() ;
}
}显然这个问题用new关键字不是很好，当然如果确定只要这两个，可以用简单工厂模式，但是我们需求不定，就用反射机制来实现一下，通过getInstance()获取实例对象
package test28;
interface IFruit {
public void eat() ;
}
class Apple implements IFruit {
@Override
public void eat() {
System.out.println("[Apple] 吃苹果 ");
}
}
class Orange implements IFruit {
@Override
public void eat() {
System.out.println("[Orange] 吃橘子 ");
}
}
class FruitFactory {
private FruitFactory() {}
public static IFruit getInstance(String className) {
IFruit fruit = null ;
try {
fruit = (IFruit)
Class.forName(className).newInstance();
} catch (InstantiationException | IllegalAccessException |ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return fruit ;
}
}
public class Test {
public static void main(String[] args) {
//这里test28是包名，通过包名.类名的方式创建实例对象
IFruit fruit =FruitFactory.getInstance("test28.Orange") ;
fruit.eat() ;
}
}核心内容
反射调用普通方法
Ⅰ、取得⼀个类中的全部普通方法
package test28;
import java.lang.reflect.Method;
class Person {
private String name ;
private int age ;
public Person() {}
public Person(String name,int age) {
this.name = name ;
this.age = age ;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + 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;
}
}
public class Test {
public static void main(String[] args) throws Exception {
Class<?> cls = Person.class ;
Method[] methods = cls.getMethods() ;
for (Method method : methods) {
System.out.println(method);
}
}
}
Ⅱ、通过反射调用setter、getter方法
补充知识：invoke可以实现动态调用，例如可以动态的传入参数，可以把方法参数化。
package test28;
import java.lang.reflect.Method;
class Person {
private String name ;
private int age ;
public Person() {}
public Person(String name,int age) {
this.name = name ;
this.age = age ;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + 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;
}
}
public class Test {
public static void main(String[] args) throws Exception {
Class<?> cls = Class.forName("test28.Person");
// 任何时候调用类中的普通方法都必须有实例化对象
Object obj = cls.newInstance() ;
//取得setName这个方法的实例化对象,设置方法名称与参数类型
Method setMethod = cls.getMethod("setName", String.class) ;
//随后需要通过Method类对象调用指定的方法，调用方法需要有实例化对象
//同时传入参数
setMethod.invoke(obj, "sakura") ;
Method getMethod = cls.getMethod("getName") ;
Object result = getMethod.invoke(obj) ; // 相当于Person对象.getName() ;
System.out.println(result) ;
}
}特别注意
1.Java中养成习惯写无参的构造方法。
原因：Class类通过反射实例化类对象的时候，只能够调用类中的无参构造。如果现在类中没有无参构造则无
法使用Class类调用，只能够通过明确的构造调用实例化处理。
扫一扫
1804
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
