标签：turn col 虚拟 throw 开始 ret 利用反射 table 实体
Annotation是从JDK5.0开始引入的新技术
Annotation的作用:
Annotation的格式：
Annotation在哪里使用？
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
//注解的参数:参数类型 + 参数名 ()
String name() default "";
int age() default 0;
int id();
String[] schools() default {"清华大学", "北京大学"};
}
class Test {
//如果没有默认值，我们就必须给注解赋值
@MyAnnotation(id = 2006)
public void test() {
}
}
与动态语言相对应的，运行时结构不可变的语言就是静态语言。如:Java、C、C++
Java不是动态语言，但Java可以称之为"准动态语言"。即Java有一定的动态性，我们可以利用反射机制获取类似动态语言的特性。Java的动态性让编程的时候更加灵活！
Reflection(反射)是Java被视为动态语言的关键，反射机制运行程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。
Class c = Class.forName("java.lang.String")
package com.ycy.demo02;
/**
* @author YeCaiYu
* @date 2020-05-04 9:43
*/
public class Test02 {
public static void main(String[] args) throws ClassNotFoundException {
//通过反射获取类的Class对象
Class c1 = Class.forName("com.ycy.demo02.User");
System.out.println(c1);
Class c2 = Class.forName("com.ycy.demo02.User");
Class c3 = Class.forName("com.ycy.demo02.User");
Class c4 = Class.forName("com.ycy.demo02.User");
//一个类在内存中只有一个Class对象
//一个类被加载后，类的整个结构都会被封装在Class对象中
System.out.println(c1.hashCode());
System.out.println(c2.hashCode());
System.out.println(c3.hashCode());
System.out.println(c4.hashCode());
}
}
//实体类:pojo , entity
class User {
private String name;
private int id;
private int age;
public User() {
}
public User(String name, int id, int age) {
this.name = name;
this.id = id;
this.age = age;
}
@Override
public String toString() {
return "User{" +
"name=‘" + name + ‘\‘‘ +
", id=" + id +
", age=" + age +
‘}‘;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
在Object类中定义了以下的方法，此方法被所有子类集成
public final Class getClass()
对象照镜子后可以得到的信息：某个类的属性、方法和构造器、某个类到底实现了那些接口。对于每个类而言，JRE都为其保留一个不变的Class类型的对象。一个Class对象包含了特定某个结构(class/interface/enum/annotation/primitive type/void/[])的有关信息。
| 方法名 | 功能说明 |
|---|---|
| static ClassforName(String name) | 返回指定类名name的Class对象 |
| Object newInstance() | 调用缺省构造函数，返回Class对象的一个实例 |
| getName() | 返回此Class对象所表示的实体(类、接口、数组类或void)的名称 |
| Class getSuperClass() | 返回当前Class对象的父类的Class对象 |
| Class[] getinterfaces() | 获取当前Class对象的接口 |
| Constructor[] getConstructors() | 返回一个包含某些Constructor对象的数组 |
| ClassLoader getClassLoader() | 返回该类的加载器 |
| Method getMethod(String name.Class.. T) | 返回一个Method对象，此对象的形参类型为paramType |
| Field[] getDeclaredFields() | 返回Field对象的一个数组 |
package com.ycy.demo02;
/**
* @author YeCaiYu
* @date 2020-05-04 10:05
*/
//测试Class类的创建有哪些
public class Test03 {
public static void main(String[] args) throws ClassNotFoundException {
Person person = new Student();
System.out.println("这个人是：" + person.name);
//方式一: 通用对象获取
Class c1 = person.getClass();
System.out.println(c1.hashCode());
//方式二: forName获取
Class c2 = Class.forName("com.ycy.demo02.Student");
System.out.println(c2.hashCode());
//方式三: 通过类名.class获取
Class c3 = Student.class;
System.out.println(c3.hashCode());
//方式四: 基本内置类型的包装类都有一个Type属性
Class c4 = Integer.TYPE;
System.out.println(c4);
//获得父类类型
Class c5 = c1.getSuperclass();
System.out.println(c5);
}
}
class Person {
public String name;
public Person() {
}
public Person(String name) {
this.name = name;
}
@Override
public String toString() {
return "Person{" +
"name=‘" + name + ‘\‘‘ +
‘}‘;
}
}
class Student extends Person {
public Student() {
this.name = "学生";
}
}
class Teacher extends Person {
public Teacher() {
this.name = "老师";
}
}
package com.ycy.demo02;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
/**
* @author YeCaiYu
* @date 2020-05-04 10:54
*/
public class Test05 {
//获取类的信息
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
Class c1 = Class.forName("com.ycy.demo02.User");
//获取类的名字
System.out.println(c1.getName());//获取包名 + 类名
System.out.println(c1.getSimpleName()); //获取类名
//获取类的属性
Field[] fields = c1.getFields();//只能找到public属性
for (Field field : fields) {
System.out.println(field);
}
System.out.println("++++++++++++++++++++++");
fields = c1.getDeclaredFields();//能找到全部的属性
for (Field field : fields) {
System.out.println(field);
}
//获取指定属性的值
Field name = c1.getDeclaredField("name");
System.out.println(name);
//获取类的方法
System.out.println("+++++++++++++++++++++++");
Method[] methods = c1.getMethods();//获得本类及其父类全部public方法
for (Method method : methods) {
System.out.println(method);
}
System.out.println("+++++++++++++++++++++++");
methods = c1.getDeclaredMethods();//获取本类的所有方法
for (Method method : methods) {
System.out.println(method);
}
//获得指定的方法
Method getName = c1.getMethod("getName", null);
Method setName = c1.getMethod("setName", String.class);
System.out.println(getName);
System.out.println(setName);
System.out.println("********************************");
//获取指定的构造器
Constructor[] constructors = c1.getConstructors();
for (Constructor constructor : constructors) {
System.out.println(constructor);
}
System.out.println("********************************");
constructors = c1.getDeclaredConstructors();
for (Constructor constructor : constructors) {
System.out.println(constructor);
}
//获得指定构造器
Constructor constructor = c1.getConstructor(String.class, int.class, int.class);
System.out.println("指定：" + constructor);
}
}
通过反射，调用类中的方法，通过Method类完成。
若原方法声明为private，则需要在调用此invoke()方法前，显式调用对象的setAccessible(true)方法，将可访问private
标签：turn col 虚拟 throw 开始 ret 利用反射 table 实体
原文地址：https://www.cnblogs.com/YeCaiYu/p/12825900.html
