第15章_Junit_注解_枚举

Junit单元测试

引入

【1】软件测试的目的：

软件测试的目的是在规定的条件下对程序进行操作,以发现程序错误,衡量软件质量,并对其是否能满足设计要求进行评估的过程。

【2】测试分类：

（1）黑盒测试：

软件的黑盒测试意味着测试要在软件的接口处进行。这种方法是把测试对象看做一个黑盒子,测试人员完全不考虑程序内部的逻辑结构和内部特性,只依据程序的需求规格说明书,检查程序的功能是否符合它的功能说明。因此黑盒测试又叫功能测试。

（2）白盒测试：---》Junit属于白盒测试。

软件的白盒测试是对软件的过程性细节做细致的检查。这种方法是把测试对象看做一个打开的盒子,它允许测试人员利用程序内部的逻辑结构及有关信息,设计或选择测试用例,对程序的所有逻辑路径进行测试,通过在不同点检查程序状态,确定实际状态是否与预期的状态一致。因此白盒测试又称为结构测试。

没有Junit的情况下如何测试

在没有使用Junit的时候，缺点：

（1）测试一定走main方法，是程序的入口，main方法的格式必须不能写错。

（2）要是在同一个main方法中测试的话，那么不需要测试的东西必须注释掉。

（3）测试逻辑如果分开的话，需要定义多个测试类，麻烦。

（4）业务逻辑和测试代码，都混淆了。

代码：

 1 public class Calculator {
 2     //加法：
 3     public int add(int a,int b){
 4         return a+b;
 5     }
 6     //减法：
 7     public int sub(int a,int b){
 8         return a-b;
 9     }
10 }

 1 public class Test {
 2     //这是一个main方法，是程序的入口：
 3     public static void main(String[] args) {
 4         //测试加法：
 5         Calculator cal = new Calculator();
 6         int result = cal.add(10, 20);
 7         System.out.println(result);
 8         //测试减法：
 9        /* int result = cal.sub(30, 10);
10         System.out.println(result);*/
11     }
12 }

1 public class Test02 {
2     //这是一个main方法，是程序的入口：
3     public static void main(String[] args) {
4         Calculator cal = new Calculator();
5         //测试减法：
6         int result = cal.sub(30, 10);
7         System.out.println(result);
8     }
9 }

Junit的使用

【1】一般测试和业务做一个分离，分离为不同的包：

建议起名：公司域名倒着写+test

以后测试类就单独放在这个包下

【2】测试类的名字：****Test --->见名知意

【3】测试方法的定义--》这个方法可以独立运行，不依托于main方法

建议：

名字：testAdd() testSub() 见名知意

参数：无参

返回值：void

【4】测试方法定义完以后，不能直接就独立运行了，必须要在方法前加入一个注解： @Test

【5】导入Junit的依赖的环境：

【6】代码：

 1 package com.llh;
 2 
 3 import com.llh.calculator.Calculator;
 4 import org.junit.Test;
 5 
 6 public class CalculatorTest {
 7     //测试add方法
 8     @Test
 9     public void testAdd(){
10         System.out.println("测试add方法");
11         Calculator cal = new Calculator();
12         int result = cal.add(10, 30);
13         System.out.println(result);
14     }
15     //测试sub方法
16     @Test
17     public void testSub(){
18         System.out.println("测试sub方法");
19         Calculator cal = new Calculator();
20         int result = cal.sub(10, 30);
21         System.out.println(result);
22     }
23 }

【7】判定结果：

绿色：正常结果

红色：出现异常

【8】即使出现绿色效果，也不意味着你的测试就通过了，因为代码中逻辑也可能出现问题，这种情况怎么解决呢？

加入断言

 1 package com.llh;
 2 
 3 import com.llh.calculator.Calculator;
 4 import org.junit.Assert;
 5 import org.junit.Test;
 6 
 7 
 8 public class CalculatorTest {
 9     //测试add方法
10     @Test
11     public void testAdd(){
12         System.out.println("测试add方法");
13         Calculator cal = new Calculator();
14         int result = cal.add(10, 30);
15         //System.out.println(result);--》程序的运行结果可以不关注
16         //加入断言：预测一下结果，判断一下我预测的结果和 实际的结果是否一致：
17         Assert.assertEquals(40,result);//第一个参数：预测结果  第二个参数：实际结果
18     }
19     //测试sub方法
20     @Test
21     public void testSub(){
22         System.out.println("测试sub方法");
23         Calculator cal = new Calculator();
24         int result = cal.sub(10, 30);
25         System.out.println(result);
26     }
27 }

@Before_@After

@Before:

某一个方法中，加入了@Before注解以后，那么这个方法中的功能会在测试方法执行前先执行

一般会在@Beforer修饰的那个方法中加入：加入一些申请资源的代码：申请数据库资源，申请IO资源，申请网络资源。。。

@After:

某一个方法中，加入了@After注解以后，那么这个方法中的功能会在测试方法执行后先执行

一般会在@After修饰的那个方法中加入：加入释放资源的代码：释放数据库资源，释放IO资源，释放网络资源。。。

代码：

 1 package com.llh;
 2 
 3 import com.llh.calculator.Calculator;
 4 import org.junit.After;
 5 import org.junit.Assert;
 6 import org.junit.Before;
 7 import org.junit.Test;
 8 
 9 public class CalculatorTest {
10     @Before
11     public void init(){
12         System.out.println("方法执行开始了。。。");
13     }
14     @After
15     public void close(){
16         System.out.println("方法执行结束了。。。");
17     }
18     //测试add方法
19     @Test
20     public void testAdd(){
21         System.out.println("测试add方法");
22         Calculator cal = new Calculator();
23         int result = cal.add(10, 30);
24         //System.out.println(result);--》程序的运行结果可以不关注
25         //加入断言：预测一下结果，判断一下我预测的结果和 实际的结果是否一致：
26         Assert.assertEquals(40,result);//第一个参数：预测结果  第二个参数：实际结果
27     }
28     //测试sub方法
29     @Test
30     public void testSub(){
31         System.out.println("测试sub方法");
32         Calculator cal = new Calculator();
33         int result = cal.sub(10, 30);
34         System.out.println(result);
35     }
36 }

注解

引入

【1】历史：

JDK5.0 新增 --- 注解（Annotation）,也叫元数据

【2】什么是注解？

注解其实就是代码里的特殊标记，这些标记可以在编译,类加载,运行时被读取,并执行相应的处理。通过使用注解,程序员可以在不改变原有逻辑的情况下，在源文件中嵌入一些补充信息。代码分析工具、开发工具和部署工具可以通过这些补充信息进行验证或者进行部署。

使用注解时要在其前面增加@符号,并把该注解当成一个修饰符使用。用于修饰它支持的程序元素。

【3】注解的重要性：

Annotation 可以像修饰符一样被使用，可用于修饰包，类，构造器,方法，成员变量,参数，局部变量的声明，这些信息被保存在Annotation的"name=value"对中。在JavaSE中，注解的使用目的比较简单，例如标记过时的功能，忽略警告等。在JavaEE/ArIdroid中注解占据了更重要的角色，例如用来配置应用程序的任何切面，代替JavaEE旧版中所遗留的繁冗代码和XML配置等。未来的开发模式都是基于注解的，JPA(java的持久化API)是基于注解的，Spring2.5以. E都是基于注解的，Hibernate3.x以后也是基于注解的，现在的Struts2有一部分也是基于注解的了，注解是一种趋势，一定程度上可以说：框架=注解+反射+设计模式。

注解的使用实例

Junit的注解

@Test

@Before

@After

代码：

 1 package com.llh;
 2 
 3 import com.llh.calculator.Calculator;
 4 import org.junit.After;
 5 import org.junit.Assert;
 6 import org.junit.Before;
 7 import org.junit.Test;
 8 
 9 public class CalculatorTest {
10     @Before
11     public void init(){
12         System.out.println("方法执行开始了。。。");
13     }
14     @After
15     public void close(){
16         System.out.println("方法执行结束了。。。");
17     }
18     @Test
19     public void testAdd(){
20         System.out.println("测试add方法");
21         Calculator cal = new Calculator();
22         int result = cal.add(10, 30);
23         Assert.assertEquals(40,result);//第一个参数：预测结果  第二个参数：实际结果
24     }
25 }

文档相关的注解

说明注释允许你在程序中嵌入关于程序的信息。你可以使用 javadoc 工具软件来生成信息，并输出到HTML文件中。

说明注释，使你更加方便的记录你的程序信息。

文档注解我们一般使用在文档注释中，配合javadoc工具

javadoc 工具软件识别以下标签：

其中注意：

Ø @param @return和@exception这三个标记都是只用于方法的。

Ø @param的格式要求: @param 形参名形参类型形参说明

Ø @return的格式要求: @return 返回值类型返回值说明，如果方法的返回值类型是void就不能写

Ø @exception的格式要求: @exception 异常类型异常说明

Ø @param和@exception可以并列多个

代码：

 1 public class Person {
 2     /**
 3      * 下面是eat方法，实现了XXX功能。
 4      * @param num1 就餐人数
 5      * @param num2 点了几个菜
 6      */
 7     public void eat(int num1,int num2){
 8     }
 9     /**
10      * @param age 年龄
11      * @return int
12      * @exception RuntimeException 当年龄过大的时候
13      * @exception IndexOutOfBoundsException 当年龄过小的时候
14      * @see Student
15      */
16     public int sleep(int age){
17         new Student();
18         if(age>100){
19             throw new RuntimeException();
20         }
21         if(age<0){
22             throw new IndexOutOfBoundsException();
23         }
24         return 10;
25     }
26 }

IDEA中的javadoc使用：

防止乱码：

JDK内置的3个注解

@Override:限定重写父类方法，该注解只能用于方法

1 public class Person {
2     public void eat(){
3         System.out.println("父类eat..");
4     }
5 }

1 public class Student extends Person {
2     /*
3     @Override的作用：限定重写的方法，只要重写方法有问题，就有错误提示。
4      */
5     @Override
6     public void eat(){
7         System.out.println("子类eat..");
8     }
9 }

@Deprecated:用于表示所修饰的元素(类,方法，构造器，属性等)已过时。通常是因为所修饰的结构危险或存在更好的选择

 1 public class Student extends Person {
 2     /*
 3     @Override的作用：限定重写的方法，只要重写方法有问题，就有错误提示。
 4      */
 5     @Override
 6     public void eat(){
 7         System.out.println("子类eat..");
 8     }
 9     /*
10     在方法前加入@Deprecated，这个方法就会变成一个废弃方法/过期方法/过时方法
11      */
12     @Deprecated
13     public void study(){
14         System.out.println("学习。。");
15     }
16 }

@SuppressWarnings:抑制编译器警告

 1 public class Test02 {
 2     //这是一个main方法，是程序的入口：
 3     public static void main(String[] args) {
 4         @SuppressWarnings("unused")
 5         int age = 10;
 6         
 7         int num = 10;
 8         System.out.println(num);
 9         @SuppressWarnings({"unused","rwatypes"})
10         ArrayList al = new ArrayList();
11     }
12 }

实现替代配置文件功能的注解

在servlet3.0之前的配置：

 1 package com.llh;
 2 
 3 import javax.servlet.*;
 4 import java.io.IOException;
 5 
 6 public class HelloServlet implements Servlet {
 7     @Override
 8     public void init(ServletConfig servletConfig) throws ServletException {
 9 
10     }
11 
12     @Override
13     public ServletConfig getServletConfig() {
14         return null;
15     }
16 
17 
18     @Override
19     public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
20         System.out.println("service方法被调用了...");
21     }
22 
23     @Override
24     public String getServletInfo() {
25         return null;
26     }
27 
28     @Override
29     public void destroy() {
30 
31     }
32 }

<?xml version="1.0" encoding="UTF-8"?>

<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"

version="4.0">

<servlet-name>HelloServlet</servlet-name>

<servlet-class>com.bjsxt.servlet.HelloServlet</servlet-class>

</servlet>

<servlet-mapping>

<servlet-name>HelloServlet</servlet-name>

<url-pattern>/hello</url-pattern>

</servlet-mapping>

</web-app>

在servlet3.0之后使用注解：替代配置文件。

 1 package com.llh;
 2 
 3 package com.bjsxt.servlet;
 4 
 5 import javax.servlet.*;
 6 import java.io.IOException;
 7 
 8 @WebServlet("/hello")
 9 public class HelloServlet implements Servlet {
10     @Override
11     public void init(ServletConfig servletConfig) throws ServletException {
12 
13     }
14 
15     @Override
16     public ServletConfig getServletConfig() {
17         return null;
18     }
19 
20     /**
21      * 用于提供服务, 接收请求, 处理响应
22      *
23      * @param servletRequest
24      * @param servletResponse
25      * @throws ServletException
26      * @throws IOException
27      */
28     @Override
29     public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
30         System.out.println("service方法被调用了...");
31     }
32 
33     @Override
34     public String getServletInfo() {
35         return null;
36     }
37 
38     @Override
39     public void destroy() {
40 
41     }
42 }

自定义注解

【1】自定义注解使用很少，一般情况下都是用现成的注解。

【2】如何自定义注解：

发现定义的注解的声明使用的关键字：@interface，跟接口没有一点关系。

【3】注解的内部：

以@SuppressWarnings为例，发现内部：

这value是属性还是方法？

答案：看上去是无参数方法，实际上理解为一个成员变量，一个属性

无参数方法名字--》成员变量的名字

无参数方法的返回值--》成员变量的类型

这个参数叫配置参数

无参数方法的类型：基本数据类型（八种），String，枚举，注解类型，还可以是以上类型对应的数组。

PS：注意：如果只有一个成员变量的话，名字尽量叫value。

【4】使用注解：

（1）使用注解的话，如果你定义了配置参数，就必须给配置参数进行赋值操作：

1 @MyAnnotation(value={"abc","def","hij"})
2 public class Person {
3 }

（2）如果只有一个参数，并且这个参数的名字为value的话，那么value=可以省略不写。

1 @MyAnnotation({"abc","def","hij"})
2 public class Person {
3 }

（3）如果你给配置参数设置默认的值了，那么使用的时候可以无需传值：

1 public @interface MyAnnotation2 {
2     String value() default "abc";
3 }

使用：

1 @MyAnnotation2
2 @MyAnnotation({"abc","def","hij"})
3 public class Person {
4 }

（4）一个注解的内部是可以不定义配置参数的：

1 public @interface MyAnnotation3 {
2 }

内部没有定义配置参数的注解--》可以叫做标记

内部定义配置参数的注解--》元数据

【5】注解的使用：

现在只学习注解的大致技能点，具体怎么应用后面慢慢学习。

元注解

元注解是用于修饰其它注解的注解。

举例：

JDK5.0提供了四种元注解：Retention, Target, Documented, Inherited

Retention

@Retention:用于修饰注解，用于指定修饰的那个注解的生命周期，@Rentention包含一个RetentionPolicy枚举类型的成员变量,使用@Rentention时必须为该value成员变量指定值:

➢RetentionPolicy.SOURCE:在源文件中有效(即源文件保留),编译器直接丢弃这种策略的注释，在.class文件中不会保留注解信息

案例：

反编译查看字节码文件：发现字节码文件中没有MyAnnotation这个注解：

➢RetentionPolicy.CLASS:在class文件中有效(即class保留)，保留在.class文件中，但是当运行Java程序时，他就不会继续加载了，不会保留在内存中，JVM不会保留注解。如果注解没有加Retention元注解，那么相当于默认的注解就是这种状态。

案例：

反编译看字节码文件，字节码文件中带有MyAnnotation注解：

➢RetentionPolicy.RUNTIME:在运行时有效(即运行时保留),当运行 Java程序时，JVM会保留注释，加载在内存中了，那么程序可以通过反射获取该注释。

Target

用于修饰注解的注解，用于指定被修饰的注解能用于修饰哪些程序元素。@Target也包含一个名为value的成员变量。

案例：

1 @Target({TYPE,CONSTRUCTOR,METHOD})
2 public @interface MyAnnotation4 {
3 }

使用：

Documented（很少）

用于指定被该元注解修饰的注解类将被javadoc工具提取成文档。默认情况下，javadoc是不包括注解的，但是加上了这个注解生成的文档中就会带着注解了

案例：

如果：Documented注解修饰了Deprecated注解，

那么Deprecated注解就会在javadoc提取的时候，提取到API中：

Inherited（极少）

被它修饰的Annotation将具有继承性。如果某个类使用了被

@Inherited修饰的Annotation,则其子类将自动具有该注解。

案例：

注解：如果MyAnno注解使用了@Inherited之后，就具备了继承性，那么相当于子类Student也使用了这个MyAnno

父类：

子类：

枚举

引入

【1】数学：枚举法：

1<x<4

2<y<5

求x+y=6

枚举法：一枚一枚的列举出来。前提：有限，确定

【2】在java中，类的对象是有限个，确定的。这个类我们可以定义为枚举类。

举例：

星期：一二三四五六日

性别：男女

季节：春夏秋冬

【3】自定义枚举类：（JDK1.5之前自定义枚举类）

 1 package com.llh;
 2 
 3 public class Season {
 4     //属性：
 5     private final String seasonName ;//季节名字
 6     private final String seasonDesc ;//季节描述
 7     //利用构造器对属性进行赋值操作：
 8     //构造器私有化，外界不能调用这个构造器，只能Season内部自己调用
 9     private Season(String seasonName,String seasonDesc){
10         this.seasonName = seasonName;
11         this.seasonDesc = seasonDesc;
12     }
13     //提供枚举类的有限的  确定的对象：
14     public static final Season SPRING = new Season("春天","春暖花开");
15     public static final Season SUMMER = new Season("夏天","烈日炎炎");
16     public static final Season AUTUMN = new Season("秋天","硕果累累");
17     public static final Season WINTER = new Season("冬天","冰天雪地");
18     //额外因素：
19     public String getSeasonName() {
20         return seasonName;
21     }
22     public String getSeasonDesc() {
23         return seasonDesc;
24     }
25     //toString();
26     @Override
27     public String toString() {
28         return "Season{" +
29                 "seasonName='" + seasonName + '\'' +
30                 ", seasonDesc='" + seasonDesc + '\'' +
31                 '}';
32     }
33 }

测试类：

1 public class TestSeason {
2     //这是一个main方法，是程序的入口：
3     public static void main(String[] args) {
4         Season summer = Season.SUMMER;
5         System.out.println(summer/*.toString()*/);
6         System.out.println(summer.getSeasonName());
7     }
8 }

JDK1_5之后使用enum关键字来创建枚举类

JDK1.5以后使用enum关键字创建枚举类：

变为下面的枚举类：

 1 package com.llh;
 2 
 3 /**
 4  * @author : llh
 5  * 定义枚举类：季节
 6  */
 7 public enum Season {
 8     //提供枚举类的有限的  确定的对象：--->enum枚举类要求对象（常量）必须放在最开始位置
 9     //多个对象之间用，进行连接，最后一个对象后面用;结束
10     SPRING("春天","春暖花开"),
11     SUMMER("夏天","烈日炎炎"),
12     AUTUMN("秋天","硕果累累"),
13     WINTER("冬天","冰天雪地");
14     //属性：
15     private final String seasonName ;//季节名字
16     private final String seasonDesc ;//季节描述
17     //利用构造器对属性进行赋值操作：
18     //构造器私有化，外界不能调用这个构造器，只能Season内部自己调用
19     private Season(String seasonName, String seasonDesc){
20         this.seasonName = seasonName;
21         this.seasonDesc = seasonDesc;
22     }
23     //额外因素：
24     public String getSeasonName() {
25         return seasonName;
26     }
27     public String getSeasonDesc() {
28         return seasonDesc;
29     }
30     //toString();
31     @Override
32     public String toString() {
33         return "Season{" +
34                 "seasonName='" + seasonName + '\'' +
35                 ", seasonDesc='" + seasonDesc + '\'' +
36                 '}';
37     }
38 }

使用枚举类：

 1 public class TestSeason {
 2     //这是一个main方法，是程序的入口：
 3     public static void main(String[] args) {
 4         Season winter = Season.WINTER;
 5         System.out.println(winter);
 6         //enum关键字对应的枚举类的上层父类是 ：java.lang.Enum
 7         //但是我们自定义的枚举类的上层父类：Object
 8         System.out.println(Season.class.getSuperclass().getName());//java.lang.Enum
 9     }
10 }

在源码中经常看到别人定义的枚举类形态：

1 public enum Season {
2     SPRING,
3     SUMMER,
4     AUTUMN,
5     WINTER;
6 }

为什么这么简单：因为这个枚举类底层没有属性，属性，构造器，toString，get方法都删掉不写了，然后案例来说应该

写为：SPRING() 现在连（）可以省略就变成 SPRING

看到的形态就剩：常量名（对象名）

案例：

Thread中的枚举类：State

 1 public enum State {
 2         /**
 3          * Thread state for a thread which has not yet started.
 4          */
 5         NEW,
 6         /**
 7          * Thread state for a runnable thread.  A thread in the runnable
 8          * state is executing in the Java virtual machine but it may
 9          * be waiting for other resources from the operating system
10          * such as processor.
11          */
12         RUNNABLE,
13         /**
14          * Thread state for a thread blocked waiting for a monitor lock.
15          * A thread in the blocked state is waiting for a monitor lock
16          * to enter a synchronized block/method or
17          * reenter a synchronized block/method after calling
18          * {@link Object#wait() Object.wait}.
19          */
20         BLOCKED,
21         /**
22          * Thread state for a waiting thread.
23          * A thread is in the waiting state due to calling one of the
24          * following methods:
25          * <ul>
26          *   <li>{@link Object#wait() Object.wait} with no timeout</li>
27          *   <li>{@link #join() Thread.join} with no timeout</li>
28          *   <li>{@link LockSupport#park() LockSupport.park}</li>
29          * </ul>
30          *
31          * <p>A thread in the waiting state is waiting for another thread to
32          * perform a particular action.
33          *
34          * For example, a thread that has called <tt>Object.wait()</tt>
35          * on an object is waiting for another thread to call
36          * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
37          * that object. A thread that has called <tt>Thread.join()</tt>
38          * is waiting for a specified thread to terminate.
39          */
40         WAITING,
41         /**
42          * Thread state for a waiting thread with a specified waiting time.
43          * A thread is in the timed waiting state due to calling one of
44          * the following methods with a specified positive waiting time:
45          * <ul>
46          *   <li>{@link #sleep Thread.sleep}</li>
47          *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
48          *   <li>{@link #join(long) Thread.join} with timeout</li>
49          *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
50          *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
51          * </ul>
52          */
53         TIMED_WAITING,
54         /**
55          * Thread state for a terminated thread.
56          * The thread has completed execution.
57          */
58         TERMINATED;
59     }

Enum类的常用方法

 1 package com.llh;
 2 
 3 /**
 4  * @author : llh
 5  */
 6 
 7 public class TestSeason {
 8     //这是一个main方法，是程序的入口：
 9     public static void main(String[] args) {
10         //用enum关键字创建的Season枚举类上面的父类是：java.lang.Enum,常用方法子类Season可以直接拿过来使用：
11         //toString();--->获取对象的名字
12         Season autumn = Season.AUTUMN;
13         System.out.println(autumn/*.toString()*/);//AUTUMN
14         System.out.println("--------------------");
15         //values:返回枚举类对象的数组
16         Season[] values = Season.values();
17         for(Season s:values){
18             System.out.println(s/*.toString()*/);
19         }
20         System.out.println("--------------------");
21         //valueOf：通过对象名字获取这个枚举对象
22         //注意：对象的名字必须传正确，否则抛出异常
23         Season autumn1 = Season.valueOf("AUTUMN");
24         System.out.println(autumn1);
25     }
26 }

枚举类实现接口

定义一个接口：

1 public interface TestInterface {
2     void show();
3 }

枚举类实现接口，并且重写show方法：

 1 public enum Season implements TestInterface {
 2     SPRING,
 3     SUMMER,
 4     AUTUMN,
 5     WINTER;
 6     @Override
 7     public void show() {
 8         System.out.println("这是Season....");
 9     }
10 }

测试类：

1 public class Test {
2     //这是一个main方法，是程序的入口：
3     public static void main(String[] args) {
4         Season autumn = Season.AUTUMN;
5         autumn.show();
6         Season summer = Season.SUMMER;
7         summer.show();
8     }
9 }

上面发现所有的枚举对象，调用这个show方法的时候走的都是同一个方法，结果都一样：

但是现在我想要：不同的对象调用的show方法也不同：

 1 package com.llh;
 2 
 3 import java.sql.SQLOutput;
 4 
 5 public enum Season implements TestInterface {
 6     SPRING{
 7         @Override
 8         public void show() {
 9             System.out.println("这是春天。。。");
10         }
11     },
12     SUMMER{
13         @Override
14         public void show() {
15             System.out.println("这是夏天。。");
16         }
17     },
18     AUTUMN{
19         @Override
20         public void show() {
21             System.out.println("这是秋天");
22         }
23     },
24     WINTER{
25         @Override
26         public void show() {
27             System.out.println("这是冬天");
28         }
29     };
30     /*@Override
31     public void show() {
32         System.out.println("这是Season....");
33     }*/
34 }

测试类：

1 public class Test {
2     //这是一个main方法，是程序的入口：
3     public static void main(String[] args) {
4         Season autumn = Season.AUTUMN;
5         autumn.show();
6         Season summer = Season.SUMMER;
7         summer.show();
8     }
9 }

实际应用

 1 package com.llh;
 2 
 3 /**
 4  * @author : llh
 5  */
 6 
 7 public class Person {
 8     //属性：
 9     private int age;
10     private String name;
11     private Gender sex;
12     public int getAge() {
13         return age;
14     }
15     public void setAge(int age) {
16         this.age = age;
17     }
18     public String getName() {
19         return name;
20     }
21     public void setName(String name) {
22         this.name = name;
23     }
24     public Gender getSex() {
25         return sex;
26     }
27     public void setSex(Gender sex) {
28         this.sex = sex;
29     }
30     @Override
31     public String toString() {
32         return "Person{" +
33                 "age=" + age +
34                 ", name='" + name + '\'' +
35                 ", sex='" + sex + '\'' +
36                 '}';
37     }
38 }

1 public enum Gender {
2     男,
3     女;
4 }

 1 public class Test {
 2     //这是一个main方法，是程序的入口：
 3     public static void main(String[] args) {
 4         Person p = new Person();
 5         p.setAge(19);
 6         p.setName("lili");
 7         p.setSex(Gender.男);//传入枚举类Gender的对象：-->在入口处对参数进行了限制
 8         System.out.println(p);
 9     }
10 }

还可以通过枚举结合switch处理：

 1 public class Test02 {
 2     //这是一个main方法，是程序的入口：
 3     public static void main(String[] args) {
 4         Gender sex = Gender.男;
 5         //switch后面的（）中可以传入枚举类型
 6         //switch后面的（）:int,short,byte,char,String ,枚举
 7         switch (sex){
 8             case 女:
 9                 System.out.println("是个女孩");
10                 break;
11             case 男:
12                 System.out.println("是个男孩");
13                 break;
14         }
15     }
16 }