java注解与反射_clazz.newinstance() 父对象缺失-优快云博客

@Retention(RetentionPolicy.RUNTIME) // 元注解
@Target({ElementType.TYPE, ElementType.METHOD}) // 元注解
public @interface A {
// 每一个方法实际上就是配置了一个参数
String name() default ""; // name 参数名， String 参数类型 default '' 默认为空
int age() default 0;
}

public @interface A {
// 只有一个参数，一般用value命名，传参的时候，不需要写 value = xxx， 直接将xxx传放入
String value();
}

反射概述

反射实际上就是java视为动态语言的关键，借助反射，我们可以在代码执行期间，通过Class类去操纵任何类的内部信息，比如内部属性或方法，甚至可以去操作私有属性！

但是对性能有影响！

Class类的概念下面讲！

Java反射机制提供的功能：

在运行时判断任意一个对象所属的类
在运行时构造任意一个类的对象
在运行时判断任意一个类所具有的成员变量和方法
在运行时调用任意一个对象的成员变量和方法
在运行时获取泛型信息
在运行时处理注解
生成动态代理

Class 类

注意Class 的首字母大写，代表一种类！（小写class 有其它作用）

首先呢，本身也是一个对象！由系统创建，在加载器将你写的代码定义的类加载到堆内存中的时候，就创建了这个对象。而它呢，是用来描述你写的代码中类的结构的（比如：属性，构造器，方法，接口，枚举，注解….）,你写的类不论创建(new)多少对象，这些对象都只拥有一个Class 对象！而我们呢，就可以通过对象的反射指向这个Class对象，得到这个Class对象，从而在执行期间去改变或者去获取关于你写的这个类的信息

Class类对应一个 JVM中的一个Class实例
一个Class对象对应的是一个加载到JVM中的一个.class文件

获取Class类的一些方法

//方法1 _通过对象获得
Class c1 = person.getClass();
//方法2 _通过forname
Class c2 = Class.forname("com.kuang.reflection.Student");
//方法3 _通过类名.class
Class c3 = Student.class;
//通过父类也能获得
Class c4 = c1.getSuperclass();

哪些类型可以拥有Class对象？

Java 内存分析

主要分为三个：

栈内存：存放基本变量类型，以及对象的指针
堆内存：主要存放new的对象和数组，可以被所有线程共享
方法区：包含了所有class和static变量的数据结构，可以被所有进程共享

关于一个类的加载过程

主要分三步：

加载阶段
- 这个阶段主要由加载器来工作，也就是ClassLoader, 加载器的概念等下再说！
- 完成的工作呢就是：
  - 1、将class文件的字节码存到内存当中去，变成方法区的运行时数据结构，如上图方法区的样子
  - 2、在堆内存中生成java.lang.Class对象
链接阶段
- 完成的工作呢就是：
  - 1、为类变量(static) 分配内存以及赋予上默认初始值！比如 static int a = 0; static String b = “”；这样子。
  - 2、为类的常量值进行赋值先这么理解吧，也就是说，在这个阶段，常量值是可以使用的！相当于为为这些finel， static，int，string，char，boolean，short,long,integer都指向方法区中的常量池
初始化阶段
- 这个阶段调用类构造器<clinit>，完成的工作，好比上图
  - 1、将类变量进行真正的赋值，也就是你写的代码这个变量到底等于多少！
  - 2、将静态代码块中的语句进行合并！
  - 3、初始一个类的时候，父类没初始化，则先触发父类的初始化

首先来说加载器的概念

类加载器的作用：也就是在上面加载阶段所完成的事

类缓存：一旦类被加载到内存中，则会存在一段时间，然后再被回收！

加载器分为三种：

系统加载器：你写的用户自定义类的加载器，也是我们用的最多的加载器,父加载器是扩展加载器，可以获得引用

// 获取系统类加载器
ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
//AppClassLoader是我们自定义的加载器，父类是扩展加载器，爷爷类值根加载器

扩展加载器：存放在 jre/lib/ext目录下jar包里面类的加载器，父加载器就是根加载器，可以获得引
```
// 获取系统类加载器的父类加载器>>扩展加载器
ClassLoader sysParent = systemClassLoader.getParent();
```

根加载器： Java的核心类，是通过这个加载器获得，我们并能获取它的引用, 为null

ClassLoader extParent = sysParent.getParent();
//获取扩展类加载器的父类加载器>>根加载器 但是获取的值为null

再来说下初始化阶段的发生阶段

类的主动引用（一定会发生类的初始化）
- 虚拟机启动，执行main方法所在的类，这个类会到初始化阶段
- new A() 也会发生初始化
- 调用类的静态方法和静态属性(除了final 常量)
- 使用java.lang.reflect包的方法，也就是获取Class的方法，也会将该类进行初始化
- 初始化子类的时候，父类如果没有初始化，则会先初始化父类
类的被动引用 (不会发生类的初始化)
- 子类引用父类的静态变量，子类不会初始化
- 数组定义分配空间，也不会引起该类的初始化 Son[] son1 = new Son[5]
- 引用常量也不会触发此类的初始化，因为再类加载的过程的第二阶段链接阶段，常量就已经可以用了

如何在运行时获得类的完整结构

实际上我们就是通过反射，也就是拿到Class类，然后执行Class类的方法，就可以获得运行时你自己写的类的完整的数据结构了，包括：接口、所继承的父类、全部构造器、全部方法、全部属性、注解….

Class类的一些方法：

package com.ClassLoader.Demo;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
/**
*/
public class Demo2 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
// Class c1=Class.forName("com.ClassLoader.Demo.User");
User user=new User();
Class c1=user.getClass();
System.out.println(c1.getSimpleName());
System.out.println("*************************");
// 获取类的名字 +详细路径
System.out.println(c1.getName());
// 得到类的名字
System.out.println(c1.getSimpleName());
// 得到该类的属性
Field[] fields=c1.getFields(); //能够找到public属性
fields=c1.getDeclaredFields(); //能够找到全部属性包括private
for (Field field:fields) {
System.out.println(field);
}
Field name=c1.getDeclaredField("name");
System.out.println(name);
System.out.println("*************************");
// 得到类的方法
Method[] methods=c1.getDeclaredMethods();
for (Method method : methods) { //获得本类及其父类的所有方法包括子类父类的private
System.out.println("getDeclaredMethods:"+method);
}
System.out.println("*************************");
Method[] methods1=c1.getMethods();
for (Method method : methods1) { //获得本类的的所有方法只能public方法
System.out.println("getMethods:"+method);
}
System.out.println("*************************");
// 获得指定的方法
// 重载
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();//获得public方法
for (Constructor constructor : constructors) {
System.out.println(constructor);
}
Constructor[] constructors1=c1.getDeclaredConstructors();//获得全部方法
for (Constructor constructor : constructors1) {
System.out.println(constructor);
}
System.out.println("*************************");
//获得指定构造器
Constructor declareConstructor=c1.getDeclaredConstructor(String.class,int.class,double.class);
System.out.println(declareConstructor);
}
}

除了获得类的完整结构，得到了Class对象，我们还能干什么？

创建类的对象，也就是实例，平常我们通过new A()的方式创建的实例，我们现在可以通过反射创建

// 利用 Class类的newInstance()方法，调用了无参构造器创建实例
Class aClass=Class.forName("com.ClassLoader.Demo.User");
User user1=(User) aClass.newInstance();

// 非只能用无参构造器创建对象，用有参构造器也可以
// 先通过Class类的getDeclaredConstructor(对应的参数)方法获得有参构造器
// 然后调用有参构造器的newInstance()方法,就可以创建实例了
Constructor constructor=aClass.getDeclaredConstructor(String.class,int.class,double.class);
User user2=(User) constructor.newInstance("xxx",xx,xx);//参数数量要一致否则出现异常

通过反射，去操作实例的方法和属性

// 通过反射调用普通方法
User user= (User) aClass.newInstance();
// 通过反射获取一个方法
Method setName=aClass.getDeclaredMethod("setName", String.class);
// inoke激活，将实例作为第一个参数传入，修改的数据作为第二个参数
setName.invoke(user,"xxx");
System.out.println(user.getName());

通过反射操作泛型就省略了！

重点：通过反射操作注解

package com.AnnotationReflect.Demo;
import java.lang.annotation.*;
import java.lang.reflect.Field;
/**
* @Description TODO
* @Author Y
*/
public class Demo1 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
Class c1=Class.forName("com.AnnotationReflect.Demo.Student1");
// 通过反射获得注解
Annotation[] annotations=c1.getAnnotations();
for (Annotation annotation : annotations) {
System.out.println(annotation);
}
// 获得类的注解value参数的值
TableY tableY=(TableY)c1.getAnnotation(TableY.class);
String value=tableY.value();
System.out.println(value);
// 获得类具体指定属性的注解
Field field=c1.getDeclaredField("name");
FiledStudent annotation=field.getAnnotation(FiledStudent.class);
System.out.println(annotation.columName());
System.out.println(annotation.type());
System.out.println(annotation.length());
}
}
@TableY("studentinfo")
class Student1{
@FiledStudent(columName = "Sno",type="int",length = 10)
private int id;
@FiledStudent(columName = "Sname",type="int",length = 10)
private String name;
@FiledStudent(columName = "Sex",type="int",length = 10)
private String sex;
public Student1(int id, String name, String sex) {
this.id = id;
this.name = name;
this.sex = sex;
}
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;
}
}
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface FiledStudent{
String columName();
String type();
int length();
}
//类名的注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface TableY{
String value();
}