文章目錄
全部源碼：https://github.com/name365/JavaSE-30Day
轉載自atguigu.com視頻
第10章枚舉類與註解
枚舉類的使用
枚舉類的理解
-
類的對象只有有限個，確定的。舉例如下：
- 星期：Monday(星期一)、…、Sunday(星期天)
- 性別：Man(男)、Woman(女)
- 季節：Spring(春節)…Winter(冬天)
- 支付方式：Cash（現金）、WeChatPay（微信）、Alipay(支付寶)、BankCard(銀行卡)、CreditCard(信用卡)
- 就職狀態：Busy、Free、Vocation、Dimission
- 訂單狀態：Nonpayment（未付款）、Paid（已付款）、Delivered（已發貨）、Return（退貨）、Checked（已確認）Fulfilled（已配貨）、
- 線程狀態：創建、就緒、運行、阻塞、死亡
-
當需要定義一組常量時，強烈建議使用枚舉類
-
枚舉類的實現
- JDK1.5之前需要自定義枚舉類
- JDK 1.5 新增的enum 關鍵字用於定義枚舉類
-
若枚舉只有一個對象, 則可以作爲一種單例模式的實現方式。
自定義枚舉類
- 枚舉類的屬性
- 枚舉類對象的屬性不應允許被改動, 所以應該使用private final 修飾
- 枚舉類的使用private final 修飾的屬性應該在構造器中爲其賦值
- 若枚舉類顯式的定義了帶參數的構造器, 則在列出枚舉值時也必須對應的傳入參數
/**
* 一、枚舉類的使用
* 1.枚舉類的理解：類的對象只有有限個，確定的。我們稱此類爲枚舉類。
* 2.當需要定義一組常量時，強烈建議使用枚舉類
* 3.若枚舉只有一個對象, 則可以作爲一種單例模式的實現方式。
*
* 二、如何定義枚舉類
* 方式一：JDK1.5之前需要自定義枚舉類
* 方式二：JDK 1.5 新增的enum 關鍵字用於定義枚舉類
*
* @author subei
* @create 2020-05-11 10:06
*/
public class SeasonTest {
public static void main(String[] args) {
Season spring = Season.SPRING;
System.out.println(spring);
}
}
//自定義枚舉類
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 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.其他訴求：獲取枚舉類對象的屬性
public String getSeasonName() {
return seasonName;
}
public String getSeasonDesc() {
return seasonDesc;
}
//4.其他訴求1：提供toString()
@Override
public String toString() {
return "Season{" +
"seasonName='" + seasonName + '\'' +
", seasonDesc='" + seasonDesc + '\'' +
'}';
}
}
使用enum關鍵字定義枚舉類
- 使用說明
- 使用enum定義的枚舉類默認繼承了java.lang.Enum類，因此不能再繼承其他類
- 枚舉類的構造器只能使用private 權限修飾符
- 枚舉類的所有實例必須在枚舉類中顯式列出(, 分隔; 結尾)。列出的實例系統會自動添加public static final 修飾
- 必須在枚舉類的第一行聲明枚舉類對象
- JDK 1.5 中可以在switch 表達式中使用Enum定義的枚舉類的對象作爲表達式, case 子句可以直接使用枚舉值的名字, 無需添加枚舉類作爲限定。
/**
* 使用enum關鍵字定義枚舉類
* 說明：定義的枚舉類默認繼承於java.lang.Enum類
*
* @author subei
* @create 2020-05-11 10:56
*/
public class SeasonTest1 {
public static void main(String[] args) {
Season1 summer = Season1.SUMMER;
//toString():
System.out.println(summer.toString());
System.out.println(Season1.class.getSuperclass());
}
}
//使用enum關鍵字枚舉類
enum Season1{
//1.提供當前枚舉類的對象，多個對象之間用","隔開，末尾對象";"結束
SPRING("春天","萬物復甦"),
SUMMER("夏天","烈日炎炎"),
AUTUMN("秋天","金秋送爽"),
WINTER("冬天","白雪皚皚");
//2.聲明Season對象的屬性:private final修飾
private final String seasonName;
private final String seasonDesc;
//3.私有化類的構造器,並給對象屬性賦值
private Season1(String seasonName,String seasonDesc){
this.seasonName = seasonName;
this.seasonDesc = seasonDesc;
}
//4.其他訴求：獲取枚舉類對象的屬性
public String getSeasonName() {
return seasonName;
}
public String getSeasonDesc() {
return seasonDesc;
}
//4.其他訴求1：提供toString()
// @Override
// public String toString() {
// return "Season{" +
// "seasonName='" + seasonName + '\'' +
// ", seasonDesc='" + seasonDesc + '\'' +
// '}';
// }
}
Enum類中的常用方法
- Enum類的主要方法：
- values()方法：返回枚舉類型的對象數組。該方法可以很方便地遍歷所有的枚舉值。
- valueOf(String str)：可以把一個字符串轉爲對應的枚舉類對象。要求字符串必須是枚舉類對象的“名字”。如不是，會有運行時異常：IllegalArgumentException。
- toString()：返回當前枚舉類對象常量的名稱
/**
* 使用enum關鍵字定義枚舉類
* 說明：定義的枚舉類默認繼承於java.lang.Enum類
*
* 三、Enum類的常用方法
* values()方法：返回枚舉類型的對象數組。該方法可以很方便地遍歷所有的枚舉值。
* valueOf(String str)：可以把一個字符串轉爲對應的枚舉類對象。要求字符串必須是枚舉類對象的“名字”。如不是，會有運行時異常：IllegalArgumentException。
* toString()：返回當前枚舉類對象常量的名稱
*
* @author subei
* @create 2020-05-11 10:56
*/
public class SeasonTest1 {
public static void main(String[] args) {
Season1 summer = Season1.SUMMER;
//toString():
System.out.println(summer.toString());
// System.out.println(Season1.class.getSuperclass());
System.out.println("**************************");
//values():返回所有的枚舉類對象構成的數組
Season1[] values = Season1.values();
for(int i = 0;i < values.length;i++){
System.out.println(values[i]);
}
System.out.println("****************************");
Thread.State[] values1 = Thread.State.values();
for(int i = 0;i < values1.length;i++){
System.out.println(values1[i]);
}
//valueOf(String objName):返回枚舉類中對象名是objName的對象。
Season1 winter = Season1.valueOf("WINTER");
//如果沒有objName的枚舉類對象，則拋異常：IllegalArgumentException
// Season1 winter = Season1.valueOf("WINTER1");
System.out.println(winter);
}
}
//使用enum關鍵字枚舉類
enum Season1{
//1.提供當前枚舉類的對象，多個對象之間用","隔開，末尾對象";"結束
SPRING("春天","萬物復甦"),
SUMMER("夏天","烈日炎炎"),
AUTUMN("秋天","金秋送爽"),
WINTER("冬天","白雪皚皚");
//2.聲明Season對象的屬性:private final修飾
private final String seasonName;
private final String seasonDesc;
//3.私有化類的構造器,並給對象屬性賦值
private Season1(String seasonName,String seasonDesc){
this.seasonName = seasonName;
this.seasonDesc = seasonDesc;
}
//4.其他訴求：獲取枚舉類對象的屬性
public String getSeasonName() {
return seasonName;
}
public String getSeasonDesc() {
return seasonDesc;
}
//4.其他訴求1：提供toString()
// @Override
// public String toString() {
// return "Season{" +
// "seasonName='" + seasonName + '\'' +
// ", seasonDesc='" + seasonDesc + '\'' +
// '}';
// }
}
使用enum關鍵字定義的枚舉類實現接口
/**
* 使用enum關鍵字定義枚舉類
* 說明：定義的枚舉類默認繼承於java.lang.Enum類
*
* 四、使用enum關鍵字定義的枚舉類實現接口的情況
* 情況一：實現接口，在enum類中實現抽象方法
* 情況二：讓枚舉類的對象分別實現接口中的抽象方法
*
* @author subei
* @create 2020-05-11 10:56
*/
public class SeasonTest1 {
public static void main(String[] args) {
//values():返回所有的枚舉類對象構成的數組
Season1[] values = Season1.values();
for(int i = 0;i < values.length;i++){
System.out.println(values[i]);
values[i].show();
}
//valueOf(String objName):返回枚舉類中對象名是objName的對象。
Season1 winter = Season1.valueOf("WINTER");
winter.show();
}
}
interface Info{
void show();
}
//使用enum關鍵字枚舉類
enum Season1 implements Info{
//1.提供當前枚舉類的對象，多個對象之間用","隔開，末尾對象";"結束
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("冬天","冰天雪地"){
@Override
public void show() {
System.out.println("寒冬臘月、滴水成冰");
}
};
//2.聲明Season對象的屬性:private final修飾
private final String seasonName;
private final String seasonDesc;
//3.私有化類的構造器,並給對象屬性賦值
private Season1(String seasonName,String seasonDesc){
this.seasonName = seasonName;
this.seasonDesc = seasonDesc;
}
//4.其他訴求：獲取枚舉類對象的屬性
public String getSeasonName() {
return seasonName;
}
public String getSeasonDesc() {
return seasonDesc;
}
//4.其他訴求1：提供toString()
// @Override
// public String toString() {
// return "Season{" +
// "seasonName='" + seasonName + '\'' +
// ", seasonDesc='" + seasonDesc + '\'' +
// '}';
// }
// @Override
// public void show() {
// System.out.println("這是一個季節。");
// }
}
註解的使用
註解的理解
-
從JDK 5.0 開始, Java 增加了對元數據(MetaData) 的支持, 也就是Annotation(註解)
-
Annotation 其實就是代碼裏的特殊標記, 這些標記可以在編譯, 類加載, 運行時被讀取, 並執行相應的處理。通過使用Annotation, 程序員可以在不改變原有邏輯的情況下, 在源文件中嵌入一些補充信息。代碼分析工具、開發工具和部署工具可以通過這些補充信息進行驗證或者進行部署。
-
Annotation 可以像修飾符一樣被使用, 可用於修飾包,類, 構造器, 方法, 成員變量, 參數, 局部變量的聲明, 這些信息被保存在Annotation 的“name=value” 對中。
-
在JavaSE中，註解的使用目的比較簡單，例如標記過時的功能，忽略警告等。在JavaEE/Android中註解佔據了更重要的角色，例如用來配置應用程序的任何切面，代替JavaEE舊版中所遺留的繁冗代碼和XML配置等。
-
未來的開發模式都是基於註解的，JPA是基於註解的，Spring2.5以上都是基於註解的，Hibernate3.x以後也是基於註解的，現在的Struts2有一部分也是基於註解的了，註解是一種趨勢，一定程度上可以說：框架= 註解+ 反射+ 設計模式。
Annotation的使用示例
-
使用Annotation 時要在其前面增加@ 符號, 並把該Annotation 當成一個修飾符使用。用於修飾它支持的程序元素
-
示例一：生成文檔相關的註解
- @author標明開發該類模塊的作者，多個作者之間使用,分割
- @version標明該類模塊的版本
- @see參考轉向，也就是相關主題
- @since從哪個版本開始增加的
- @param對方法中某參數的說明，如果沒有參數就不能寫
- @return對方法返回值的說明，如果方法的返回值類型是void就不能寫
- @exception對方法可能拋出的異常進行說明，如果方法沒有用throws顯式拋出的異常就不能寫其中
- @param@return和@exception這三個標記都是隻用於方法的。
- @param的格式要求：@param形參名形參類型形參說明
- @return的格式要求：@return返回值類型返回值說明
- @exception的格式要求：@exception異常類型異常說明
- @param和@exception可以並列多個
-
示例二：在編譯時進行格式檢查(JDK內置的三個基本註解)
- @Override: 限定重寫父類方法, 該註解只能用於方法
- @Deprecated: 用於表示所修飾的元素(類, 方法等)已過時。通常是因爲所修飾的結構危險或存在更好的選擇
- @SuppressWarnings: 抑制編譯器警告
-
示例三：跟蹤代碼依賴性，實現替代配置文件功能
- Servlet3.0提供了註解(annotation),使得不再需要在web.xml文件中進行Servlet的部署。
- spring框架中關於“事務”的管理
import java.util.ArrayList;
import java.util.Date;
/**
* 註解的使用
*
* 1. 理解Annotation:
* ① jdk 5.0 新增的功能
*
* ② Annotation 其實就是代碼裏的特殊標記, 這些標記可以在編譯, 類加載, 運行時被讀取, 並執行相應的處理。通過使用 Annotation,
* 程序員可以在不改變原有邏輯的情況下, 在源文件中嵌入一些補充信息。
*
* ③在JavaSE中，註解的使用目的比較簡單，例如標記過時的功能，忽略警告等。在JavaEE/Android
* 中註解佔據了更重要的角色，例如用來配置應用程序的任何切面，代替JavaEE舊版中所遺留的繁冗
* 代碼和XML配置等。
*
* 2. Annocation的使用示例
* 示例一：生成文檔相關的註解
* 示例二：在編譯時進行格式檢查(JDK內置的三個基本註解)
* @Override: 限定重寫父類方法, 該註解只能用於方法
* @Deprecated: 用於表示所修飾的元素(類, 方法等)已過時。通常是因爲所修飾的結構危險或存在更好的選擇
* @SuppressWarnings: 抑制編譯器警告
*
* 示例三：跟蹤代碼依賴性，實現替代配置文件功能
*
* @author subei
* @create 2020-05-11 11:19
*/
public class AnnotationTest {
public static void main(String[] args) {
Person p = new Student();
p.walk();
Date date = new Date(2020, 10, 11);
System.out.println(date);
@SuppressWarnings("unused")
int num = 10;
// System.out.println(num);
@SuppressWarnings({ "unused", "rawtypes" })
ArrayList list = new ArrayList();
}
}
class Person{
private String name;
private int age;
public Person() {
super();
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public void walk(){
System.out.println("學習中……");
}
public void eat(){
System.out.println("摸魚中……");
}
}
interface Info{
void show();
}
class Student extends Person implements Info{
@Override
public void walk() {
System.out.println("噴子走開");
}
@Override
public void show() {
}
}
如何自定義註解
- 定義新的Annotation類型使用**@interface**關鍵字
- 自定義註解自動繼承了java.lang.annotation.Annotation接口
- Annotation的成員變量在Annotation定義中以無參數方法的形式來聲明。其方法名和返回值定義了該成員的名字和類型。我們稱爲配置參數。類型只能是八種基本數據類型、String類型、Class類型、enum類型、Annotation類型、以上所有類型的數組。
- 可以在定義Annotation的成員變量時爲其指定初始值,指定成員變量的初始值可使用default關鍵字
- 如果只有一個參數成員，建議使用參數名爲value
- 如果定義的註解含有配置參數，那麼使用時必須指定參數值，除非它有默認值。格式是“參數名=參數值”，如果只有一個參數成員，且名稱爲value，可以省略“value=”
- 沒有成員定義的Annotation稱爲標記;包含成員變量的Annotation稱爲元數據Annotation
- 注意：自定義註解必須配上註解的信息處理流程纔有意義。
/**
* @author subei
* @create 2020-05-11 11:47
*/
public @interface MyAnnotation {
String value();
}
/**
* 註解的使用
*
* 3.如何自定義註解：參照@SuppressWarnings定義
* ① 註解聲明爲：@interface
* ② 內部定義成員，通常使用value表示
* ③ 可以指定成員的默認值，使用default定義
* ④ 如果自定義註解沒有成員，表明是一個標識作用。
*
* 如果註解有成員，在使用註解時，需要指明成員的值。
* 自定義註解必須配上註解的信息處理流程(使用反射)纔有意義。
* 自定義註解通過都會指明兩個元註解：Retention、Target
*
* @author subei
* @create 2020-05-11 11:19
*/
@MyAnnotation(value = "hello")
jdk中4個基本的元註解的使用1
-
JDK 的元Annotation 用於修飾其他Annotation 定義
-
JDK5.0提供了4個標準的meta-annotation類型，分別是：
- Retention
- Target
- Documented
- Inherited
元數據的理解：String name = “MyBlog”;
-
@Retention: 只能用於修飾一個Annotation 定義, 用於指定該Annotation 的生命週期, @Rentention包含一個RetentionPolicy類型的成員變量, 使用@Rentention時必須爲該value 成員變量指定值:
- RetentionPolicy.SOURCE:在源文件中有效（即源文件保留），編譯器直接丟棄這種策略的註釋
- RetentionPolicy.CLASS:在class文件中有效（即class保留），當運行Java 程序時, JVM 不會保留註解。這是默認值
- RetentionPolicy.RUNTIME:在運行時有效（即運行時保留），當運行Java 程序時, JVM 會保留註釋。程序可以通過反射獲取該註釋。
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
/**
* @author subei
* @create 2020-05-11 11:47
*/
@Retention(RetentionPolicy.SOURCE)
public @interface MyAnnotation {
String value();
}
/**
* 註解的使用
*
* 4.jdk 提供的4種元註解
* 元註解：對現有的註解進行解釋說明的註解
* Retention:指定所修飾的 Annotation 的生命週期：SOURCE\CLASS（默認行爲）\RUNTIME
* 只有聲明爲RUNTIME生命週期的註解，才能通過反射獲取。
* Target:
* Documented:
* Inherited:
*
* @author subei
* @create 2020-05-11 11:19
*/
public class AnnotationTest {
public static void main(String[] args) {
}
}
@MyAnnotation(value = "hello")
class Person{
private String name;
private int age;
public Person() {
super();
}
@MyAnnotation(value = "jack")
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public void walk(){
System.out.println("學習中……");
}
public void eat(){
System.out.println("摸魚中……");
}
}
jdk中4個基本的元註解的使用2
- @Target: 用於修飾Annotation 定義, 用於指定被修飾的Annotation 能用於修飾哪些程序元素。@Target 也包含一個名爲value 的成員變量。
- @Documented: 用於指定被該元Annotation 修飾的Annotation 類將被javadoc工具提取成文檔。默認情況下，javadoc是不包括註解的。
- 定義爲Documented的註解必須設置Retention值爲RUNTIME。
- @Inherited: 被它修飾的Annotation 將具有繼承性。如果某個類使用了被@Inherited 修飾的Annotation, 則其子類將自動具有該註解。
- 比如：如果把標有@Inherited註解的自定義的註解標註在類級別上，子類則可以繼承父類類級別的註解
- 實際應用中，使用較少
import org.junit.Test;
import java.lang.annotation.Annotation;
import java.util.ArrayList;
import java.util.Date;
/**
* 註解的使用
*
* 4.jdk 提供的4種元註解
* 元註解：對現有的註解進行解釋說明的註解
* Retention:指定所修飾的 Annotation 的生命週期：SOURCE\CLASS（默認行爲）\RUNTIME
* 只有聲明爲RUNTIME生命週期的註解，才能通過反射獲取。
* Target:用於指定被修飾的 Annotation 能用於修飾哪些程序元素
* *******出現的頻率較低*******
* Documented:表示所修飾的註解在被javadoc解析時，保留下來。
* Inherited:被它修飾的 Annotation 將具有繼承性。
*
* 5.通過反射獲取註解信息 ---到反射內容時系統講解
*
* @author subei
* @create 2020-05-11 11:19
*/
public class AnnotationTest {
public static void main(String[] args) {
}
@Test
public void testGetAnnotation(){
Class clazz = Student.class;
Annotation[] annotations = clazz.getAnnotations();
for(int i = 0;i < annotations.length;i++){
System.out.println(annotations[i]);
}
}
}
@MyAnnotation(value = "hello")
class Person{
private String name;
private int age;
public Person() {
super();
}
@MyAnnotation
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@MyAnnotation
public void walk(){
System.out.println("學習中……");
}
public void eat(){
System.out.println("摸魚中……");
}
}
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
/**
* @author subei
* @create 2020-05-11 11:47
*/
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE,TYPE_PARAMETER,TYPE_USE})
public @interface MyAnnotation {
String value() default "book";
}
利用反射獲取註解信息
- JDK 5.0 在java.lang.reflect包下新增了AnnotatedElement接口, 該接口代表程序中可以接受註解的程序元素
- 當一個Annotation 類型被定義爲運行時Annotation 後, 該註解纔是運行時可見, 當class 文件被載入時保存在class 文件中的Annotation 纔會被虛擬機讀取
- 程序可以調用AnnotatedElement對象的如下方法來訪問Annotation 信息
jdk8新特性：可重複註解
Java 8對註解處理提供了兩點改進：可重複的註解及可用於類型的註解。此外，反射也得到了加強，在Java8中能夠得到方法參數的名稱。這會簡化標註在方法參數上的註解。
- 可重複註解示例：
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import static java.lang.annotation.ElementType.*;
/**
* @author subei
* @create 2020-05-11 15:07
*/
@Retention(RetentionPolicy.RUNTIME)
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
public @interface MyAnnotations {
MyAnnotation[] value();
}
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
/**
* @author subei
* @create 2020-05-11 11:47
*/
@Repeatable(MyAnnotations.class)
@Retention(RetentionPolicy.RUNTIME)
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE,TYPE_PARAMETER,TYPE_USE})
public @interface MyAnnotation {
String value() default "hello";
}
import java.lang.annotation.Annotation;
/**
* 註解的使用
*
* 6.jdk 8 中註解的新特性：可重複註解、類型註解
*
* 6.1可重複註解：① 在MyAnnotation上聲明@Repeatable，成員值爲MyAnnotations.class
* ② MyAnnotation的Target和Retention等元註解與MyAnnotations相同。
*
*
* @author subei
* @create 2020-05-11 11:19
*/
public class AnnotationTest {
public static void main(String[] args) {
}
}
@MyAnnotation(value = "hi")
@MyAnnotation(value = "abc")
//jdk 8之前的寫法：
//@MyAnnotations({@MyAnnotation(value="hi"),@MyAnnotation(value="hi")})
jdk8新特性：類型註解
- JDK1.8之後，關於元註解@Target的參數類型ElementType枚舉值多了兩個：TYPE_PARAMETER,TYPE_USE。
- 在Java8之前，註解只能是在聲明的地方所使用，Java8開始，註解可以應用在任何地方。
- ElementType.TYPE_PARAMETER表示該註解能寫在類型變量的聲明語句中（如：泛型聲明）。
- ElementType.TYPE_USE表示該註解能寫在使用類型的任何語句中。
import java.util.ArrayList;
/**
* 註解的使用
*
* 6.jdk 8 中註解的新特性：可重複註解、類型註解
*
* 6.1可重複註解：① 在MyAnnotation上聲明@Repeatable，成員值爲MyAnnotations.class
* ② MyAnnotation的Target和Retention等元註解與MyAnnotations相同。
*
* 6.2類型註解：
* ElementType.TYPE_PARAMETER 表示該註解能寫在類型變量的聲明語句中（如：泛型聲明）。
* ElementType.TYPE_USE 表示該註解能寫在使用類型的任何語句中。
*
* @author subei
* @create 2020-05-11 11:19
*/
public class AnnotationTest {
}
class Generic<@MyAnnotation T>{
public void show() throws @MyAnnotation RuntimeException{
ArrayList<@MyAnnotation String> list = new ArrayList<>();
int num = (@MyAnnotation int) 10L;
}
}
- MyAnnotation
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
/**
* @author subei
* @create 2020-05-11 11:47
*/
@Retention(RetentionPolicy.RUNTIME)
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE,TYPE_PARAMETER,TYPE_USE})
public @interface MyAnnotation {
String value() default "hello";
}
整個Java全棧系列都是筆者自己敲的筆記。寫作不易，如果可以，點個讚唄！✌