注解和反射

注解

• 注解入门
• 内置注解
• 自定义注解, 元注解

什么是注解

• Annotation 是从JDK5.0开始引入的新技术
• Annotation的作用:
  • 不是程序本身, 可以对程序作出解释.(这一点和注释(comment)没什么区别)
  • 可以被其他程序(比如: 编译器等)读取
• Annotation的格式:
  • 注解是以"@注释名"在代码中存在的, 还可以添加一些参数值, 例如: @SuppressWarnings(value=“unchecked”).
• Annotation在哪里使用?
  • 可以附加在package, class, method, field等上面, 相当于给他们添加了额外的辅助信息, 我们可以通过反射机制编程实现对这些元数据的访问

内置注解

• @Override: 定义在java.lang.Override中, 此注释只适用于修饰方法, 表示一个方法声明打算重写超类中的另一个方法声明:
• @Deprecated: 定义在java.lang.Deprecated中, 此注释可以用于修饰方法, 属性, 类, 表示不鼓励程序员使用这样的元素, 通常是因为它很危险或者存在更好的选择.
• @SuppressWarnings: 定义在java.lang.SuppressWarnings中, 用来抑制编译时的警告信息.
  • 与前两个注释有所不同, 你需要添加一个参数才能正确使用, 这些参数都是已经定义好了的, 我们选择性的使用就好了.
  • @SuppressWarnings(“all”)
  • @SuppressWarnings(“unchecked”)
  • @SuppressWarnings(value={“unchecked”, “deprecation”})
  • 等等…

// 什么是注解
public class Test01 extends Object{
	// @Override  重写的注解
	@Override
	public String toString(){
		return super.toString();
	}
	
	// Deprecated 不推荐程序员使用, 但是可以使用, 或者存在更好的方式
	@Deprecated
	public static void test(){
		System.out.println("Deprecated");
	}

	// 可放在类上, 方法上
	@SuppressWarnings("all)
	public void test02(){
		List list = new ArrayList();
	}
	
	public static void main(String[] args){
		// 一般调用过时的方法, 程序中会出现删除线
		test();
	}
}

元注解

• 元注解的作用就是负责注解其他注解, Java定义了4个标准的meta-annotation类型, 他们被用来提供对其他annotation类型作说明.
• 这些类型和它们所支持的类在java.lang.annotation包中可以找到.(@Target, @Retention, @Documented, @Inherited)
  • @Target(必写): 用于描述注解的使用范围(即: 被描述的注解可以用在什么地方)
  • @Retention(必写): 表示需要在什么级别保存该注释信息, 用于描述注解的声明周期(SOURCE < CLASS < RUNTIME)
  • @Document: 说明该注解将被包含在javadoc中
  • @Inherited: 说明子类可以继承父类中的该注解

// 测试注解
public class Test02{
	@AnnotationTest
	public void test(){
		
	}
}

// 定义一个注解
// Target 表示我们注解可以用在哪些地方。
@Target(value = {ElementType.METHOD, ElementType.TYPE})

// Retention 表示我们的注解在什么地方还有效
// runtime > class > sources
@Retention(value = RetentionPolicy.RUNTIME)

// Documented 表示是否要将我们的注解生成在javadoc中
@Documented

// Inherited 子类可以继承父类的注解
@Inherited
@interface AnnotationTest{
}

自定义注解

• 使用@interface自定义注解时, 自动继承了java.lang.annotation.Annotation接口
• 分析:
  • @interface用来声明一个注解, 格式: public @interface 注解名{定义内容}
  • 其中的每一个方法实际上是声明了一个配置参数.
  • 方法的名称就是参数的名称.
  • 返回值类型就是参数的类型(返回值只能是基本类型, Class, String, enum)
  • 可以通过default来声明参数的默认值
  • 如果只有一个参数成员, 一般参数名为value
  • 注解元素必须要有值, 我们定义注解元素时, 经常使用空字符串, 0作为默认值.

// 自定义注解
public class Test{
	// 注解可以显示赋值, 如果没有默认值, 我们就必须给注解赋值
	@MyAnnotation(age = 19, name="测试")
	public void test(){}

	@MyAnnotation2("测试")
	public void test2(){
		
	}
}

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation{
	// 注解的参数 : 参数类型 + 参数名();
	String name() default "";
	int age();
	int id() default 1;// 如果默认值为-1, 代表不存在
	
	String[] testS() default {"测试文本1", "测试文本2"};
}

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation2{
	String value();
}

反射

• Java反射机制概述
• 理解Class类并获取Class实例
• 类的加载与ClassLoader
• 创建运行时类的对象
• 获取运行时类的完整结构
• 调用运行时类的指定结构

静态 VS 动态语言

动态语言

• 是一类在运行时可以改变其结构的语言: 例如新的函数, 对象, 甚至代码可以被引进, 已有的函数可以被删除或是其他结构上的变化。通俗点说就是在运行时代码可以根据某些条件改变自身结构。
• 主要动态语言: Object-C, C#, Javascript, PHP, Python等。

静态语言

• 与动态语言想对应的, 运行时结构不可变的语言就是静态语言。如Java, C, C++。
• Java不是动态语言, 但Java可以称之为"准动态语言"。即Java有一定的动态性, 我们可以利用反射机制获得类似动态语言的特性。Java的动态性让编程的时候更加灵活!

Java reflection

• Reflection(反射)是Java被视为动态语言的关键, 反射机制允许程序在执行期借助于Reflection API 取得任何类的内部信息, 并能直接操作任意对象的内部属性及方法。
• 加载完类之后, 在堆内存的方法中就产生了一个Class类型的对象(一个类只有一个Class对象), 这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子, 透过这个镜子看到类的结构, 所以, 我们形象的称之为: 反射

Class c = Class.forName("java.lang.String");
正常方式:
1. 引入需要的"包类"名称
2. 通过new实例化
3. 取得实例化对象
反射方式:
1. 实例化对象
2. getClass()方法
3. 得到完整的"包类"名称

Java反射机制研究及应用

Java反射机制提供的功能

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

Java反射有点和缺点

优点

• 可以实现动态创建对象和编译, 体现出很大的灵活性

缺点

• 对性能有影响。使用反射基本上是一种解释操作, 我们可以告诉JVM, 我们希望做什么并且它满足我们的要求。这类操作总是慢于直接执行相同的操作。

反射相关的API

• java.lang.class: 代表一个类
• java.lang.reflect.Method: 代表类的方法
• java.lang.reflect.Field: 代表类的成员变量
• java.lang.reflect.Constructor: 代表类的构造器
• …

// 什么叫反射
public class Test{
	public static void main(String[] args) throws ClassNotFoundException {
		// 通过反射获取类的Class对象
		// 具体的路径.到类名
		Class c1 = Class.forName("cn.test.test");
		Class c2 = Class.forName("cn.test.test");
		Class c3 = Class.forName("cn.test.test");
		Class c4 = Class.forName("cn.test.test");
		
		// 一个类在内存中只有一个Class对象
		// 一个类被加载后, 类的整个结构都会被封装在Class对象中
		System.out.println(c1.hashCode());
		System.out.println(c2.hashCode());
		System.out.println(c3.hashCode());
		System.out.println(c4.hashCode());
	}
}

Class类

对象照镜子后可以得到的信息: 某个类的属性, 方法和构造器, 某个类到底实现了哪些接口。对于每个类而言, JRE都为其保留一个不变的Class类型的对象。一个Class对象包含了特定某个结构(class/interface/enum/annotation/primitive type/void/[])的有关信息。

• Class本身也是一个类
• Class对象只能由系统建立对象
• 一个加载的类在JVM中只会有一个Class实例
• 一个Class对象对应的是一个加载到JVM中的一个.class文件
• 每个类的实例都会记得自己是由哪个Class实例所生成
• 通过Class可以完整地得到一个类中的所有被加载的结构
• Class类是Reflection的根源, 针对任何你想动态加载, 运行的类, 唯有先获得相应的Class对象

获取Class类的实例

1. 若已知具体的类, 通过类的class属性获取, 该方法最为安全可靠, 程序性能最高。
   Class clazz = Person.class;
2. 已知某个类的实例, 调用该实例的getClass()方法获取Class对象
   Class clazz = person.getClass();
3. 已知一个类的全类名, 且该类在类路径下, 可通过Class类的静态方法forName()获取, 可能抛出ClassNotFoundException
   Class clazz = Class.forName(“demo01.Student”);
4. 内置基本数据类型可以直接用类名.Type
5. 还可以利用ClassLoader我们之后讲解

 public static void main(String[] args) {
        // 获取类的实例
        // 1.
        try {
            Class aClass = Class.forName("tk.mybatis.simple.model.Country");
            System.out.println(aClass.hashCode());
            System.out.println(aClass);


            // 2.
            Class countryClass = Country.class;
            System.out.println(countryClass.hashCode());
            System.out.println(countryClass);

            // 3.
            Class aClass1 = new Country().getClass();
            System.out.println(aClass1);
            System.out.println(aClass1.hashCode());

            // 4.
            Class type = Integer.TYPE;
            System.out.println(type);
            System.out.println(type.hashCode());

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

哪些类可以有Class对象?

• class: 外部类, 成员(成员内部类, 静态内部类), 局部内部类, 匿名内部类。
• interface: 接口
• []: 数组
• enum: 枚举
• annotation: 注解@interface
• primitive type: 基本数据类型
• void

public static void main(String[] args) {
        Class c1 = Object.class;// 类
        Class c2 = Comparable.class;// 接口
        Class c3 = String[].class;// 一维数组
        Class c4 = int[][].class;// 二维数组
        Class c5 = Override.class;// 注解
        Class c6 = ElementType.class;// 枚举
        Class c7 = Integer.class;// 基本数据类型
        Class c8 = void.class;// void
        Class c9 = Class.class;// class

        System.out.println(c1);  // class java.lang.Object
        System.out.println(c2);  // interface java.lang.Comparable
        System.out.println(c3);  // class [Ljava.lang.String;
        System.out.println(c4);  // class [[I
        System.out.println(c5);  // interface java.lang.Override
        System.out.println(c6);  // class java.lang.annotation.ElementType
        System.out.println(c7);  // class java.lang.Integer
        System.out.println(c8);  // void
        System.out.println(c9);  // class java.lang.Class

    }

Java内存分析

了解: 类的加载过程

当程序主动使用某个类时, 如果该类还未被加载到内存中, 则系统会通过如下三个步骤来对类进行初始化。

类的加载与ClassLoader的理解

• 加载: 将class文件字节码内容加载到内存中, 并将这些静态数据转换成方法区的运行时数据结构, 然后生成一个代表这个类的java.lang.Class对象.
• 链接: 将java类的二进制代码合并到JVM的运行状态之中的过程。
  • 验证: 确保加载的类信息符合JVM规范, 没有安全方面的问题
  • 准备: 正式为类变量(static)分配内存并设置类变量默认初始值的阶段, 这些内存都将方法区中进行分配。
  • 解析: 虚拟机常量池的符号引用(变量名)替换为直接引用(地址)的过程。
• 初始化:
  • 执行类构造器()方法的过程。类构造器()方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。(类构造器是构造类信息的, 不是构造类对象的构造器)
  • 当初始化一个类的时候, 如果发现其父类还没有进行初始化, 则需要先触发其父类的初始化。
  • 虚拟机会保证一个类的()方法在多线程环境中被正常锁和同步。

测试clinit方法(属于JVM)

class A {
	static {
		System.out.println("A类静态代码块初始化");
		m = 300;
	}
	
	static int m = 100;
	
	public A(){
		System.out.println("A类的无参构造初始化");	
	}
	
}

public class Application{
	public static void main(String[] args){
		// 不用通过实例化, 就可以访问类变量m, 用于区分jvm中clinit()与类构造器()的
		System.out.println(A.m);

		/**
		 * 1. 加载到内存, 会产生一个类对应Class对象
		 * 2. 链接, 链接结束后 m = 0;(此处还没有赋我们期望的默认值, 是这个类型的默认值)
		 * 3. 初始化
		 * 		<clinit>(){
		 * 			System.out.println("A类静态块初始化");
		 * 			m = 300;
		 * 			m = 100;	
		 * 		}
		 **/
	}
}

什么时候会发生类的初始化?

• 类的主动引用(一定会发生类的初始化)
  • 当虚拟机启动, 先初始化main方法所在的类
  • new一个类的对象
  • 调用类的静态成员(除了final常量)和静态方法
  • 使用java.lang.reflect包的方法对类进行反射调用
  • 当初始化一个类, 如果其父类没有被初始化, 则先初始化它的父类
• 类的被动引用(不会发生类的初始化)
  • 当访问一个静态域时, 只有真正声明这个域的类才会被初始化。如: 当通过子类引用父类的静态变量, 不会导致子类初始化
  • 通过数组定义类引用, 不会触发此类的初始化
  • 引用常量不会触发此类的初始化(常量在链接阶段就存入调用类的常量池中了)

public class Application{
	public static void main(String[] args) {
	        // 主动引用
	        // 结果是: main块, 然后父类, 最后子类
	//        B b = new B();
	
	        // 反射也会产生主动调用
	        // 结果是: main块, 然后父类, 最后子类
	//        try {
	//            Class.forName("tk.mybatis.simple.designMode.B");
	//        } catch (ClassNotFoundException e) {
	//            e.printStackTrace();
	//        }
	
	        // 通过子类调用父类的静态变量
	        // 结果是: main块, 然后父类
	//        System.out.println(B.b);
	
	        // 通过子类调用子类的静态块
	        // 结果是: main块, 然后父类, 最后子类
	//        System.out.println(B.m);
	
	        // 通过子类调用子类的静态常量, 因为会放在常量池中
	        // 结果是: main块
	//        System.out.println(B.M);
	
	        // 结果是: main块
	        B[] array = new B[5];
    }
}

class A {
    static int b = 2;
    static{
        System.out.println("父类被加载");
    }
}

class B extends A {
    static{
        System.out.println("子类被加载");
        b = 300;
    }

    static int m = 100;
    static final int M = 1;
}

类加载器的作用

• 类加载的作用: 将class文件字节码内容加载到内存中, 并将这些静态数据转换成方法区的运行时数据结构, 然后在堆中生成一个代表这个类的java.lang.Class对象, 作为方法区中类的数据的访问入口。
• 类缓存: 标准的JavaSE类加载器可以按要求查找类, 但一旦某个类被加载到类加载器中, 他将维持加载(缓存)一段时间。不过JVM垃圾回收机制可以回收这些Class对象