Java 枚举和注解详解 11章

第十一章

枚举 和 注解

11.1 枚举

11.1.1枚举介绍

1、枚举对应的英文（enumeration），简称（enum）

2、枚举是一组常量的集合

3、可以理解成：枚举属于一种特殊的类，里面只包含一组有限的特定对象

11.1.2枚举的实现方式

1、自定义类实现枚举

//1、直接将构造器定义成私有的，因为是要防止对象被程序员去创建
//2、要去掉setXXX方法，防止被修改，因为枚举类的对象属性等成员是固定的，不能被修改
//3、在类的内部去创建所需要的固定对象,因为要保证外面类能用，所以用public去修饰
//4、用 final static 去修饰，为了确保，外部类能够直接使用static，已经防止属性被加载用final
//5、枚举对象的对象名通常使用全英文大写，因为常量的规范名
//6、枚举对象根据需要，可以有多个属性

案例：创建一个season（季节）类对象

package com.xiaowang.enum_;
/*演示自定义枚举类*/
public class Enumeration01 {
    public static void main(String[] args) {
        System.out.println(Season.SPRING);
    }
}
class Season{
    private String name;
    private String desc;
    //创建四个固定对象
    public final static Season SPRING = new Season("春天","温暖");
    public final static Season SUMMER = new Season("夏天","温暖");
    public final static Season AUTUMN = new Season("秋天","温暖");
    public final static Season WINTER = new Season("冬天","温暖");

    //1、直接将构造器定义成私有的，因为是要防止对象被程序员去创建
    //2、要去掉setXXX方法，防止被修改，因为枚举类的对象属性等成员是固定的，不能被修改
    //3、在类的内部去创建所需要的固定对象,因为要保证外面类能用，所以用public去修饰
    //4、用 final static 去修饰，为了确保，外部类能够直接使用static，已经防止属性被加载用final
    private Season(String name, String desc) {
        this.name = name;
        this.desc = desc;
    }
    public String getName() {
        return name;
    }
    public String getDesc() {
        return desc;
    }
    @Override
    public String toString() {//写一个toString方法去显示对象属性，更直观
        return "Season{" +
                "name='" + name + '\'' +
                ", desc='" + desc + '\'' +
                '}';
    }
}
输出：
Season{name='春天', desc='温暖'}

小结：自定义类实现枚举的特点
1、构造器私有化
2、本类内部创建一组对象（案例中是四个，也可以多个）
3、对外暴露对象（用 public final static 去修饰）
4、可以提供get（）方法去获取信息，但是不能有set（）方法去修改

2、enum关键字实现枚举

//1、直接将构造器定义成私有的，因为是要防止对象被程序员去创建
//2、要去掉setXXX方法，防止被修改，因为枚举类的对象属性等成员是固定的，不能被修改
//3、创建常量对象直接用 ：常量对象名（实参列表）
//5、枚举对象的对象名通常使用全英文大写，因为常量的规范名
//6、枚举对象根据需要，可以有多个属性
//7、所创建的常量对象，要放在类的第一行

案例：创建一个season（季节）类对象

package com.xiaowang.enum_;
/**
 * @Author 小王
 * @DATE: 2022/3/11
 */
public class Enumeration02 {
    public static void main(String[] args) {
        System.out.println(Season.SPRING);
    }
}
enum Season2{
    //演示enum关键字实现枚举类
    //1、用关键字 enum 替换 class ,构造器、方法等不用改变
    //2、创建对象的时候，可以直接用 对象名（实参列表）去替换自定义枚举类的创建方法，这里就是：
    //    SPRING("春天","温暖") 去替换 public final static Season SPRING = new Season("春天","温暖");
    //3、如果要创建多个常量对象用 ,号 去隔开
    //4、如果要使用enum关键字来实现枚举类，那么，创建的常量对象要写在最前面
    SPRING("春天","温暖"),SUMMER("夏天","温暖"),AUTUMN("秋天","温暖"),WINTER("冬天","温暖");
    private String name;
    private String desc;
    private Season2(String name, String desc) {
        this.name = name;
        this.desc = desc;
    }

    public String getName() {
        return name;
    }
    public String getDesc() {
        return desc;
    }

    @Override
    public String toString() {//写一个toString方法去显示对象属性，更直观
        return "Season{" +
                "name='" + name + '\'' +
                ", desc='" + desc + '\'' +
                '}';
    }
}
输出：
Season{name='春天', desc='温暖'}

小结：enum关键字实现枚举的特点

1、当外面使用enum 关键字开发一个枚举类时，默认会 继承 Enum类，而且是一个final类，可以用 javap 去反编译查看

2、传统的 public static final Season SPRING = new Season(“春天”, “温暖”); 简化成 SPRING(“春天”, “温暖”), 这里必须要知道，对象时调用哪个构造器，主要通过所传入的实参列表来确定。

=============

3、如果使用无参构造器去创建常量对象，则可以省略 （实参列表） 包括括号可以省略

4、当有多个枚举对象时，使用 , 间隔，最后有一个分号结尾

5、用enum关键字来实现的时候，枚举对象必须放在枚举类的行首

11.1.3枚举练习

A01:判断下面代码是否有错：

enum Gender{
BOU,GIRL;
}

答：没有错；
① Gender 类是用 enum 关键字去实现的 Gender 枚举类；
②BOY , GIRL调用的是枚举类的无参构造器，这个构造器是默认的，因为类中没有其他的构造器去覆盖默认的无参构造器
③要是类中有其他构造器，要想使之这语法没错，就得再显性的说明一下无参构造器

A02判断以下代码的输出：

public class Enumeration03 {
    public static void main(String[] args) {
        Gender boy = Gender.BOY;
        Gender boy2 = Gender.BOY;
        System.out.println(boy);
        System.out.println(boy == boy2);
    }
}
enum Gender{
    BOY,GIRL;
}
输出：
BOY
true

输出部分代码分析：

        System.out.println(boy);
   /*  这里是要调用自己的toString方法，但是Gender类没有这个方法
       所以就去调用父类Enum类的toString方法，结构如下：
        public String toString(){
            return name();
        }
        所以就输出对象名 BOY 呗*/
        System.out.println(boy == boy2);
        //因为枚举类是final static 去修饰的，那么不同被赋值的对象的实质还是同一个对象，所以返回True

11.1.4 enum常用方法说明

1、使用关键字 enum时，会隐式的继承Enum类，所以我们可以使用Enum类相关的方法

①、name（）方法 {返回当前对象名（常量名），子类中不能重写}
②、ordinal（）方法 {返回当前对象所在的位置，从0开始编号}
③、value（）方法 {主要就是去存放所有的枚举对象，可以用for循环去查看}
④、valueOf（）方法 {将字符串转换成枚举对象，要求字符串必须是枚举对象中已经有的常量名，否则会报错}
⑤、compareTo（）方法 {比较两个枚举常量，比较的就是value（）得到的那个编号}

package com.xiaowang.enum_;

/**
 * @Author 小王
 * @DATE: 2022/3/11
 */
public class EnumMethod {
    public static void main(String[] args) {
        Season2 autumn = Season2.AUTUMN;
        //用Season2来演示
        //1、name() 返回当前对象名（常量名），子类中不能重写
        System.out.println(autumn.name());
        //2、ordinal() 返回当前对象所在的位置，从0开始编号
        System.out.println(autumn.ordinal());
        //3、values方法，从javap反编译的类中可以看出来，是有这个方法的
        //   主要就是去存放所有的枚举对象，可以用for循环去查看
        Season2[] values = Season2.values();
        System.out.println("=======普通for方法查看==========");
        for (int i = 0; i < values.length ; i++) {
            System.out.println(i);
        }
        System.out.println("=======增强for方法查看==========");
        //增强for循环方法，是将常量对象去赋值给输出对象
        //这里是：将values所存放的对象，依次去赋值给season2，然后输出，输出玩即退出循环
        for (Season2 season2: values){
            System.out.println(season2);
        }
        //4、valueOf：将字符串转换成枚举对象，要求字符串必须是枚举对象中已经有的常量名，否则会报错
        //执行流程：
        //1、根据你所输入的字符串去枚举对象中查找
        //2、如果找到了，就返回，否则就报错
        Season2 spring = Season2.valueOf("SPRING");
        System.out.println("spring = "+spring);
        //5、compareTo：比较两个枚举常量，比较的就是value（）得到的那个编号
        //就是把自己的 编号 和传入对象的编号进行比较
        //这里就是 Season2.AUTUMN编号  和  Season2.SUMMER编号进行比较
        //compareTo的关键实现代码是：
        /*public final int compareTo(E o) {
        下面就是：Season2.AUTUMN 编号（2） - Season2.SUMMER 编号（1），所以输出：1
        return self.ordinal - other.ordinal;
    }*/
        System.out.println(Season2.AUTUMN.compareTo(Season2.SUMMER));
    }
}
输出：
AUTUMN
2
=======普通for方法查看==========
0
1
2
3
=======增强for方法查看==========
Season{name='春天', desc='温暖'}
Season{name='夏天', desc='炎热'}
Season{name='秋天', desc='凉爽'}
Season{name='冬天', desc='寒冷'}
spring = Season{name='春天', desc='温暖'}
1

11.1.5 enum练习题

A01：
①声明Week枚举类，其中包含星期一至星期日的定义，MONDAY、TUESDAY、WEDNESDAY、THURSDAY、FRIDAY、SATURDAY、SUNDAY；
②使用values 返回所有的枚举数组，并遍历，输出以下效果图

package com.xiaowang.enum_;

/**
 * @Author 小王
 * @DATE: 2022/3/11
 */
public class EnumText {
    public static void main(String[] args) {
        Week[] weeks = Week.values();
        System.out.println("===所有星期的信息如下==");
        for (int i = 0; i < weeks.length ; i++) {
            System.out.println(weeks[i]);
        }
    }
}
enum Week{
    MONDAY("星期一"),TUESDAY("星期二"),WEDNESDAY("星期三"),
    THURSDAY("星期四"),FRIDAY("星期五"),SATURDAY("星期六"),SUNDAY("星期日");
    private String days;
    Week(String days) {
        this.days = days;
    }

    @Override
    public String toString() {
        return  days ;
    }
}
输出：
===所有星期的信息如下==
星期一
星期二
星期三
星期四
星期五
星期六
星期日

11.1.6 enum实现接口

1、使用enum关键字后，就不能再继承其他类了，因为enum会隐式继承Enum。而且Java是单继承机制的

2、枚举类和普通类一样，可以实现接口，形式：
enum 类名 implements 接口1，接口2{ }

11.2注解

11.2.1 注解介绍

注解理解：
1、注解（Annotation）也被称为元数据（Metadata），用于修饰解释 包、类、方法、属性、构造器、局部变量等数据信息

2、和注释一样，注解不影响程序逻辑，但是注解可以被编译或运行，相当于嵌再代码中的补充信息

3、在JavaSE中，注解的使用目的比较简单，例如标记过时的功能，忽略警告等。在JavaEE中注解占据了更重要的校色，例如用来配置应用程序的任何切面，代替Java EE旧版中所遗留的繁冗代码和XML配置。

基本的 Annotation 介绍：
在使用Annotation时要在其前面加上 @ 符号，并把该Annotation 当成一个修饰符使用，用于修饰它支持的程序元素

三个基本的Annotation：
① @Override：限定某个方法，是重写父类方法，该注解只能用于方法
② @Deprecated：用于表示某个程序元素（类、方法）已经过时
③ @SuppressWarnings：抑制编译器警告

11.2.2 Override注解

package com.xiaowang.annotat_;

/**
 * @Author 小王
 * @DATE: 2022/3/12
 */
public class Override_ {
    public static void main(String[] args) {
        
    }
}
class Father{
    public void cry(){
        System.out.println("你是猪？？");
    }
}
class Son extends Father{
    @Override//表示重写了父类的cry方法，写了@Override就代表重写了父类的方法，编译器会去校验是否是重写
    public void cry() {
        System.out.println("你才是猪..");
    }
    @Override//编译器到这里的时候检查到父类并没有此方法，所以就会报错
    public void hi(){}//false
}

注意：
写了@Override就代表重写了父类的方法，编译器会去校验是否是重写，如果发现并不是重写，那么编译器就会报错

追进去@Override 看看具体是什么：

补充说明：
@interface 不是指这个是一个 interface 接口，而是一个注解类，是在jdk5.0过后才加入的

Override 使用说明：
1、@Override 表示指定重写父类的方法（可以从编译层面去验证），如果父类没有此方法，则会报错

2、如果不写 @Override 注解，但是子类中还是有父类的方法，那么仍然构成重写

3、@Override 只能修饰方法，不能修饰其他类、包、属性等

4、查看@Override 注解源码为：
说明只能修饰方法

5、@Target 是修饰注解的注解，称为元注解

11.2.3 Deprecated 注解

@Deprecated 用于表示某个程序元素（类、方法）已过时

package com.xiaowang.annotat_;
/**
 * @Author 小王
 * @DATE: 2022/3/14
 */
public class Deprecated_ {
    public static void main(String[] args) {
        A a = new A();
        a.cry();//方法、属性、类有中划线就代表被@Deprecated修饰，表示已经过时了，
        System.out.println(a.sum);
    }
}
//1、@Deprecated修饰某个元素代表过时
//2、过时了，但是不代表不能被使用，只是不推荐再使用
@Deprecated
class A{
    @Deprecated
    public int sum = 10;
    @Deprecated
    public void cry(){
    }
}

@Dprecated 说明：
1、用于表示某个程序元素（类、方法等）已过时

2、可以修饰：方法、类、包、字段、参数 等等

3、可以修饰以下：

@Target(value={CONSTRUCTOR, FIELD, LOCAL_VARIABLE, 
METHOD, PACKAGE, PARAMETER, TYPE})

4、@Deprecated 的作用可以做到新旧版本的兼容和过渡

11.2.4 SuppressWarnings 注解

@SuppressWarnings ：抑制编译器警告（就是代码中黄色警告）

package com.xiaowang.annotat_;

import java.util.ArrayList;

/**
 * @Author 小王
 * @DATE: 2022/3/14
 */
//1、当不想看到这些警告的时候，可以使用 @SuppressWarnings 注解来抑制警告信息
//2、在{" "}中，可以写入你希望抑制（不显示）的警告信息
//3、@SuppressWarnings的使用范围，和你防止的位置相关的
//  例如：如果@SuppressWarnings只写在main方法，那么就只能抑制main方法中的，具体抑制看{"内容"}
//       在其他方法中就不能被抑制，如果要全部抑制，可以直接方法类上
@SuppressWarnings({" "})//具体见以下列表
public class SuppressWarnings_ {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add("jack");
        arrayList.add("jack");
        arrayList.add("jack");
        int i;
    }
}

可以存放的关键字及其用途：

SuppressWarnings源码：

@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.SOURCE)
public @interface SuppressWarnings {
    String[] value();
}

从SuppressWarnings 源码中可以看到：

1、可以放置的位置有：
TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE

2、该注解类有数组 String[] value()，说明可以设置一个数组，比如：
@SuppressWarnings({“rawtypres”,“unchecked”,“unused”})

11.2.5 JDK的元 Annotation（元注解）

元注解基本介绍：
JDK 的 元注解Annotation 用于修饰其他 Annotation

元注解：本身的作用不大，但是可以让人们在看源码的时候，知道是干嘛的

元注解的种类：
① Retention 指定注解的作用范围，三种：SOURCE、CLASS、RUNTIME
② Target 指定注解可以在哪些地方使用
③ Documented 指定该注解是否惠再 javadoc 中体现
④ Inherited 子类会继承父类注解

11.2.5.1 Retention注解

说明：
只能用于修饰一个 Annotation 定义，用于指定该 Annotation 可以保留多长时间，
@Retention 包含一个 RetentionPolicy 类型成员，只用 @Retention
时必须为该 value 成员变量指定值。

@Retention三种值：

11.2.5.2 Target 注解

说明：
用于修饰Annotation定义，用于指定被修饰的 Annotation 能用于哪些程序元素，@Target 也包含一个名为 value 的成员变量

例如：

11.2.5.3 Documented 注解

说明：
@Documented 用于 指定被该 元Annotation 修饰的 Annotation 类 将被 javadoc 工具提取成文档，也就是在生成文档的时候，在文档中可以看到该注解

注：
定义为Documented的注解，必须设置 Retention的值为 RUNTIME (主要是要被保留在文档中嘛)

11.2.5.4 Inherited 注解

说明：
被 @Inherited修饰的 Annotation 将具有继承性，也就是，如果某一个类使用了被 @ Inherited修饰的 Annotation ，则这个类的子类也将自动具有该注解

11.3练习题

A01：

package com.xiaowang.homework_;

/**
 * @Author 小王
 * @DATE: 2022/3/14
 */
public class Homework01 {
    public static void main(String[] args) {
        System.out.println(Frock.getNextNum());
        System.out.println(Frock.getNextNum());
        Frock frock = new Frock();
        Frock frock1 = new Frock();
        Frock frock2 = new Frock();
        System.out.println(frock.getSerialNumber());
        System.out.println(frock1.getSerialNumber());
        System.out.println(frock2.getSerialNumber());
    }
}
class Frock{
    private static int currentNum = 100000;
    private int serialNumber;

    public Frock() {
        serialNumber = getNextNum()
        ;
    }

    public  static int getNextNum(){
        currentNum += 100;
        return currentNum;
    }
    public int getSerialNumber() {
        return serialNumber;
    }
}
输出：
100100
100200
100300
100400
100500

A02：

package com.xiaowang.homework_;

/**
 * @Author 小王
 * @DATE: 2022/3/14
 */
public class Homework02 {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.shout();
        Dog dog = new Dog();
        dog.shout();
    }
}
abstract class Animal{
    public abstract void shout();
}
class Cat extends Animal{
    @Override
    public void shout() {
        System.out.println("猫会喵喵叫");
    }
}
class Dog extends Animal{
    @Override
    public void shout() {
        System.out.println("狗会汪汪叫");
    }
}
输出：
猫会喵喵叫
狗会汪汪叫

注意：抽象类的方法是没有方法体的；既然一个类有抽象方法，那么类也是抽象类；一个类继承一个抽象类，那么抽象类的抽象方法必须要实现

A03：

package com.xiaowang.homework_;

import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;

/**
 * @Author 小王
 * @DATE: 2022/3/14
 */
public class homework03 {
    public static void main(String[] args) {
        Cellphone cellphone = new Cellphone();
        cellphone.testWork(new Computer() {//匿名内部类作参数传递
            //编译类型：Computer 这个接口。运行类型就是 匿名内部类
            @Override
            public double work(double n1, double n2) {
                return n1 + n2;//计算方法是可以修改的
            }
        },5,2);

    }
}
class Cellphone{
    //当我们调用testwork方法时，直接传入一个实现了Computer接口的匿名内部类即可

    public void testWork(Computer computer,double n1,double n2){
        double result = computer.work(n1,n2) ;
        System.out.println("运算结果="+result);
    }
}
interface Computer{
    //题目没有具体要求方法，那么我们可以自己去写
    double work(double n1,double n2);
}
输出：
运算结果=7.0

A04：

package com.xiaowang.homework_;

/**
 * @Author 小王
 * @DATE: 2022/3/15
 */
public class Homework04 {
    public static void main(String[] args) {
        A a = new A();
        a.cry();
    }
}
class A{
    private final String NAME = "外部类江仔";
    public void cry(){
        class B{//局部内部类
            private final String NAME = "内部类江仔 ";
            public void show(){
                System.out.println("NAME = "+NAME);
                //同名时，访问外部类的成员用：外部类名.this.成员名
                System.out.println("NAME = "+A.this.NAME);
            }
        }
        B b = new B();//调用局部内部类必须在内部类所在方法中的外部类上去创建对象然后再使用
        b.show();
    }
}
输出：
NAME = 内部类江仔 
NAME = 外部类江仔

A05： 题：
1．有一个交通具接口类 Vehicles ，有 work 接口
2．有 Horse 类和 Boat 类分别实现 VehicLes
3．创建交通工具工厂类，有两个方法分别获得交通工具 Horse 和 Boat
4。有 Person 类，有 name 和 VehicLes 属性，在构造器中为两个属性赋值
5．实例化 Person 对象“唐僧”，要求一般情况下用 Horse 作为交通工具，遇到大河时用 Boat 作为交通工具
6．增加一个情况，如果唐僧过火焰山，使用飞机＝>程序扩展性

package com.xiaowang.homework_;

import org.omg.CORBA.PUBLIC_MEMBER;
import sun.security.mscapi.CPublicKey;

/**
 * @Author 小王
 * @DATE: 2022/3/15
 */
public class Homework05 {
    public static void main(String[] args) {
        Person tang = new Person("唐僧", new Horse());
        tang.passRiver();
        tang.passRoad();
        tang.passMountain();
    }
}
class Person{
    private String name;
    private Vehicles vehicles ;
    //构造器
    public Person(String name,Vehicles vehicles){
        this.name = name;
        this.vehicles=vehicles;
    }
    //创建两个交通工具的方法,因为不同情况下有不同的过河方式
    //因为再实例化对象的时候，已经设置了方式，所以我们得去判断一下
    public void passRiver(){//当过河的时候
        //防止始终使用的是传入的交通工具
       // if (vehicles instanceof Boat)  改成 if (!(vehicles instanceof Boat))
        //(1).vehicles = null ：vehicles instanceof Boat ==>false
        //(2).vehicles = 骑马 ：vehicles instanceof Boat ==>false
        //(3).vehicles = 乘船 ：vehicles instanceof Boat ==>true
        if (!(vehicles instanceof Boat)) {//当设置的交通工具是乘船的时候
            this.vehicles = ToolFactory.getVehicles1();//返回一个船对象去赋值给 vehicles
        }
        vehicles.work();//此时的vehicles已经是 Boat 对象了，所以调用 Boat的work方法
    }
    public void passRoad(){//走正常情况下时
        if (!(vehicles instanceof Horse)) {
            this.vehicles = ToolFactory.getVehicles();
        }
        vehicles.work();//动态绑定
    }

    public void passMountain(){//过火焰山时
        if (!(vehicles instanceof Plant)) {
            this.vehicles = ToolFactory.getVehicles2();
        }
        vehicles.work();//动态绑定
    }
}
class ToolFactory{//方便不用创建对象就是用方法，所以直接将其方法设置为静态的
    //整个过程中，如果马骑的始终是同一匹，而在过河的时候，是不同的船情况：
    public static Horse horse = new Horse();//通过饿汉式直接将马定
    private ToolFactory(){ }//私有化构造器，防止程序员去new一个马对象
    public static Horse getVehicles(){
       // return new Horse();//直接返回交通工具的对象
        return horse;//同一匹马，
    }
    public static Boat getVehicles1(){
        return new Boat();
    }
    public static Plant getVehicles2(){
        return new Plant();
    }
}
interface Vehicles{
    void work();
}
class Horse implements Vehicles{

    @Override
    public void work() {
        System.out.println("骑马...");
    }
}
class Boat implements Vehicles{

    @Override
    public void work() {
        System.out.println("过河，所以要乘船...");
    }
}
class Plant implements Vehicles{

    @Override
    public void work() {
        System.out.println("过火焰山，所以坐飞机...");
    }
}
输出：
过河，所以要乘船...
骑马...
过火焰山，所以坐飞机...

A06：题：
内部类练习
有一个 Car 类，有属性 temperature （温度），车内有 Air （空调）类，有吹风的功能 flow , Air 会监视车内的温度，如果温度超过40度则吹冷气。如果温度低于0度则吹暖气，如果在这之间则关掉空调。实例化具有不同温度的 Car 对象，调用空调的 flow 方法，测试空调吹的风是否正确

解法一：匿名局部内部类实现：

package com.xiaowang.homework_;

/**
 * @Author 小王
 * @DATE: 2022/3/15
 */
public class Homework06 {
    public static void main(String[] args) {
        new Car(5).monitor();
        new Car(-2).monitor();
        new Car(55).monitor();
    }
}
/*内部类练习
有一个 Car 类，有属性 temperature （温度），车内有 Air （空调）类，有吹风的功能 flow ,
 Air 会监视车内的温度，如果温度超过40度则吹冷气。如果温度低于0度则吹暖气，如果在这之间则关掉空调。
 实例化具有不同温度的 Car 对象，调用空调的 flow 方法，测试空调吹的风是正确
 */
class Car{
    private double temperature;
    public Car(double temperature){
        this.temperature=temperature;
    }
    public  void monitor(){
        class Air{
            public void flow(){
                if (temperature<0){
                    System.out.println("温度小于0度，吹暖风");
                }else if (temperature>40){
                    System.out.println("温度高于40度，吹冷风");
                }else {
                    System.out.println("温度处于0-40之间，关闭空调");
                }
            }
        }
        Air air = new Air();
        air.flow();

    }
}
输出：
温度处于0-40之间，关闭空调
温度小于0度，吹暖风
温度高于40度，吹冷风

解法2：成员内部类

package com.xiaowang.homework_;

/**
 * @Author 小王
 * @DATE: 2022/3/15
 */
public class Homework06 {
    public static void main(String[] args) {
        new Car(5).cry();
        new Car(-2).cry();
        new Car(55).cry();
    }
}
/*内部类练习(局部内部类)
有一个 Car 类，有属性 temperature （温度），车内有 Air （空调）类，有吹风的功能 flow ,
 Air 会监视车内的温度，如果温度超过40度则吹冷气。如果温度低于0度则吹暖气，如果在这之间则关掉空调。
 实例化具有不同温度的 Car 对象，调用空调的 flow 方法，测试空调吹的风是正确
 */
class Car{
    private double temperature;
    //构造器
    public Car(double temperature) {
        this.temperature = temperature;
    }
    class Air{
        public void flow(){
            if (temperature<=0){
                System.out.println("温度小于0度，吹暖风");
            }else if (temperature>=40){
                System.out.println("温度高于40度，吹冷风");
            }else {
                System.out.println("温度处于0-40之间，关闭空调");
            }
        }
    }
    public void cry(){
        Air air = new Air();
        air.flow();
    }
}
输出：
温度处于0-40之间，关闭空调
温度小于0度，吹暖风
温度高于40度，吹冷风

A07：

package com.xiaowang.homework_;

import org.omg.CORBA.PRIVATE_MEMBER;

/**
 * @Author 小王
 * @DATE: 2022/3/15
 */
public class Homework07 {
    public static void main(String[] args) {
        Color color = Color.RED;
        color.show();
        //switch方法中，switch（）中写枚举对象
        //case 后面 写 常量值
        switch (color){
            case RED:
                System.out.println("匹配到：红色");
                break;
            case BLUE:
                System.out.println("匹配到：蓝色");
                break;
            case BLACK:
                System.out.println("匹配到：黑色");
                break;
            case GREEN:
                System.out.println("匹配到：绿色");
                break;
            case YELLOW:
                System.out.println("匹配到：黄色");
                break;
            default:
                System.out.println("没有匹配到");
        }
    }
}
enum Color implements IColor{
    RED(255,0,0),BLUE(0,0,255),
    YELLOW(255,255,0),BLACK(0,0,0),
    GREEN(0,255,0);
    private int redValue;
    private int greenValue;
    private int blueValue;

    Color(int redValue, int greenValue, int blueValue) {
        this.redValue = redValue;
        this.greenValue = greenValue;
        this.blueValue = blueValue;
    }

    @Override
    public void show() {
        System.out.println("三个属性值：\t"+"redValue = "+redValue+" greenValue = "
                +greenValue+" blueValue"+blueValue);
    }
}
interface IColor{
    void show();
}
输出：
三个属性值：	redValue = 255 greenValue = 0 blueValue0
匹配到：红色

枚举和注解篇幅就在这结束了吖，这是整个Java学习中的第十一章哦，觉得还不错的可以查看我完整的Java笔记哦：
Java学习第二阶段（仍然在继续更新中~~~~）

Java学习第一阶段