动态性
动态语言
- 在程序运行时，可以改变程序结构或变量类型，典型的语言：
- Python，ruby，javascript
- 如：
function test(){
var s = "var a=3;var b=5;alert(a+b);";
eval(s);
}
Java的动态性
- C，C++，JAVA不是动态语言，但是JAVA有一定的动态性
- 我们可以利用反射机制，字节码操作获得类似动态语言的特性
- JAVA的动态性让编程的时候更加灵活
Class类
反射机制
- 指的是可以于运行时加载，探知，使用编译期间完全未知的类
- 程序在运行状态中，可以动态加载一个只有名称的类，对于任意一个已加载的类，都能知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性。
、Class c=Class.forName("com.User");
"com.User"是字符串，是类的路径，可以动态的实时的加载这个类。- 加载完类之后，在堆内存中，就产生一个Class类型的对象，一个类只有一个Class对象，这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象像一面镜子，透过这个镜子看到类的结构。所以称之为反射、
先简单写一个com.User
public class User {
/**
*
*/
private int id;
private int age;
private String uname;
public User() {
}
public User(int id,int age,String uname){
super();
this.id=id;
this.age=age;
this.uname=uname;
}
public String getUname() {
return uname;
}
public void setUname(String uname) {
this.uname = uname;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
}
获取Class对象的方式
- 获取Class对象的三种方式
- 1 Object ——>
getClass(); - 2 任何数据类型（包括基本数据类型int，数组等）都有一个“静态”的class属性
- 3 通过Class类的静态方法：
forName（String className）(常用)
public class Demo01 {
public static void main(String []args){
//第一种 Object ——> getClass();
User user1 = new User();
Class clazz1=user1.getClass();
System.out.println(clazz1.hashCode());
//第二种 任何数据类型（包括基本数据类型）都有一个“静态”的class属性
Class clazz2 = User.class;
System.out.println(clazz2.hashCode());
//第三种：通过Class类的静态方法：forName（String className）(常用)
String path="com.fanshe.User";
try {
Class clazz3=Class.forName(path);
System.out.println(clazz3.hashCode());
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
这三种方法得到的hashcode是一样的，这验证了一个类只有一个Class对象：一个工厂可以有很多辆车，但可能只有一张图纸。
反射机制的常见作用
反射的使用主要就是获取到了Class对象之后，通过调用Class对象的方法来操纵。
public class Demo02 {
public static void main(String[] args) throws NoSuchMethodException {
//第三种：通过Class类的静态方法：forName（String className）(常用)
String path="com.fanshe.User";
try {
Class clazz3=Class.forName(path);
//获得类的名字
System.out.println("\n获取类的名字: ");
System.out.println(clazz3.getName());//包名加类名
System.out.println(clazz3.getSimpleName());//类名
//获取属性信息
System.out.println("\n获取属性信息: ");
Field[] field=clazz3.getFields();
Field[] field1=clazz3.getDeclaredFields();
System.out.println(field.length+" "+field1.length);//前者只能读取public的
Field field2 = clazz3.getDeclaredField("id");
for(Field temp:field1){
System.out.println("属性: "+temp);
}
//获取方法的属性
System.out.println("\n获取方法的属性: ");
Method[] methods = clazz3.getDeclaredMethods();
Method method = clazz3.getMethod("setUname", String.class);//单一方法
Method method1 = clazz3.getMethod("getUname",null);
for(Method temp:methods){
System.out.println("方法： "+temp);
}
//获得构造器的信息
System.out.println("\n获得构造器信息: ");
Constructor[] constructors = clazz3.getDeclaredConstructors();
for(Constructor temp:constructors){
System.out.println("构造器: "+temp);
}
Constructor constructor = clazz3.getDeclaredConstructor(int.class,int.class,String.class);
System.out.println("有参构造器："+clazz3);
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (NoSuchFieldException e) {
e.printStackTrace();
}
}
}
运行结果
获取类的名字:
com.fanshe.User
User
获取属性信息:
0 3
属性: private int com.fanshe.User.id
属性: private int com.fanshe.User.age
属性: private java.lang.String com.fanshe.User.uname
获取方法的属性:
方法： public int com.fanshe.User.getId()
方法： public java.lang.String com.fanshe.User.getUname()
方法： public void com.fanshe.User.setUname(java.lang.String)
方法： public void com.fanshe.User.setId(int)
方法： public int com.fanshe.User.getAge()
方法： public void com.fanshe.User.setAge(int)
获得构造器信息:
构造器: public com.fanshe.User()
构造器: public com.fanshe.User(int,int,java.lang.String)
有参构造器：class com.fanshe.User
通过反射API的动态操作
public class Demo03 {
public static void main(String []args){
//第三种：通过Class类的静态方法：forName（String className）(常用)
String path="com.fanshe.User";
try {
Class clazz3=Class.forName(path);
/*通过反射API调用构造方法，构造对象*/
//其实是调用了User的无参方法
User user = (User)clazz3.newInstance();
user.setUname("大王");
System.out.println(user.getUname());
//获得方法
Constructor<User> constructor = clazz3.getDeclaredConstructor(int.class,int.class,String.class);
//通过实际的参数来调用
User user1 = constructor.newInstance(1001,18,"美云");
System.out.println(user1.getUname());
/*通过反射API调用普通方法*/
//user1.setUname("小七");
User user2 =(User) clazz3.newInstance();
Method method = clazz3.getDeclaredMethod("setUname",String.class);
method.invoke(user2,"小七");
System.out.println(user2.getUname());
/*通过反射API操作属性*/
User user3 = (User)clazz3.newInstance();
Field f =clazz3.getDeclaredField("uname");
f.setAccessible(true);
f.set(user3,"小赖");
System.out.println(user3.getUname());
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
} catch (NoSuchFieldException e) {
e.printStackTrace();
}
}
}
运行结果明显
大王
美云
小七
小赖
这样写有什么好处呢？可以发现setUname 是字符串，传的参数也是变量，这样的变量我们就可以从文件中读取，可以从数据库中读取，总之可以从其他地方传过来，这样就实现了动态的调用，动态创建类。
参考
[1] https://www.cnblogs.com/nullcodeworld/p/8878747.html
[2] b站：av29578196
京公网安备 11010502036488号