Java 基础知识点 笔记总结 (八)
文章目录
- 1. 枚举类 介绍
- 2. JDK5.0之前 自定义枚举类
- 3. JDK5.0之后 使用enum关键字 定义枚举类
- 4. enum类中的常用方法
- 5. 使用enum关键字定义的枚举类 实现接口的情况
- 6. 注解(Annotation)
- 7. 注解 起源 功能
- 8. 三个JDK内置基本注解
-
- 8.1 @Override注解
- 8.2 @Deprecated注解
- 8.3 @SuppressWarning注解
- 9. 自定义注解
- 10. JDK中的元注解
-
- 10.1 什么是元注解？
- 10.2 @Retention 元注解
- 10.3 @Target 元注解
- 10.4 @Documented 元注解
- 10.5 @Inherited 元注解
- 11. JDK8 新特性 可重复注解
-
- 11.1 JDK 1.8 版本之前
- 11.2 JDK 1.8 版本之后
- 12. 类型注解
1. 枚举类 介绍
枚举类创建方式：
方式一：JDK1.5之前需要自定义枚举类。
方式二：JDK1.5新增的enum关键字用于定义枚举类。
什么情况下，用枚举类？
2. JDK5.0之前 自定义枚举类
其实和单例模式设计原理一样：
package com.holmes.java06;
public class SeasonTest {
public static void main(String[] args) {
Season spring = Season.SPRING;
System.out.println(spring.toString());
}
}
//方式一：自定义枚举类
class Season{
//1.声明Season对象的属性:因为自己定义的常量，因此必须唯一要用private final修改。
private final String seasonName;
private final String seasonDesc;
//2.私有化类的构造器,并给对象属性赋值
private Season(String seasonName,String seasonDesc){
this.seasonName = seasonName;
this.seasonDesc = seasonDesc;
}
//3.提供当前枚举类的多个对象(就像单例模式，本类不能声明对象，但可以调用方法生成对象):public static final类型！
public static final Season SPRING = new Season("春天","春暖花开");
public static final Season SUMMER = new Season("夏天","夏日炎炎");
public static final Season AUTUMN = new Season("秋天","秋高气爽");
public static final Season WINTER = new Season("冬天","冰天雪地");
//4.其他诉求1：获取枚举类对象的属性
public String getSeasonName() {
return seasonName;
}
public String getSeasonDesc() {
return seasonDesc;
}
//4.其他诉求2：重写toString()方法
@Override
public String toString() {
return "Season{" +
"seasonName='" + seasonName + '\'' +
", seasonDesc='" + seasonDesc + '\'' +
'}';
}
}
3. JDK5.0之后 使用enum关键字 定义枚举类
- 定义的枚举类默认继承于java.lang.Enum类。
package com.holmes.java06;
public class SeasonTest {
public static void main(String[] args) {
Season summer = Season.SUMMER;
//我们在没有重写toString()方法时，这里默认调用toString()方法，但返回的结果值不是当前地址，说明这个toString()方法被重写过！
System.out.println(summer);//SUMMER
//我们查看Season类的父类
System.out.println(Season.class.getSuperclass());//class java.lang.Enum
//原因就是因为他继承了enum类，而不是Object，如果时Object返回的就是地址。
}
}
//方式二：使用enum关键字枚举类
enum Season{
//1.提供当前枚举类的对象，多个对象之间用","隔开，末尾对象用";"结束。
SPRING("春天","春暖花开"),
SUMMER("夏天","夏日炎炎"),
AUTUMN("秋天","秋高气爽"),
WINTER("冬天","冰天雪地");
//2.声明Season对象的属性:因为自己定义的常量，因此必须唯一要用private final修改。
private final String seasonName;
private final String seasonDesc;
//3.私有化类的构造器,并给对象属性赋值
private Season(String seasonName,String seasonDesc){
this.seasonName = seasonName;
this.seasonDesc = seasonDesc;
}
//4.其他诉求1：获取枚举类对象的属性
public String getSeasonName() {
return seasonName;
}
public String getSeasonDesc() {
return seasonDesc;
}
}
4. enum类中的常用方法
package com.holmes.java06;
public class SeasonTest {
public static void main(String[] args) {
Season summer = Season.SUMMER;
//1.toString()方法：
System.out.println(summer.toString());
System.out.println("***************");
//2.values()方法：
Season[] values = Season.values();
for (int i=0; i < values.length;i++){
System.out.println(values[i]);
}
System.out.println("********");
//同样在之前的Thread.State状态也是enum定义的：
Thread.State[] values1 = Thread.State.values();
for (int i=0; i < values1.length;i++){
System.out.println(values1[i]);
}
System.out.println("***************");
//3.valueOf(String objName)方法:返回枚举类中对象名是objName的对象
Season winter = Season.valueOf("WINTER");
System.out.println(winter);//默认调用toString()方法，还是返回对象名。
//如果没找到，就会报错IllegalArgumentException。
}
}
//方式二：使用enum关键字枚举类
enum Season{
//1.提供当前枚举类的对象，多个对象之间用","隔开，末尾对象用";"结束。
SPRING("春天","春暖花开"),
SUMMER("夏天","夏日炎炎"),
AUTUMN("秋天","秋高气爽"),
WINTER("冬天","冰天雪地");
//2.声明Season对象的属性:因为自己定义的常量，因此必须唯一要用private final修改。
private final String seasonName;
private final String seasonDesc;
//3.私有化类的构造器,并给对象属性赋值
private Season(String seasonName,String seasonDesc){
this.seasonName = seasonName;
this.seasonDesc = seasonDesc;
}
//4.其他诉求1：获取枚举类对象的属性
public String getSeasonName() {
return seasonName;
}
public String getSeasonDesc() {
return seasonDesc;
}
}
5. 使用enum关键字定义的枚举类 实现接口的情况
- 情况一：实现接口，enum枚举类实现接口并实现其抽象方法。
- 情况二：每个对象可以给自己单独设置重写方法，如下：
package com.holmes.java06;
public class SeasonTest {
public static void main(String[] args) {
Season summer = Season.SUMMER;
//调用自己单独重写的方法
summer.show();
Season winter = Season.WINTER;
//自己没有定义那就调用共用的重写的方法
winter.show();
}
}
interface Info{
void show();
}
//方式二：使用enum关键字枚举类
enum Season implements Info{
SPRING("春天","春暖花开"){
@Override
public void show() {
System.out.println("这是一个春天");
}
},
SUMMER("夏天","夏日炎炎"){
@Override
public void show() {
System.out.println("这是一个夏天");
}
},
AUTUMN("秋天","秋高气爽"){
@Override
public void show() {
System.out.println("这是一个春天秋天");
}
},
WINTER("冬天","冰天雪地");
private final String seasonName;
private final String seasonDesc;
private Season(String seasonName,String seasonDesc){
this.seasonName = seasonName;
this.seasonDesc = seasonDesc;
}
public String getSeasonName() {
return seasonName;
}
public String getSeasonDesc() {
return seasonDesc;
}
@Override
public void show() {
//在这的方法代表所有对象默认调用该方法，每个对象也可以自己重写自己的方法。
System.out.println("春夏秋冬");
}
}
6. 注解(Annotation)
像@Test，@Override等都是注解，在代码里注解就是特殊标记。
生成文档相关的注解：
JDK内置的三个基本注解：
注解功能之一：可以实现替代配置文件功能：
@BeforeClass，@AfterClass等等以下注解很常用！！要记住！
7. 注解 起源 功能
- 注解是从JDK5.0开始的，Java增加了对元数据(MetaData)的支持，也就是Annotation(注解)。
- 他到后面最主要的功能就是代替旧版中所遗留的繁冗代码和XML配置等操作。
8. 三个JDK内置基本注解
8.1 @Override注解
@Override注解：重写标志，如果报错或者没有变颜色说明代码有问题！
8.2 @Deprecated注解
@Deprecated注解：代表已经过时了，但是还可以用！deprecated英文意思是贬低，强烈反对的意思。
通常是因为所修饰的结构危险或存在更好的选择。
8.3 @SuppressWarning注解
@SuppressWarning抑制编译器警告注解，这个很有意思，它就是用来抑制编译器警告的，说的通俗一点就是用来去除警告的。
@SuppressWarning(“xxx”,“xxx”)它可以携带很多参数，每个参数都有不同作用，例如："unuse"代表未使用，"rawtypes"代表传参时也要传递带泛型的参数等等。
在eclipse中，我们没有用到的变量属性什么的，它会报黄色线条的警告。
在IDEA中，他没有黄色警告，但是它是淡黑的，告诉你没有用到该变量。
同样，我们添加抑制编译器注解后，他就变成正常颜色了。
9. 自定义注解
创建时，要选择Annotation注解类型：
注解的声明就是@interface：
注意：注解和interface接口没有任何关系，@interface就是这么个结构。
自定义注解自动继承了java.lang.annotation.Annotation接口。
内部定义成员，通常使用value表示:
参数名 = “参数值” 形式：
可以指定成员的默认值，使用default定义：
如果自定义注解没有成员，表明是一个标识作用。
就像标识接口差不多，都是标识作用：
当然，相反如果注解有成员，在使用注解时，需要指定成员的值。
自定义注解必须配上注解的信息处理流程(使用反射)才有意义。
10. JDK中的元注解
10.1 什么是元注解？
- JDK的元Annotation(注解)用于修饰其他Annotation(注解)定义的。
简而言之，就是修饰其他注解的注解叫元注解。
同样还有一个叫做元数据：
- JDK提供的4中元注解：
10.2 @Retention 元注解
@Retention元注解:指定所修饰的Annotation的生命周期：SOURCE、CLASS(默认)、RUNTIME(只有声明为RUNTIME生命周期的注解，才能通过反射获取。)
source：注解只保留在源文件，当Java文件编译成class文件的时候，注解被遗弃；被编译器忽略
class：注解被保留到class文件，但jvm加载class文件时候被遗弃，这是默认的生命周期
runtime：注解不仅被保存到class文件中，jvm加载class文件之后，仍然存在
RetentionPolicy的默认值是CLASS，编译时有，运行时不加载。
其中，RetentionPolicy就是一个枚举类，包含三种状态：
我们常用的SuppressWarnings就是使用的Retention注解：
10.3 @Target 元注解
@Target元注解:用于指明我们所修饰的注解，它能修饰哪些程序元素。
package com.holmes.java06;
import java.lang.annotation.Target;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.ElementType.LOCAL_VARIABLE;
@Target({
TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
//上面参数代表不同可以修饰不同的类型效果：
//type:类，接口，枚举类；field：属性；method：方法；parameter：形参；constructor：构造器；local_variable:局部变量
public @interface MyAnnotation {
String value() default "hello";
}
10.4 @Documented 元注解
@Documented元注解：表示所修饰得注解在被javadoc解析(生成文档)时，保留下来。
10.5 @Inherited 元注解
@Inherited元注解：被它修饰的注解，将具有继承性，其子类就会继承父类的注解。
如果想要打印注解信息到一个数组中可以像下面这么做：
11. JDK8 新特性 可重复注解
11.1 JDK 1.8 版本之前
Annotation注解数组方式重复注解(过时，JDK 8之前的写法)：
package com.holmes.java06;
public @interface MyAnnotations {
//首先，定义一个注解数组，在这里面。
MyAnnotation[] value();
}
11.2 JDK 1.8 版本之后
我们使用@Repeatable注解来解决：
MyAnnotations注解内容：
package com.holmes.java06;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.ElementType.LOCAL_VARIABLE;
@Retention(RetentionPolicy.RUNTIME)
@Target({
TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
public @interface MyAnnotations {
//首先，定义一个注解数组，在这里面。
MyAnnotation[] value();
}
MyAnnotation注解内容：
package com.holmes.java06;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.ElementType.LOCAL_VARIABLE;
@Inherited
@Repeatable(MyAnnotations.class)
@Retention(RetentionPolicy.RUNTIME)
@Target({
TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
//上面参数代表不同可以修饰不同的类型效果：
//type:类，接口，枚举类；field：属性；method：方法；parameter：形参；constructor：构造器；local_variable:局部变量
public @interface MyAnnotation {
String value() default "hello";
}
具体步骤如下：
- 第一步：在MyAnnotation上声明@Repeatable ， 成员值为MyAnnotations.class。
- 第二步：MyAnnotation的Target 和 Retention 必须 和MyAnnotations相同，Retention不一致会周期不同报错，Target不一致也会报错。
12. 类型注解
案例：
//这里泛型之所以能够用注解，就是因为在MyAnnotation注解的TARGET中设置了Type_PARAMETER
class Generic<@MyAnnotation T>{
//抛出异常，声明集合，强转也都可以给予注解，这就因为MyAnnotation的TARGET中设置了TYPE_USE
public void show() throws @MyAnnotation(value = "abc") RuntimeException{
ArrayList<@MyAnnotation String> list = new ArrayList<>();
int num = (@MyAnnotation int)10L;
}
}
package com.holmes.java06;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.ElementType.LOCAL_VARIABLE;
@Inherited
@Repeatable(MyAnnotations.class)
@Retention(RetentionPolicy.RUNTIME)
//设置了TYPE_PARAMETER,TYPE_USE。
@Target({
TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE,TYPE_PARAMETER,TYPE_USE})
//上面参数代表不同可以修饰不同的类型效果：
//type:类，接口，枚举类；field：属性；method：方法；parameter：形参；constructor：构造器；local_variable:局部变量
public @interface MyAnnotation {
String value() default "hello";
}