注解和反射

一、注解（Annotation）

是从JDK5.0引入的新技术

Annotation的作用：

·可以对程序作出解释

·可以被其他程序读取

Annotation的格式：

·注解是以"@注释名"在代码中存在，还可以添加一些参数值

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 {
	
    	//抑制全部警告
		@SuppressWarnings("all")
		public static void main(String[] args) {
			Scanner scan = new Scanner(System.in);
			String str = scan.next();	
			method02();		
		}
		
    	//过时警告
		@Deprecated
		public static void method02(){
			
		}
	
    	//抑制单类型的警告信息
		@SuppressWarnings("unchecked")
		public static void method01(){
			ArrayList list = new ArrayList();	
			list.add(123);
			list.add("str");
		}
	}

元注解

Java定义了4个标准的meta-annotation类型:

@Target：用于描述注解的使用范围(即:被描述的注解可以用在什么地方）

ElementType的取值包含以下几种：

• TYPE:类，接口或者枚举
• FIELD:域，包含枚举常量
• METHOD:方法
• PARAMETER:参数
• CONSTRUCTOR:构造方法
• LOCAL_VARIABLE:局部变量
• ANNOTATION_TYPE:注解类型
• PACKAGE:包

@Retention：表示需要要在什么级别保存该注择信息，用于描述注解的生命周期 (默认值是runtime)

​ (SOURCE < CLASS < RUNTIME)

• SOURCE：源码级别保留，编译后即丢弃。
• CLASS:编译级别保留，编译后的class文件中存在，在jvm运行时丢弃，这是默认值。
• RUNTIME： 运行级别保留，编译后的class文件中存在，在jvm运行时保留，可以被反射调用。

@Document：说明该注解将被包含在javadoc中

@Inherited：说明子类可以继承父类中的该注解

自定义注解

@interface用来声明一个注解，格式：public @interface注解名{定义内容}

其中的每一个方法实际上是声明了一个配置参数.

方法的名称就是参数的名称.

返回值类型就是参数的类型（返回值只能是基本类型、Class、String、enum）

可以通过default来声明参数的默认值

如果只有一个参数成员，一般参数名为value()

自定义注解

	//自定义注解
	@Target({ElementType.TYPE,ElementType.METHOD})
	@Retention(RetentionPolicy.RUNTIME)
	public @interface MyAnnotation01 {
		//注解参数
		String[] author();
	}

	//使用注解
	@MyAnnotation01(author = {"hhy","cjk"})
	public class Test01 {
		@MyAnnotation01(author = "fjj")
		public static void main(String[] args) {
			/**
			 * 自定义注解
			 */
		}
	}

注解使用一个value参数

	//自定义注解
	@Target({ElementType.TYPE,ElementType.METHOD})
	@Retention(RetentionPolicy.RUNTIME)
	public @interface MyAnnotation01 {
		//注解参数
		//使用value不用写键值对，直接写值
		String[] value();
	}

	//使用注解
	@MyAnnotation01({"hhy","cjk"})
	public class Test01 {
		@MyAnnotation01("fjj")
		public static void main(String[] args) {
			/**
			 * 自定义注解
			 */
		}
	}

多个注解参数

	//自定义注解
	@Target({ElementType.TYPE,ElementType.METHOD})
	@Retention(RetentionPolicy.RUNTIME)
	public @interface MyAnnotation01 {
		//注解参数
		String[] author();
		String[] version();
	}

	//使用注解
	@MyAnnotation01(author = {"hhy","cjk"},version = "1.0")
	public class Test01 {
		@MyAnnotation01(author = "fjj" , version = "1.0")
		public static void main(String[] args) {
			/**
			 * 自定义注解
			 */
		}
	}

给注解参数设置默认值

	//自定义注解
	@Target({ElementType.TYPE,ElementType.METHOD})
	@Retention(RetentionPolicy.RUNTIME)
	public @interface MyAnnotation01 {
		//注解参数
		//default设置默认参数
		String[] author() default "xxx";
		String[] version() default "1.0";
	}

	//使用注解
	@MyAnnotation01()
	public class Test01 {
		@MyAnnotation01()
		public static void main(String[] args) {
			/**
			 * 自定义注解
			 */
		}
	}

二、反射（Reflection）

静态语言 VS 动态语言

动态语言:

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

静态语言：

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

反射

Reflection(反射）是Java被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法

加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象)，这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为:反射

Java反射机制提供的功能
·在运行时判断任意一个对象所属的类

·在运行时构造任意一个类的对象

·在运行时判断任意一个类所具有的成员变量和方法

·在运行时获取泛型信息

·在运行时调用任意一个对象的成员变量和方法

·在运行时处理注解

·生成动态代理

反射的优缺点

优点:

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

缺点:

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

·java.lang.Class:代表一个类

·java.lang.reflect.Method:代表类的方法

·java.lang.reflect.Field :代表类的成员变量

·java.lang.reflect.Constructor:代表类的构造器

Class类

在Object类中定义了以下的方法，此方法将被所有子类继承

以上的方法返回值的类型是一个Class类，此类是Java反射的源头，实际上所谓反射从程序的运行结果来看也很好理解，即:可以通过对象反射求出类的名称。

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

·Class本身也是一个类

·Class 对象只能由系统建立对象

·一个加载的类在JVM中只会有一个Class实例

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

·每个类的实例都会记得自己是由哪个Class 实例所生成

·通过Class可以完整地得到一个类中的所有被加载的结构

·Class类是Reflection的根源，针对任何你想动态加载、运行的类，唯有先获得相应的Class对象

Class类的常用方法

测试class类的创建方式有哪些

//测试class类的创建方式有哪些
public class Test {
   public static void main(String[] args) throws ClassNotFoundException {
       Person person = new Student();
       System.out.println("这个人是：" + person.getName());

       //方式一：通过对象获得
       Class person1 = person.getClass();
       System.out.println(person1.hashCode());     //2128227771

       //方式二：forName获得
       Class person2 = Class.forName("com.qf.test.Student");
       System.out.println(person2.hashCode());     //2128227771

       //方式三：通过类名.class获得
       Class<Student> person3 = Student.class;
       System.out.println(person3.hashCode());  //2128227771

       //方式四：基本内置类型都包装类都有一个TYPE属性
       Class type = Integer.TYPE;
       System.out.println(type);       //int

       //获得父类类型
       Class superclass = person1.getSuperclass();
       System.out.println(superclass);     //class com.qf.test.Person
   }
}

//实体类
class Person{
   private String name;

   public Person() {
   }

   public Person(String name) {
       this.name = name;
   }

   public String getName() {
       return name;
   }

   public void setName(String name) {
       this.name = name;
   }

   @Override
   public String toString() {
       return "User{" +
               "name='" + name + '\'' +
               '}';
   }
}

class Student extends Person{
   public Student(){
       this.setName("学生");
   }
}

class Teacher extends Person{
   public Teacher(){
       this.setName("老师");
   }
}

常见类型的Class对象

//常见类型的Class对象
public class Test {
   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

       //只要元素类型与维度一样，就是同一个class
       int[] a = new int[1];
       int[] b = new int[100];
       System.out.println(a.getClass().hashCode());//2128227771
       System.out.println(b.getClass().hashCode());//2128227771
   }
}