目录
1. 枚举类与注解
1.1 枚举类
1.1.1 枚举类的使用
1.枚举类的理解：类的对象只有有限个，确定的。我们称此类为枚举类；
2.当需要定义一组常量时，强烈建议使用枚举类；
3.如果枚举类中只有一个对象，则可以作为单例模式的实现方式。
1.1.2 如何定义枚举类
方式一： jdk5.0之前，自定义枚举类；
方式二： jdk5.0时，可以使用enum关键字定义枚举类。
(1) 方式一：自定义枚举类
1.声明类对象的属性：private final进行修饰；
2.私有化类的构造器，并对对象属性进行赋值；
3.提供当前枚举类的多个对象；
4.其他述求：获取枚举类对象的属性、toString( )。
(2) 方式二：使用enum关键字枚举类
1.提供当前枚举类的对象，多个对象之间用逗号隔开，末尾的对象用分号结束；
2.声明类对象的属性：private final进行修饰；
3.私有化类的构造器，并对对象属性进行赋值；
4.其他述求：获取枚举类对象的属性、toString( )。
1.1.3 enum类中的常用方法
● values()方法：返回枚举类型的对象数组。该方法可以很方便地遍历所有的枚举值；
● valueOf(String str)：可以把一个字符串转为对应的枚举类对象。要求字符串必须是枚举类对象的“名字”。如不是，会有运行时异常：IllegalArgumentException；
● toString()：返回当前枚举类对象常量的名称。
1.1.4 使用enum关键字定义的枚举类实现接口的情况
情况一：实现接口，在enum类中实现抽象方法；
情况二：让枚举类的对象分别实现接口中的抽象方法。
package com.java.meiju;
/**
* @description:枚举类
* @author: Fish_Vast
* @Date: 2021/9/27
* @version: 1.0
*/
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 seasonDescribe; //季节的描述
//2.私有化类的构造器,并对对象属性进行赋值
private Season(String seasonName, String seasonDescribe){
this.seasonName = seasonName;
this.seasonDescribe = seasonDescribe;
}
//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.其他述求1：获取枚举类对象的属性
public String getSeasonName() {
return seasonName;
}
public String getSeasonDescribe() {
return seasonDescribe;
}
//4.其他述求2:toString()
@Override
public String toString() {
return "Season{" +
"seasonName='" + seasonName + '\'' +
", seasonDescribe='" + seasonDescribe + '\'' +
'}';
}
}
package com.java.meiju;
/**
* @description:
* 使用enum关键字定义枚举类
* 说明：定义的枚举类默认继承于java.lang.Enum类
* @author: Fish_Vast
* @Date: 2021/9/27
* @version: 1.0
*/
public class SeasonTest1 {
public static void main(String[] args) {
Season1 summer = Season1.SUMMER;
//toString():返回当前枚举类对象常量的名称
System.out.println(summer);
// 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]);
values[i].show();
}
System.out.println("*******");
Thread.State[] values1 = Thread.State.values();
for (int i = 0; i <values1.length; i++) {
System.out.println(values1[i]);
}
System.out.println("*******");
//valueOf(String objName):返回枚举类中对象名是objName的对象。
Season1 winter = Season1.valueOf("WINTER");
//如果没有objName的枚举类对象,则抛异常：IllegalArgumentException
//Season1 winter = Season1.valueOf("WINTER1");
System.out.println(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 seasonDescribe; //季节的描述
//3.私有化类的构造器,并对对象属性进行赋值
private Season1(String seasonName, String seasonDescribe){
this.seasonName = seasonName;
this.seasonDescribe = seasonDescribe;
}
//4.其他述求1：获取枚举类对象的属性
public String getSeasonName() {
return seasonName;
}
public String getSeasonDescribe() {
return seasonDescribe;
}
//4.其他述求2:toString()
//enum关键字已经重写了toString()方法，输出的就是“名称”,如果有其他的诉求，可以继续重写toString()
// @Override
// public String toString() {
// return "Season{" +
// "seasonName='" + seasonName + '\'' +
// ", seasonDescribe='" + seasonDescribe + '\'' +
// '}';
// }
// @Override
// public void show() {
// System.out.println("这是一个季节！");
// }
}
1.2 注解(Annotation)
1.2.1 理解Annotation
① jdk5.0新增的功能；
② Annotation其实就是代码里的特殊标记, 这些标记可以在编译, 类加载, 运行时被读取,并执行相应的处理。通过使用Annotation, 程序员可以在不改变原有逻辑的情况下, 在源文件中嵌入一些补充信息；
③ 在JavaSE中，注解的使用目的比较简单，例如标记过时的功能，忽略警告等。在JavaEE/Android中注解占据了更重要的角色，例如用来配置应用程序的任何切面， 代替JavaEE旧版中所遗留的繁冗代码和XML配置等。
1.2.2 常见的Annotation示例
● 示例一：生成文档相关的注解
● 示例二： 在编译时进行格式检查(JDK内置的三个基本注解)
@Override: 限定重写父类方法, 该注解只能用于方法；
@Deprecated: 用于表示所修饰的元素(类, 方法等)已过时。通常是因为所修饰的结构危险或存在更好的选择；
@SuppressWarnings: 抑制编译器警告。
● 示例三： 跟踪代码依赖性，实现替代配置文件功能(框架层面的内容)
1.2.3 如何自定义注解：参考@SuppressWarnings定义
① 注解声明为：@interface，跟接口没有任何关系，这只是个固定格式而已；
② 内部定义成员，通常使用value表示；
③ 可以指定成员的默认值，使用default定义；
④ 如果自定义注解没有成员，表明是一个标识作用。
如果注解有成员，在使用注解时，需要指明成员的值。
自定义注解必须配上注解的信息处理流程（使用反射）才有意义。
自定义注解通常都会指明两个元注解：Retention、Target。
1.2.4 jdk提供的元注解
● 元注解：对现有的注解进行解释说明的注解
Retention： 指定所修饰的 Annotation 的生命周期：SOURCE\CLASS(默认行为)\RUNTIME(只有声明为RUNTIME声明周期的注解，才能通过反射获取)
Target： 用于指定被修饰的Annotation能用于修饰哪些元素
● 下面两个元注解出现的频率较低：
Documented： 表示所修饰的注解在被javac解析时，保留下来
Inherited： 被它修饰的Annotation将具有继承性
1.2.5 通过反射来获取注解信息
在反射笔记内容中再涉及，后续的内容将尽快更新进行补充。
1.2.6 jdk8 中注解的新特性
（1）可重复性注解
① 在MyAnnotation上声明@Repeatable,成员值为MyAnnotations.class；
② MyAnnotation的Target,Retention和Inherited等元注解与MyAnnotations相同。
（2）类型注解
① ElementType.TYPE_PARAMETER 表示该注解能写在类型变量的声明语句中（如：泛型声明）；
② ElementType.TYPE_USE 表示该注解能写在使用类型的任何语句中。
package com.java.zhujie;
import org.junit.Test;
import java.lang.annotation.Annotation;
import java.util.ArrayList;
import java.util.Date;
/**
* @description: 注解的使用
* @author: Fish_Vast
* @Date: 2021/9/30
* @version: 1.0
*/
public class AnnotationTest {
public static void main(String[] args) {
Person p = new Student();
Student s = new Student();
p.walk();
s.show();
//Deprecated
Date date = new Date(2020,9,30);
System.out.println(date);
//SuppressWarnings:警告int型变量num未被使用
@SuppressWarnings("unused")
int num = 10;
@SuppressWarnings({"unused","rawtypes"}) //其中的"unused","rawtypes"为属性(成员变量)
ArrayList list = new ArrayList();
}
@Test
public void test(){
Class clazz = Student.class;
Annotation[] annotations = clazz.getAnnotations();
for (int i = 0; i < annotations.length; i++) {
System.out.println(annotations[i]);
}
}
}
//@MyAnnotation(value = "hello") //这里面一定得需要有值，或者有默认值。
//jdk8 以前的形式：
//@MyAnnotations({@MyAnnotation(value = "hello"),@MyAnnotation(value = "world")})
@MyAnnotation(value = "hello")
@MyAnnotation(value = "world")
class Person{
private String name;
private int age;
public Person() {
}
@MyAnnotation
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public void walk(){
System.out.println("走路！");
}
}
interface Info{
void show();
}
class Student extends Person implements Info{
@Override //里面没有"value"值得注解，我们称之为"标记"。
public void walk() {
System.out.println("学生走路！");
}
@Override
public void show() {
System.out.println("我是学生");
}
}
class Generic <@MyAnnotation T>{
public void show() throws @MyAnnotation RuntimeException{
int num = (@MyAnnotation int) 10L;
ArrayList<@MyAnnotation String> list = new ArrayList<>();
}
}
package com.java.zhujie;
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_PARAMETER, TYPE_USE})
public @interface MyAnnotation {
//String value();
//默认值
String value() default "hi";
}
package com.java.zhujie;
import java.lang.annotation.Inherited;
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;
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
public @interface MyAnnotations {
MyAnnotation[] value();
}
路过的小伙伴，可以点赞+关注一波呀~本人将会持续更新相关学习博文，感谢您的支持哦！！！
469
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
