学习注解s

注解

注释：给人看，用于提醒程序员
注解：给程序看的，它拥有一定的功能
注解是JDK1.5之后才有
注解的格式：@关键词
注解的位置：类上、方法上、属性上

注解的分类

1、编译检查

如果写法错误，则编译报错

1 @Override : 表明该方法重写的父类的方法
2 @Deprecated ： 标记过时
3 @SuppressWarnings("serial") ：  抑制警告

2、文档

通过注解生成文档

/**
 * 
 * @author 老王 
 * @version 1.0
 * 
 *
 */
public  class Father {
	/**
	 * 
	 * @param a  加数1
	 * @param b  加数2
	 * @return   两数之和
	 */
	public int add(int a,int b){
		return a+b;
	};
}

通过CMD命令生成文档API
	javadoc xx.java
	javadoc *.java
步骤：
	1 创建文件夹，把需要生成文档的java文件放进该文件夹中
	2 通过cmd切换到当前文件夹，最后通过javadoc命令生成文档

3、自定义

//语法:新建自定义注解
public @interface 注解名{

	方法列表;
}
注解的底层是一个接口,它继承了Annotation接口
通过反编译证明：
1  javac xx.java
2  javap xx.class
public interface MyAnno extends java.lang.annotation.Annotation {
}

注解的属性

1 这里的属性实际上指的是接口中的方法的声明
2 方法必须有返回值
3 返回值类型也是有规定的：
	3.1  8大基本数据类型
	3.2  String
	3.3  枚举
	3.4  注解
	3.5  返回以上类型的数组形式

使用自定义注解

语法：在类上、方法上、属性上都能使用

如果该注解没有任何属性:@注解名
如果该注解有任何属性: @注解名(属性1=值1,属性2=值2.....)

public @interface  MyAnno {
	public  int  x1(); // 八大基本类型
	public  String  x2();//String类型
	public  Stu  x3();//枚举类型
	public  MyAnno2  x4();//注解类型
	public  int[]  x5();//以上类型的数组类型
}
//使用:
@MyAnno(x1=3,x2="abc",x3=Stu.jack,x4=@MyAnno2,x5={1,2,3})
public class User {}

我们可以把定义在注解中的属性当作形参
而使用注解时传递的值当作实参

关于属性的特殊案例

1 如果数组中的元素只有一个，则可以省去{}
2 我们可以给属性设置默认值，设置默认值后，在使用注解是可以不用管该属性
3 如果属性名是value，并且该注解只有这一个属性或者该注解的其他属性都有默认值，则在使用注解时可以省去value

//定义
public @interface  MyAnno {
	public  String[]  value();
}
//使用：
@MyAnno(value={"abc"})
public class User {}
//简写：
@MyAnno("abc")
public class User {}

元注解

用于约束注解的注解
位置：放在注解的上方
元注解是固定的：
	1、@Target：约束注解的使用位置(类、方法、属性)

@Target({ElementType.TYPE,ElementType.FIELD,ElementType.METHOD})
	public @interface  MyAnno {｝

如果不写，默认是三个都能够放
	2、@Retention  ：注解被保留的阶段(字节码、类、对象)
推荐被保留到对象阶段

@Retention(RetentionPolicy.RUNTIME)
		public @interface  MyAnno {
	//默认是RetentionPolicy.class

3、@Documented :该注解能够被抽取到api文档中去 (了解)
4、@Inherited  :该注解能够被子类继承 (了解)

		@Inherited
		public @interface  MyAnno {
		@MyAnno
		public class Father{}
		public class Son extends Father{}
	//则son也拥有该注解

注解版配置

@MyDog(className="com.woniuxy.demo2.Dog",methodName="eat")
public class Test {		
		//获得该类的反射对象
		Class clazz= Test.class;
		//获得该类上的MyDog注解对象
		MyDog myDog =(MyDog)clazz.getDeclaredAnnotation(MyDog.class);
//		底层
//		
//		public class MyDogImpl implements MyDog{
//			@Override
//			public String className() {
//				return "com.woniuxy.demo2.Dog";
//			}
//			@Override
//			public String methodName() {
//				return "eat";
//			}
//		}
		//MyDog myDog=new MyDogImpl();
		//获取对象中的属性值
		String className = myDog.className();
		String methodName =myDog.methodName();
		//获取类的反射对象
		Class clazz2=Class.forName(className);
		//获取clazz2类的方法
		Method m= clazz2.getDeclaredMethod(methodName);
		//执行方法
		m.invoke(clazz2.newInstance());
	}
}

案例：通过自定义注解来测试某个类的N个方法是否有bug,把bug输出到文本中

被测试类：

package com.woniuxy.demo3;

import java.util.Scanner;

public class MyMath {
	
	public void haha(){
		System.out.println("haha");
	}
	
	@MyCheck
	public void add(){
		int a=1,b=2;
		System.out.println(a+b);
	}
	@MyCheck
	public void jian(){
		int a=1,b=2;
		System.out.println(a-b);
	}
	@MyCheck
	public void chu(){
		int a=1,b=0;
		System.out.println(a/b);
	}
	@MyCheck
	public void xx(){
		Scanner sca=null;
		String next = sca.next();
		System.out.println(next);
	}
	@MyCheck
	public void xx1(){
		int [] arr={1,2,3};
		arr[3]=4;
		System.out.println(arr);
	}
}

注解类

package com.woniuxy.demo3;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyCheck {
	
}

解析注解的主函数

package com.woniuxy.demo3;

import java.io.File;
import java.io.FileWriter;
import java.lang.reflect.Method;

public class Test {
	public static void main(String[] args)throws Exception {
		//获得MyMath的反射对象
		MyMath math=new MyMath();
		Class clazz = math.getClass();
		//获得所有方法
		Method[] methods = clazz.getDeclaredMethods();
		//遍历
		FileWriter fw=new FileWriter(new File("log.txt"));
		for(Method m:methods){
			//判断当前方法是否拥有该注解		if(m.isAnnotationPresent(MyCheck.class)){
				try {
					m.invoke(math);
				} catch (Exception e) {
					String msg="方法名:"+m.getName()+":异常信息："+e.getCause().getMessage()+"\n";
					fw.write(msg);
				}
			}
		}
		//关闭流
		fw.close();
	}
}

在以后，我们不会用到自定义注解，而是使用框架技术提供好的注解
注解 搭配 解析注解的程序 才能有效果

复合注解

注解上还能够放注解（不是元注解）

public @interface MyAnno1 {
	public int a();
}

@MyAnno1(a=1)
public @interface MyAnno2 {
	public String b();
	
}

MyAnno2就是复合注解
或者
MyAnno2 继承了 @MyAnno1

补充点

枚举(enum)

概念：一一列举，把所有的情况都列举出来，最终取值只能从中获取（数据已经固定了）

因此，枚举一般用于固定的数据(国家、日期、季节、省份,线路)

1、列表中的每一个字段用逗号分隔，最终用；代表结束

2、枚举就是java的语法糖(结构简单，语法很人性化)

3、枚举类默认是继承了Enum的类，并且该类默认是被final修饰

4、枚举中列举的字段默认前面是隐藏了public static final 

季节[] values = 季节.values();
		for(季节 season:values){
			System.out.println(season);
		}

5、枚举类都提供了一个values方法，能够获取列表
	1、使用字符串

public enum 季节 {
	春,夏,秋,东
}

使用:
遍历字符串

		季节[] values = 季节.values();
		for(季节 season:values){
			System.out.println(season);
		}

2、使用对象:
注意：列表必须放在第一个位置，并且以分号结尾

public enum 季节 {
	春("春天","春暖花开"),
	夏("夏天","很热"),
	秋("秋天","秋高气爽"),
	冬("东天","很冷");
	String 名字;
	String 描述;
	private 季节(String 名字,String 描述){
		this.名字=名字;
		this.描述=描述;
	}
}

遍历对象

季节[] values = 季节.values();
		for(季节 season:values){
			System.out.println(season.名字+":"+season.描述);
		}