Java注解

import java.util.Arrays;
import java.util.Comparator;
import java.util.Date;

/*
 * 1、注解：
 * 	 也是一种注释。它是代码级别的注释。是用代码注释代码。
 *  不同于我们之前的单行注释//，多行注释/*  * /
 *  
 * 当你在代码中，看到@开头就是注解了。
 * 
 * 2、一个完整的注解，由三部分组成：
 * （1）声明
 * （2）使用
 * （3）读取
 * 
 * 绝大多数程序员，面对的基本上是（2）使用。
 * 
 * 3、系统中预定义的三个最基本的注解
 * （1）@Override
 * 作用：检查这个方法是否符合重写的要求
 * ①方法名：相同
 * ②形参列表：相同
 * ③返回值类型
 * 	  基本数据类型和void：相同
 * 	 引用数据类型：<=
 * ④修饰符
 * 	权限修饰符：>=
 * 	其他修饰符：private,static,final不能重写
 * 
 * （2）@SuppressWarnings(xx)
 * 作用：抑制警告
 * 
 * （3）@Deprecated
 * 作用：标记某个方法、类、属性等已过时
 * 不建议程序员继续使用，因为可能有问题，也可能是不好用。
 * 
 * 面向对象的开发原则：对修改关闭，对扩展开发
 */
public class TestAnnotation {
//	@SuppressWarnings({ "unchecked", "rawtypes" })
	@SuppressWarnings("all")
	public static void main(String[] args) {
		String[] all = {"hello","Hai","Java","chai"};
		Arrays.sort(all, new Comparator(){

			@Override
			public int compare(Object o1, Object o2) {
				String s1 = (String) o1;
				String s2 = (String) o2;
				return s1.compareToIgnoreCase(s2);
			}
			
		});
		
/*		Arrays.sort(all, new Comparator<String>(){

			@Override
			public int compare(String o1, String o2) {
				return o1.compareToIgnoreCase(o2);
			}
			
		});*/
		
	/*	for (int i = 0; i < all.length; i++) {
			System.out.println(all[i]);
		}*/
		
		Date date = new Date(2019,6,1);
		System.out.println(date);
	}
}
class Father{
	public void print1n(){
		System.out.println("父类的方法");
	}
}
class Son extends Father{
/*	@Override
	public void println(){
		System.out.println("子类的方法");
	}*/
}

import java.io.FileInputStream;
import java.io.FileNotFoundException;

/*
 * 文档注释相关的注解：
 *   文档注释是Java特有的一种注释。
 *   @author：作者
 *   @see：另请参阅
 *   @since：从xx版本引入的
 *   
 *   @param：形参
 *   	格式：@param 形参名  形参数据类型  解释
 *   	要求：如果方法有几个形参，就写几个@param
 *   @return：返回值
 *   	格式：@return 返回值类型  解释
 *   	要求：如果方法的返回值类型是void，就不用写了
 *   @throws：抛出的异常  或  @execetion
 *   	格式：@throws 异常类型名  解释
 *   	要求：方法声明可能抛出几种异常，就写几个，没有就不写
 *   
 *   建议大家：
 *   	注释与代码要一致，如果不一致，会误导别人或自己
 */

/**
 * 
 * @author Irene
 *
 */
public class TestAnnotation2 {
	
	/**
	 * 这是Java的主方法，是Java程序的入口
	 * @param args String[] 命令行参数，使用java命令时，在后面传入参数，例如
	 * 	java 类名   参数1  参数2 ....
	 */
	public static void main(String[] args) {
		
	}
	
	/**
	 * 这是一个求两个整数中最大值的方法
	 * @param a int 其中一个整数
	 * @param b int 另一个整数
	 * @return int 返回最大值
	 */
	public static int getMax(int a, int b){
		return a>b?a:b;
	}
	
	/**
	 * 这是复制一个文件的方法
	 * @param src String 源文件
	 * @param dest  String 目标文件
	 * @throws FileNotFoundException 当源文件找不到时会抛出该异常
	 */
	public static void copyFile(String src, String dest) throws FileNotFoundException{
		FileInputStream fis = new FileInputStream(src);
		//..
	}
	
	/**
	 * 
	 */
	public void println(){
		
	}
}

Junit注解 

import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;

/*
 * JUnit4：
 * 
 * @Test:
 * 	 用它标记的方法，就可以作为一个独立单元进行测试
 * 	如果某个类中，有多个@Test标记的方法，那么如果没有选择运行哪一个，就都会运行，如果选择了，就运行其中一个
 * 
 * @Before：在xx之前
 * 		会在每一个@Test方法之前
 * @After：在xx之后
 * 		会在每一个@Test方法之后
 * 
 * 要求：
 * (1)单元测试的方法都必须是public
 * (2)必须是无参的()
 * (3)必须是void
 * 
 * @BeforeClass：
 * 		会在类初始化阶段完成
 * @AfterClass
 * 		会在类卸载阶段完成
 * 每个类只执行一次
 * @BeforeClass和@AfterClass而且要求方法是静态的
 */
public class TestJUnit {
	
/*	@Test
	void method(){
		System.out.println("非public的方法");
	}*/
	
/*	@Test
	public void method(String str){
		System.out.println("有参的method");
	}*/
	
	public void method(String str){
		System.out.println("有参的method" + str);
	}
	
	@Test
	public void testMethod(){
		method("hello");
	}
	
/*	@Test
	public String getStr(){
		return "hello";
	}*/
	
	@Test
	public void test1(){
		System.out.println("hello junit1");
	}
	
	@Test
	public void test2(){
		System.out.println("hello junit2");
	}
	
	@Before
	public void init(){
		System.out.println("开始....");
	}
	
	@After
	public void close(){
		System.out.println("结束....");
	}
	
	@BeforeClass
	public static void clinit(){
		System.out.println("最开始....");
	}
	
	@AfterClass
	public static void destroy(){
		System.out.println("最后....");
	}
}

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

/*
 * Java中把注解是看成接口。
 * Java中把枚举看成类。
 * 
 * 注解的三个完整步骤：
 * （1）声明
 * （2）使用
 * （3）读取
 * 
 * 一、注解的声明
 * 语法格式：
 * 	【修饰符】 @interface 注解名{
 * 	}
 * 
 * 二、元注解
 * 元注解：注解注解的注解，或者换句话说，加在注解上面的注解，叫做元注解
 * 1、@Target
 * 标记这个注解可以用于什么位置。
 * 它由ElementType枚举的常量对象来决定：
 * 	 例如：TYPE,FIELD,CONSTRUCTOR等10个位置
 * 
 * 2、@Retention
 * 标记这个注解可以滞留到什么阶段
 * 它由RetentionPolicy的3个常量对象来指定：
 * 		SOURCE, CLASS, RUNTIME
 * SOURCE：源代码阶段.java		只能被编译器读取
 * CLASS：字节码阶段.class
 * RUNTIME：运行时JVM
 * 
 * 3、@Documented
 * 标记某个注解是否可以被javadoc.exe读取到API
 * 
 * 4、@Inherited
 * 标记这个注解是否可以被子类继承
 */
public class TestDefineAnnotation {
	public static void main(String[] args) {
		//以下这段代码是用到了反射的内容，今天暂时不用看懂，知道是读取
		Class clazz = MyClass.class;
		MyAnnotation my = (MyAnnotation) clazz.getAnnotation(MyAnnotation.class);
		System.out.println(my);
	}
}
//使用注解
@MyAnnotation
class MyClass{
	
}

class Sub extends MyClass{
	
}

//自定义注解
//@Target(ElementType.METHOD)//这个表示只能用在方法上
@Target({ElementType.METHOD,ElementType.TYPE})//这个表示可以用在方法和类型上面
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@interface MyAnnotation{
	
}

静态导入:

import static java.lang.annotation.ElementType.*;
import java.lang.annotation.Target;

import static java.lang.Math.*;

/*
 * JDK1.5：
 * （1）枚举
 * （2）注解
 * （3）静态导入
 * ...
 * 
 * 静态导入：JDK1.5
 * 语法格式：
 * 	 import static 包.类名.静态成员;
 * 	 import static 包.类名.*;
 */
public class TestStaticImport {
	public static void main(String[] args) {
/*		System.out.println(Math.PI);
		System.out.println(Math.sqrt(4));*/
		
		System.out.println(PI);
		System.out.println(sqrt(4));
	}
}

@Target({TYPE,METHOD,FIELD})
@interface MyAnnotation{
	
}

自定义注解

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

/*
 * 一个注解有三部分组成：
 * （1）声明
 * （2）使用
 * （3）读取
 * 
 * 一、声明注解
 * 1、形式一
 * @元注解
 * 【修饰符】 @interface 注解名{
 * }
 * 
 * 2、形式二
 * @元注解
 * 【修饰符】 @interface 注解名{
 * 		配置参数列表;
 * }
 * 说明：
 * （1）如果声明注解时，有配置参数，那么在使用注解的时候，需要给这个配置参数赋值
 * 例如：
 * @SuppressWarings("all")
 * @Target(ElementType.TYPE)
 * 
 * （2）如果注解的配置参数只有一个，并且名字是value，那么在使用赋值时，可以省略"value="，
 * 其他的配置参数名称不可以省略
 * 
 * 建议：大家在声明配置参数时，首先考虑使用value
 * 
 * （3）这个配置参数的类型有要求：
 * ①8种基本数据类型
 * ②String
 * ③枚举
 * ④Class类型
 * ⑤Annotation类型
 * ⑥以上这些类型的数组
 * 
 * （4）配置参数可以有默认值
 * @元注解
 * 【修饰符】 @interface 注解名{
 * 		数据类型  参数名()  default 默认值;
 * }
 * 如果这个配置参数有默认值，那么在使用时可以不用赋值，也可以重新赋值
 * 
 * 回忆：default
 * ①switch
 * ②接口的默认方法
 * ③自定义注解的配置参数的默认值
 * 
 */
public class TestAnnotation {
	public static void main(String[] args) {
		//3、读取，我们到反射时再说
	}
}

//1、声明注解
@Target(ElementType.TYPE)//表示MyAnnotation这个注解只能用在类、接口等上面
@Retention(RetentionPolicy.RUNTIME)//表示MyAnnotation这个注解可以滞留到运行时，可以被反射读取到
@interface MyAnnotation{
	
}

//2、使用注解
@MyAnnotation
class MyClass{
	
}

//1、声明另一个注解
@Target(ElementType.TYPE)//表示YourAnnotation这个注解只能用在类、接口等上面
@Retention(RetentionPolicy.RUNTIME)//表示YourAnnotation这个注解可以滞留到运行时，可以被反射读取到
@interface YourAnnotation{
	String value() default "尚硅谷";
}

//2、使用这个注解
@YourAnnotation//这个atguigu的值是要读取注解的程序使用的
class YourClass{
	
}