Java 枚举类
一、枚举类的使用
1.枚举类的理解:类的对象只有有限个,确定的。我们称此类为枚举类。
2.当需要定义一组常量时,强烈建议使用枚举类。
3.如果枚举类中只有一个对象,则可以作为单例模式的实现方式。
二、枚举类的定义
方式一:jdk5.0之前,自定义枚举类
/**
* 一、枚举类的使用
* 1.枚举类的理解:类的对象只有有限个,确定的。我们称此类为枚举类
* 2.当需要定义一组常量时,强烈建议使用枚举类
* 3.如果枚举类中只有一个对象,则可以作为单例模式的实现方式。
*
* 二、如何定义枚举类
* 方式一:jdk5.0之前,自定义枚举类
* 方式二:jdk5.0,可以使用enum关键字定义枚举类
*
* 三、Enum类中的常用方法:
* values()方法:返回枚举类型的对象数组。该方法可以很方便地遍历所有的枚举值。
* valueOf(String str):可以把一个字符串转为对应的枚举类对象。要求字符串必须是枚举类对象的“名字”。如不是,会有运行时异常:IllegalArgumentException。
* toString():返回当前枚举类对象常量的名称
*
* 四、使用enum关键字定义的枚举类实现接口的情况
* 情况一:实现接口,在enum类中实现抽象方法
* 情况二:让枚举类的对象分别实现接口中的抽象方法
*/
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的
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.其他诉求1:提供toString()
@Override
public String toString() {
return "Season{" +
"seasonName='" + seasonName + '\'' +
", seasonDesc='" + seasonDesc + '\'' +
'}';
}
}
方式二:jdk5.0,可以使用enum关键字定义枚举类
/**
* 使用enum关键字定义枚举类
* 说明:定义的枚举类默认继承于java.lang.Enum类
*/
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]);
values[i].show();
}
System.out.println("****************");
//State.values():返回线程所有的枚举类对象构成的常量数组
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 seasonDesc;
//2.私有化类的构造器,并给对象属性赋值
private Season1(String seasonName,String seasonDesc){
this.seasonName = seasonName;
this.seasonDesc = seasonDesc;
}
//4.其他诉求1:获取枚举类对象的属性
public String getSeasonName() {
return seasonName;
}
public String getSeasonDesc() {
return seasonDesc;
}
// //4.其他诉求1:提供枚举toString()输出
// @Override
// public String toString() {
// return "Season1{" +
// "seasonName='" + seasonName + '\'' +
// ", seasonDesc='" + seasonDesc + '\'' +
// '}';
// }
//实现接口,在enum类中实现抽象方法
// @Override
// public void show() {
// System.out.println("这是一个季节");
// }
}
三、Enum类中的常用方法:
values():
返回枚举类型的对象数组。该方法可以很方便地遍历所有的枚举值。
valueOf(String str):
可以把一个字符串转为对应的枚举类对象。要求字符串必须是枚举类对象的“名字”。如不是,会有运行时异常:IllegalArgumentException。
toString():
返回当前枚举类对象常量的名称
四、使用enum关键字定义的枚举类实现接口的情况
情况一:实现接口,在enum类中实现抽象方法
在枚举类中直接实现接口抽象方法。
//使用enum关键字枚举类
enum Season1 implements Info{
//1.提供当前枚举类的对象,多个对象之间用","隔开,末尾对象";"结束
SPRING("春天","春暖花开");
//实现接口,在enum类中实现抽象方法
@Override
public void show() {
System.out.println("这是一个季节");
}
}
情况二:让枚举类的对象分别实现接口中的抽象方法
在枚举类对象中实现接口抽象方法
//使用enum关键字枚举类
enum Season1 implements Info{
//1.提供当前枚举类的对象,多个对象之间用","隔开,末尾对象";"结束
SPRING("春天","春暖花开"){
//让枚举类的对象分别实现接口中的抽象方法
@Override
public void show() {
System.out.println("春天在哪里?");
}
};
}
Java 注解
一、注解 (Annotation) 概述
- 从 JDK 5.0 开始, Java 增加了对元数据(MetaData) 的支持, 也就是Annotation(注解)
- Annotation 其实就是代码里的特殊标记, 这些标记可以在编译, 类加载, 运行时被读取, 并执行相应的处理。通过使用 Annotation, 程序员可以在不改变原有逻辑的情况下, 在源文件中嵌入一些补充信息。代码分析工具、开发工具和部署工具可以通过这些补充信息进行验证或者进行部署。
- Annotation 可以像修饰符一样被使用, 可用于修饰包,类, 构造器, 方法, 成员变量, 参数, 局部变量的声明, 这些信息被保存在 Annotation的 “name=value” 对中。
- 在JavaSE中,注解的使用目的比较简单,例如标记过时的功能,忽略警告等。在JavaEE/Android中注解占据了更重要的角色,例如用来配置应用程序的任何切面, 代替JavaEE旧版中所遗留的繁冗代码和XML配置等。
- 未来的开发模式都是基于注解的, JPA是基于注解的, Spring2.5以上都是基于注解的, Hibernate3.x以后也是基于注解的,现在的Struts2有一部分也是基于注解的了,注解是一种趋势,一定程度上可以说: 框架 = 注解 + 反射 + 设计模式。
二、注解的使用案例
示例一 生成文档相关的注解
@author 标明开发该类模块的作者, 多个作者之间使用分割
@version 标明该类模块的版本
@see 参考转向, 也就是相关主题
@since 从哪个版本开始增加的
@param 对方法中某参数的说明, 如果没有参数就不能写
@return 对方法返回值的说明, 如果方法的返回值类型是void就不能写
@exception 对方法可能抛出的异常进行说明 , 如果方法没有用throws显式抛出的异常就不能写
其中
@param @return 和 @exception 这三个标记都是只用于方法的。
@param的格式要求: @param 形参名 形参类型 形参说明
@return 的格式要求: @return 返回值类型 返回值说明
@exception的格式要求: @exception 异常类型 异常说明
@param和@exception可以并列多个
/**
* @author cmy
* @version 1.0
* @see Math.java
*/
public class JavadocTest {
/**
* 程序的主方法,程序的入口
* @param args String[] 命令行参数
*/
public static void main(String[] args) {
}
/**
* 求圆面积的方法
* @param radius double 半径值
* @return double 圆的面积
*/
public static double getArea(double radius){
return Math.PI * radius * radius;
}
}
示例二 在编译时进行格式检查(JDK内置的三个基本注解)
- @Override: 限定重写父类方法, 该注解只能用于方法,校验方法是否重写。
- @Deprecated: 用于表示所修饰的元素(类, 方法等)已过时。通常是因为所修饰的结构危险或存在更好的选择。
- @SuppressWarnings: 抑制编译器警告 。
public class AnnotationTest{
public static void main(String[] args) {
@SuppressWarnings("unused")
int a = 10;
}
@Deprecated
public void print(){
System.out.println("过时的方法");
}
@Override
public String toString() {
return "重写的toString方法()";
}
}
示例三 跟踪代码依赖性,实现替代配置文件功能
- Servlet3.0提供了注解(annotation),使得不再需要在web.xml文件中进行Servlet的部署
@WebServlet("/login")
public class LoginServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws
ServletException, IOException { }
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws
ServletException, IOException {
doGet(request, response);
} }
<!-- xml配置servlet -->
<servlet>
<servlet-name>LoginServlet</servlet-name>
<servlet-class>com.servlet.LoginServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>LoginServlet</servlet-name>
<url-pattern>/login</url-pattern>
</servlet-mapping>
浏览器地址/login、对应servlet-name的LoginServlet、通过LoginServlet找到com.servlet.LoginServlet控制类位置传递请求响应信息。
- Spring框架中关于“事务” 的管理,使用注解后不用再xml中配置事务。
@Transactional(propagation=Propagation.REQUIRES_NEW,
isolation=Isolation.READ_COMMITTED,readOnly=false,timeout=3)
public void buyBook(String username, String isbn) {
//1.查询书的单价
int price = bookShopDao.findBookPriceByIsbn(isbn);
//2. 更新库存
bookShopDao.updateBookStock(isbn);
//3. 更新用户的余额
bookShopDao.updateUserAccount(username, price);
}
<!-- xml配置事务属性 -->
<tx:advice transaction-manager="dataSourceTransactionManager" id="txAdvice">
<tx:attributes>
<!-- 配置每个方法使用的事务属性 isolation隔离级别、propagation方法如何用事务-->
<tx:method name="buyBook" propagation="REQUIRES_NEW"
isolation="READ_COMMITTED" read-only="false" timeout="3" />
</tx:attributes>
</tx:advice>
三、自定义注解 Annotation
参照@SuppressWarnings定义:
① 注解声明为:@interface
② 内部定义成员,通常使用value表示
③ 可以指定成员的默认值,使用default定义
④ 如果自定义注解没有成员,表明是一个标识作用。
如果注解有成员,在使用注解时,需要指明成员的值。
自定义注解必须配上注解的信息处理流程(使用反射)才有意义。
自定义注解通过都会指明两个元注解:Retention、Target。
四、jdk 提供的4种元注解
元注解:对现有的注解进行解释说明的注解。
Retention:指定所修饰的 Annotation 的生命周期:SOURCE\CLASS(默认行为)\RUNTIME
只有声明为RUNTIME生命周期的注解,才能通过反射获取。
Target:用于指定被修饰的 Annotation 能用于修饰哪些程序元素。
出现的频率较低
Documented:表示所修饰的注解在被javadoc解析时,保留下来。默认不加这个注解。
Inherited:被它修饰的 Annotation 将具有继承性。
五、通过反射获取注解信息
具体看注解综合案例
/**
* 常规注解反射案例
*/
@Test
public void testGetAnnotation(){
//得到目标类class
Class clazz = Student.class;
//反射获取目标类class上的注解
Annotation[] annotations = clazz.getAnnotations();
//遍历输出注解数组
for(int i = 0;i < annotations.length;i++){
//输出注解内容
System.out.println(annotations[i]);
}
}
六、jdk8注解新特性可重复注解、类型注解
可重复注解:
① 在MyAnnotation上声明@Repeatable,成员值为MyAnnotations.class
② MyAnnotation的Target和Retention等元注解与MyAnnotations相同。
类型注解:
ElementType.TYPE_PARAMETER 表示该注解能写在类型变量的声明语句中(如:泛型声明)。
ElementType.TYPE_USE 表示该注解能写在使用类型的任何语句中。
七、注解综合案例
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.*;
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
public @interface MyAnnotations {
//为了重复使用MyAnnotation注解创建注解数组
MyAnnotation[] value();
}
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
//注解继承
@Inherited
//注解可重复 1.8后特性
@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";
}
package com.atguigu.java1;
import org.junit.Test;
import java.lang.annotation.Annotation;
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: 抑制编译器警告
* 示例三:跟踪代码依赖性,实现替代配置文件功能
*
* 3. 如何自定义注解:
* 参照@SuppressWarnings定义
* ① 注解声明为:@interface
* ② 内部定义成员,通常使用value表示
* ③ 可以指定成员的默认值,使用default定义
* ④ 如果自定义注解没有成员,表明是一个标识作用。
如果注解有成员,在使用注解时,需要指明成员的值。
自定义注解必须配上注解的信息处理流程(使用反射)才有意义。
自定义注解通过都会指明两个元注解:Retention、Target
4. jdk 提供的4种元注解
元注解:对现有的注解进行解释说明的注解
Retention:指定所修饰的 Annotation 的生命周期:SOURCE\CLASS(默认行为)\RUNTIME
只有声明为RUNTIME生命周期的注解,才能通过反射获取。
Target:用于指定被修饰的 Annotation 能用于修饰哪些程序元素
*******出现的频率较低*******
Documented:表示所修饰的注解在被javadoc解析时,保留下来。
Inherited:被它修饰的 Annotation 将具有继承性。
5.通过反射获取注解信息 ---到反射内容时系统讲解
6. jdk 8 中注解的新特性:可重复注解、类型注解
6.1 可重复注解:
① 在MyAnnotation上声明@Repeatable,成员值为MyAnnotations.class
② MyAnnotation的Target和Retention等元注解与MyAnnotations相同。
6.2 类型注解:
ElementType.TYPE_PARAMETER 表示该注解能写在类型变量的声明语句中(如:泛型声明)。
ElementType.TYPE_USE 表示该注解能写在使用类型的任何语句中。
*/
public class AnnotationTest {
public static void main(String[] args) {
//向上转型,子类转成父类
Person p = new Student();
//优先调用子类的walk方法
p.walk();
//@Deprecated表示所修饰的元素(类, 方法等)已过时
Date date = new Date(2020, 10, 11);
System.out.println(date);
//@SuppressWarnings抑制编译器警告注解
@SuppressWarnings("unused")
int num = 10;
@SuppressWarnings({ "unused", "rawtypes" })
ArrayList list = new ArrayList();
}
/**
* 常规注解反射案例
*/
@Test
public void testGetAnnotation(){
//得到目标类class
Class clazz = Student.class;
//反射获取目标类class上的注解
Annotation[] annotations = clazz.getAnnotations();
//遍历输出注解数组
for(int i = 0;i < annotations.length;i++){
//输出注解内容
System.out.println(annotations[i]);
}
}
/**
* 类型注解反射案例
*/
@Test
public void testGeneric(){
//得到目标泛型类class
Class<Generic> genericClass = Generic.class;
//反射获取目标泛型类class中的注解
Annotation[] annotations = genericClass.getAnnotations();
//遍历输出注解数组
for(int i = 0;i < annotations.length;i++){
//输出注解内容
System.out.println(annotations[i]);
}
}
}
//重复使用_jdk8之前的写法:
//@MyAnnotations({@MyAnnotation(value="hi"),@MyAnnotation(value="hi")})
//重复使用_jdk8之后的写法:
@MyAnnotation(value="hi")
@MyAnnotation(value="abc")
class Person{
private String name;
private int age;
public Person() {
}
@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("人吃饭");
}
}
//接口类
interface Info{
void show();
}
//子类继承父类实现接口类
class Student extends Person implements Info{
//@Override注解检验方法是否是重写方法
@Override
public void walk() {
System.out.println("学生走路");
}
public void show() {
}
}
//类型注解示例 Target增加参数类型TYPE_PARAMETER、TYPE_USE后可修饰声明、类型
//注解@MyAnnotation修饰泛型声明
class Generic<@MyAnnotation("修饰泛型T") T>{
//注解@MyAnnotation修饰RuntimeException
public void show() throws @MyAnnotation("修饰运行抛异常") RuntimeException{
//注解@MyAnnotation修饰String
ArrayList<@MyAnnotation("修饰String") String> list = new ArrayList<>();
//注解@MyAnnotation修饰int
int num = (@MyAnnotation("修饰int") int) 10L;
//可通过反射拿到注解内容
}
}