注解与反射

什么是注解

annotation是从JDK5.0开始引入的新技术．

Annotation的作用：
不是程序本身，可以对程序作出解释：（这一点和注释(comment没什么区别）
可以被其他程序(如:编译器等)读取。

Annotation的格式：
注解是以"@注释名"在代码中存在的，还可以添加一些参数值，如@SuppressWarnings(value=“unchecked”).

Annotation在哪里使用？
＞可以附加在package，class，method ,field 等上面，相当于给他们添加了额外的辅助信息，
我们可以通过反射机制编程实现对这些元数据的访问

注解示例

 public class Test0l extends object{
//@override 重写的注解
@override
public String tostring(){
Thread
return super. toString();
}

注解：有检查和约束的作用。

内置注解

overfide：定义在java.lang.Override 中，此注释只适用于修辞方法 表示一—个方法声明打算
重写超类中的另一个方法声明.

@Deprecated ：定义在java.lang.Deprecated中，此注释可以用于修辞方法 ，属性，类，表示不
鼓励程序员使用这样的元素，通常是因为它很危险或者存在更好的选择

@suppressWarnings ：定义在java.lang.SuppressWarnings中,用来抑制编译时的警告信息
与前两个注释有所不同,你需要添加一个参数才能正确使用,这些参数都是已经定义好了的，
我们选择性的使用就好了
@SuppressWarnings("all")
@SuppressWarnings("unchecked)
@SuppressWarnings (value={"unchecked","deprecation"})

元注解

元注解的作用就是负责注解其他注解，Java定义了4个标准的meta-annotation类型 他们被用来提供对其他annotation类型作说明．
这些类型和它们所支持的类在java.lang.annotation包中可以找到(@Target, @Retention@Documented.@inherited）

**
@Target：用于描述注解的使用范围(即：被描述的注解可以用在什么地方)
@Retention：表示需要在什么级别保存该注释信急，用于描述注解的生命周期
(SOURCE < CLASS < RUNTIME)**
@Document：说明该注解将被包含在javadoc中
@lnherited：说明子类可以继承父类中的该注解

如何自定义注解

用 @intertace自定义注解时，自动继承了jiava.lang.annotatlon.Annotation接口

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

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

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

返回值类型就是参数的类型（返回值只能是基本类型,Class , String,enum).

可以通过defaut来声明参数的默认值
如果只有一个参数成员，一般参数名为value

注解元素必须要有值，我们定义注解元素时，经常使用空字符串,0作为默认值．

//自定义注解
public class Test03
1/注解可以显示赋值
如果没有點认值，
我们就必须给注解赋值

@MyAnnotation2 (age= 18,name = "秦疆"）
public void test0（）{}
aMvAnnotation3(秦疆)
public void test2(){
}
)

@Target({ElementType.TYPE, ElementType.METHOD})
(Retention (RetentionPolicy.RUNTIME)
@interface MyAnnotation2{
//注解的参数：参数类型＋参数名;
String name() default
int age0);
int id() defaul-1// 如果默认值为-1，代表不存在

String[] schools（） default {“西部开源”,”清华大学”}：
 @Target ({elementType.TYPE, ElementType.METHOD})
-Retention (RetentionPolicv. RUNTIME)
@interface MyAnnotation3{
String value 

反射

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

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

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

Class c =
Class.forName(“java.lang.String”)

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

获得反射对象

Java反射机制提供的功能
＞在运行时判断任意一个对象所属的类
＞在运行时构造任意一个类的对象
＞在运行时判断任意一个类所具有的成员变量和方法
＞在运行时获取泛型信息
＞在运行时调用任意一个对象的成员变量和方法
＞ 在运行时处理注解

通过反射获取类的class对象

Class c1 = Class. forName ("com.kuang.reflection.User") ;
System.out.println(cl);
Class
c2
= Class. forName ("com.kuang.reflection.User") ;
class
= class. forName ("com.kuang.reflection.user");
class
©4
class. forName ("com.kuang.reflection.User") ;
//一个类在内存中只有一个Class对象
//一个类被加我后，类的整个结构都会封装在Class对象中
system.out.println(c2.hashcode())；
system.out.println(c3.hashCode())；
System.out.println(c4.hashcode());

类加载内存分析

类的加载过程

1.类的加载
2. 类的链接
3. 类的初始化

加载

将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表一个这个类的java.lang.Class对象。

链接

将Java类的二进制代码合升到JVM的运行状态之中的过程。
1、验证:确保加载的类信息符合JVM规范，没有安全方面的问题。
2、准备：正式为类变量 (static）分配内存并设置类变量默认初始值的阶段，这些成内存都将在方法区中进行分配。
3、解析：虚拟机常量池内的符号引用 （常量名）替换为直接引用（地址）的过程。

初始化

1、执行类构造器0方法的过程。类构造器0方法是由编译期自动收集类中所有类变量的赋值动作和静态
代码块中的语句合并产生的。（类构造器是构造类信息的，不是构造该类对象的构造器）
2、当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化。
3、虚拟机会保证一个类的0方法在多线程环境中被正确加锁和同步，

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

类的主动引用
当虚拟机启动，先初始化main方法所在的类
new一个类的对象
调用类的静态成员(除了final常量）和静态方法
使用java.lang.reflect包的方法对类进行反射调用。
当初始化一个类，如果其父类没有被初始化，则先会初始化它的父类

类的被动引用 （不会发生类的初始化）
当访问一个静态域时，只有真正声明这个域的类才会被初始化。如：当通过子类引用父类的静态变量，不会导
致子类初始化
通过数组定义类引用，不会触发此类的初始化
引用常量不会触发此类的初始化（常量在链接阶段就存入调用类的常量池中了）

public static void main(String[] args) throws ClassNotFoundException {
//1、主动引用 Son son = new Son();
//反射也会主动引用
//class. forName (“com.kuang.reflection.son”);
  }
 }
class  Father{
static int b = 2;
static {
system.out.println(n父类被加载"）；
 }
}

class son extends Father{
static {
System .out .println(n子类被加载"）；
m = 300;
static
int m =100;
static final int M = 1;
}

获取类的运行时结构

1/获得类的方法
System.out.println(“=============“);
Method[] methods
cl.getMethods();//获得本类及其父类的全部pubtic方法
for (Method method : methods) {
System.out.println("正常的：”+method）；
}

methods=cl.getDeclaredMethods():
//获得本类的所有方法
for (Method method : methods) {
System.out.println("getDeclaredMethods:"+method);
}
//获得指定方法
//重截
Method getName
c1.getMethod ( name: "getName"
Method setName
cl.getMethod( name: "setName",
System.out.println(getName);
System.out.println(setName);
..parameterTypes: null) ;
...parameterTypes: String. class) ;
1/获得指定所构造器
system.out.println("====================“);
Constructor[] constructors
cl.getConstructors();
for (Constructor constructors=c1.constructors();	
{
System.out.println(constructor);
}
constructors=c1.getDeclaredConstructors();
for (Constructor constructor : constructors) {
system.out.println("#”+constructor);
}.

有了Class对象能做什么？

创建类的对象：调用Class对象的newlnstance0方法
1）类必须有一个无参数的构造器。
2）类的构造器的访问权限需要足够

无参的构造器就如何创建对象

只要在操作的时候明确的调用类中的构造器，
并将参数传递进去之后，才可以实例化操作。
步骤：
1）通过Class类的getDeclaredConstructor(Class. parameterTypes)取得本类的指定形参类型的构
造器
2）向构造器的形参中传递一个对象数组进去，里面包含了构造器中所需的各个参数。
3）通过Constructor实例化对象

性能比较分析

public class Test10 {
//普通方式调用
public void test01	(){
User user= new User（）；
long startTime = System.currentTimeMillis();
for (int i = 0;i< 1000000000; i++) 
{
user.getName () ;
}

long endTime = System.currentTimeMillis（）;
System .out.println("普通方式执行10亿次："+ (endTime-startTime ) +"'ms");
}
//反射方式调用
//反射方式调用 关闭检测

//反射方式调用
public static void test02()
User user = new User () ;
long startTime = System. currentTimeMillis();
for (int i = 0; i< 1000000000: i++)
{
user .getName();
}
long endTime = System.currentTimeMillis() ;
System.out.printin("反射方式执行10亿次："+ (endTime-startTime ) +"'ms");
}