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{
}