0基础学java-day11-(枚举和注解)

一、枚举

1 先看一个需求

0基础学java-day11-(枚举和注解)_第1张图片

package com.hspedu.enum_;

public class Enumeration01 {
    public static void main(String[] args) {
        Season spring = new Season("春天", "温暖");
        Season winter = new Season("冬天", "寒冷");
        Season summer = new Season("夏天", "炎热");
        Season autumn = new Season("秋天", "凉爽");
        autumn.setName("XXX");
        autumn.setDesc("非常的热..");
        //因为对于季节而已,他的对象(具体值),是固定的四个,不会有更多
        //按照老师的这个设计类的思路,不能体现季节是固定的四个对象
        //因此,这样的设计不好===> 枚举类[枚: 一个一个 举: 例举 , 即把具体的对象一个一个例举出来的类
        // 就称为枚举类]
        Season other = new Season("红天", "~~~");

    }
}
class Season{
    private String name;
    private String desc;

    public Season(String name, String desc) {
        this.name = name;
        this.desc = desc;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }
}

2 分析问题

创建 Season 对象有如下特点

  • 季节的值是有限的几个值(spring, summer, autumn, winter)
  • 只读,不需要修改。

3 解决方案-枚举 

  • 枚举对应英文(enumeration, 简写 enum)
  • 枚举是一组常量的集合
  • 可以这里理解:枚举属于一种特殊的类,里面只包含一组有限的特定的对象

4 枚举的二种实现方式 

  •  自定义类实现枚举
  •  使用 enum 关键字实现枚举

5 自定义类实现枚举-应用案例 

0基础学java-day11-(枚举和注解)_第2张图片

package com.hspedu.enum_;

/**
 * @author 林然
 * @version 1.0
 */
public class Enumeration02 {
    public static void main(String[] args) {

    }
}
//演示自定义枚举实现
class Season01{
    private String name;
    private String desc;
    //定义了四个对象, 固定.
    public static final Season SPRING = new Season("春天", "温暖");
    public static final Season WINTER = new Season("冬天", "寒冷");
    public static final Season AUTUMN = new Season("秋天", "凉爽");
    public static final Season SUMMER = new Season("夏天", "炎热");
    //1. 将构造器私有化,目的防止 直接 new
    //2. 去掉 setXxx 方法, 防止属性被修改
    //3. 在 Season 内部,直接创建固定的对象
    private Season01(String name, String desc) {
        this.name = name;
        this.desc = desc;
    }

    public String getName() {
        return name;
    }



    public String getDesc() {
        return desc;
    }

    @Override
    public String toString() {
        return "Season01{" +
                "name='" + name + '\'' +
                ", desc='" + desc + '\'' +
                '}';
    }
}

 6 自定义类实现枚举-小结

进行自定义类实现枚举,有如下特点:

  • 构造器私有化
  • 本类内部创建一组对象[四个 春夏秋冬]
  • 对外暴露对象(通过为对象添加 public final static 修饰符)
  • 可以提供 get 方法,但是不要提供 set

 7 enum 关键字实现枚举-快速入门

7.1  说明 

 使用 enum 来实现前面的枚举案例,看下面演示,主要体会和自定义类实现枚举不同的地方

  • 如果使用了 enum 来实现枚举类
  • 1. 使用关键字 enum 替代 class
  • 2. public static final Season SPRING = new Season("春天", "温暖") 直接使用 SPRING("春天", "温暖") 解读 常量名(实参列表)
  • 3. 如果有多个常量(对象)使用 ,号间隔即可
  • 4. 如果使用 enum 来实现枚举,要求将定义常量对象,写在最前面
  • 5. 如果我们使用的是无参构造器,创建常量对象,则可以省略 ()
package com.hspedu.enum_;

/**
 * @author 林然
 * @version 1.0
 */
public class Enumeration03 {
    public static void main(String[] args) {
        System.out.println(Season02.AUTUMN);
        System.out.println(Season02.SUMMER);
    }
}
//演示使用 enum 关键字来实现枚举类
enum  Season02{
    //4. 如果使用 enum 来实现枚举,要求将定义常量对象,写在前面
    SPRING("春天", "温暖"), WINTER("冬天", "寒冷"),
    AUTUMN("秋天", "凉爽"), SUMMER("夏天", "炎热"),WHAT();//What()可以简写成WHAT
    private String name;
    private String desc;
    //定义了四个对象, 固定.
    // public static final Season SPRING = new Season("春天", "温暖");
//    public static final Season WINTER = new Season("冬天", "寒冷");
//    public static final Season AUTUMN = new Season("秋天", "凉爽");
//    public static final Season SUMMER = new Season("夏天", "炎热");
    //如果使用了 enum 来实现枚举类
//1. 使用关键字 enum 替代 class
//2. public static final Season SPRING = new Season("春天", "温暖") 直接使用
// SPRING("春天", "温暖") 解读 常量名(实参列表)
//3. 如果有多个常量(对象), 使用 ,号间隔即可
//4. 如果使用 enum 来实现枚举,要求将定义常量对象,写在前面
//5. 如果我们使用的是无参构造器,创建常量对象,则可以省略 ()

    private Season02() {
    }

    private Season02(String name, String desc) {
        this.name = name;
        this.desc = desc;
    }

    public String getName() {
        return name;
    }



    public String getDesc() {
        return desc;
    }

    @Override
    public String toString() {
        return "Season01{" +
                "name='" + name + '\'' +
                ", desc='" + desc + '\'' +
                '}';
    }
}

7.2 enum 关键字实现枚举注意事项

  • 当我们使用 enum 关键字开发一个枚举类时,默认会继承 Enum , 而且是一个 final [如何证明],使用 javap 工 具来演示0基础学java-day11-(枚举和注解)_第3张图片
  • 传统的 public static final Season2 SPRING = new Season2("春天", "温暖"); 简化成 SPRING("春天", "温暖"), 这里必 须知道,它调用的是哪个构造器.
  • 如果使用无参构造器 创建 枚举对象,则实参列表和小括号都可以省略
  •  当有多个枚举对象时,使用,间隔,最后有一个分号结尾
  • 枚举对象必须放在枚举类的行首

 8.课堂练习

8.1 作业一

0基础学java-day11-(枚举和注解)_第4张图片

8.2 作业二 

下面代码输出什么? EnumExercise01.java 0基础学java-day11-(枚举和注解)_第5张图片

9 enum 用方法说明 

说明:使用关键字 enum 时,会隐式继承 Enum , 这样我们就可以使用 Enum 相关的方法 

0基础学java-day11-(枚举和注解)_第6张图片

 0基础学java-day11-(枚举和注解)_第7张图片

10 enum 常用方法应用实例 

一起来举例说明 enum 常用的方法的使用,对 Season2 测试
  • toString:Enum 类已经重写过了,返回的是当前对象 名,子类可以重写该方法,用于返回对象的属性信息
  • name:返回当前对象名(常量名),子类中不能重写
  • ordinal:返回当前对象的位置号,默认0 开始
  • values:返回当前枚举类中所有的常量
  • valueOf将字符串转换成枚举对象,要求字符串必须 为已有的常量名,否则报异常!
  • compareTo比较两个枚举常量,比较的就是编号!
    package com.hspedu.enum_;
    
    /**
     * @author 林然
     * @version 1.0
     */
    public class EnumMethod {
        public static void main(String[] args) {
            //使用 Season2 枚举类,来演示各种方法
            Season02 autumn = Season02.AUTUMN;
            //输出枚举对象的名字
            System.out.println(autumn.name());
            //ordinal() 输出的是该枚举对象的次序/编号,从 0 开始编号
            //AUTUMN 枚举对象是第三个,因此输出 2
            System.out.println(autumn.ordinal());
            //从反编译可以看出 values 方法,返回 Season2[]数组
            //含有定义的所有枚举对象
            Season02 [] values =Season02.values();
            System.out.println("===遍历取出枚举对象(增强 for)====");
            for (Season02 season: values) {//增强 for 循环
                System.out.println(season);
            }
            //valueOf:将字符串转换成枚举对象,要求字符串必须
            //为已有的常量名,否则报异常
            //执行流程
            //1. 根据你输入的 "AUTUMN" 到 Season2 的枚举对象去查找
            //2. 如果找到了,就返回,如果没有找到,就报错
            Season02 autumn1 = Season02.valueOf("AUTUMN");
            System.out.println("autumn1="+autumn1);
            //compareTo:比较两个枚举常量,比较的就是编号
            //1. 就是把 Season2.AUTUMN 枚举对象的编号 和 Season2.SUMMER 枚举对象的编号比较
            //2. 看看结果
            /*
                public final int compareTo(E o){
                    return self.ordinal - other.ordinal;
                }
    
             */
            System.out.println(Season02.AUTUMN.compareTo(Season02.SUMMER));
            //补充了一个增强 for
                // int[] nums = {1, 2, 9};
                // //普通的 for 循环
                // System.out.println("=====普通的 for=====");
                // for (int i = 0; i < nums.length; i++) {
                // System.out.println(nums[i]);
                // }
                // System.out.println("=====增强的 for=====");
                // //执行流程是 依次从 nums 数组中取出数据,赋给 i, 如果取出完毕,则退出 for
                // for(int i : nums) {
                // System.out.println("i=" + i);
                // }
        }
    }
    
    

 11. enum 课堂练习

0基础学java-day11-(枚举和注解)_第8张图片

package com.hspedu.enum_;

/**
 * @author 林然
 * @version 1.0
 */
public class EnumExercise02 {
    public static void main(String[] args) {
        Week [] weeks =Week.values();
        System.out.println("===所有星期的信息如下===");
        for(Week week :weeks){
            System.out.println(week.getName());
        }
    }
}
enum Week{
    MONDAY("星期一"),TUESDAY("星期二"), WEDNESDAY("星期三"),
    THURSDAY("星期四"), FRIDAY("星期五"), SATURDAY("星期六"),
    SUNDAY("星期天");
    private String day_name;

    Week(String day_name) {
        this.day_name = day_name;
    }

    public String getName() {
        return day_name;
    }
}

12 enum 使用细节

  •  使用 enum 关键字后,就不能再继承其它类了,因为 enum 会隐式继承 Enum,而 Java 是单继承机制。
  • 枚举类和普通类一样,可以实现接口,如下形式。
  •  enum 类名 implements 接口 1,接口 2{}
package com.hspedu.enum_;

/**
 * @author 林然
 * @version 1.0
 */
public class EnumDetail {
    public static void main(String[] args) {
        Music.CLASSICMUSIC.playing();
    }
}
class A{

}
//1.使用 enum 关键字后,就不能再继承其它类了,因为 enum 会隐式继承 Enum,而 Java 是单继承机制
//enum Season3 extends A {
//
//}
//2.enum 实现的枚举类,仍然是一个类,所以还是可以实现接口的
interface IPlaying {
    public void playing();
}
enum Music implements IPlaying{
    CLASSICMUSIC;

    @Override
    public void playing() {
        System.out.println("播放好听的音乐...");
    }
}

 二、注解

1.注解的理解 

  •  注解(Annotation)也被称为元数据(Metadata),用于修饰解释 包、类、方法、属性、构造器、局部变量等数据信息
  • 和注释一样,注解不影响程序逻辑,但注解可以被编译或运行,相当于嵌入在代码中的补充信息
  • JavaSE 中,注解的使用目的比较简单,例如标记过时的功能,忽略警告等。在 JavaEE 中注解占据了更重要的角 色,例如用来配置应用程序的任何切面,代替 java EE 旧版中所遗留的繁冗代码和 XML 配置等

 2. 基本的 Annotation 介绍

  • 使用 Annotation 时要在其前面增加 @ 符号, 并把该 Annotation 当成一个修饰符使用。用于修饰它支持的程序元 素
  • 三个基本的 Annotation:
  • 1) @Override: 限定某个方法,是重写父类方法, 该注解只能用于方法
  • 2) @Deprecated: 用于表示某个程序元素(, 方法等)已过时
  • 3) @SuppressWarnings: 抑制编译器警告

3.基本的 Annotation 应用案例 

3.1 @Override 注解的案例 

0基础学java-day11-(枚举和注解)_第9张图片

0基础学java-day11-(枚举和注解)_第10张图片

package com.hspedu.annotation_;

/**
 * @author 林然
 * @version 1.0
 */
public class Override_ {
    public static void main(String[] args) {

    }
}
class Father{//父类
    public void fly(){
        System.out.println("Father fly...");
    }
    public void say(){}
}
class Son extends Father {//子类

//1. @Override 注解放在 fly 方法上,表示子类的 fly 方法时重写了父类的 fly
//2. 这里如果没有写 @Override 还是重写了父类 fly
//3. 如果你写了@Override 注解,编译器就会去检查该方法是否真的重写了父类的
// 方法,如果的确重写了,则编译通过,如果没有构成重写,则编译错误
//4. 看看 @Override 的定义
// 解读: 如果发现 @interface 表示一个 注解类
/*
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Override {
}
*/
    @Override //说明
    public void fly() {
        System.out.println("Son fly....");
    }
    @Override
    public void say() {}
}

0基础学java-day11-(枚举和注解)_第11张图片

3.2 @Deprecated 注解的案例 

@Deprecated: 用于表示某个程序元素(, 方法等)已过时 ,但是仍然可以使用

package com.hspedu.annotation_;

/**
 * @author 林然
 * @version 1.0
 */
public class Deprecated_ {
    public static void main(String[] args) {
        A a =new A();
        a.hi();
    }
}
//1. @Deprecated 修饰某个元素, 表示该元素已经过时
//2. 即不在推荐使用,但是仍然可以使用
//3. 查看 @Deprecated 注解类的源码
//4. 可以修饰方法,类,字段, 包, 参数 等等
//5. @Deprecated 可以做版本升级过渡使用
/*
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(value={CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, PARAMETER, TYPE})
public @interface Deprecated {
}
*/
@Deprecated
class A {
    @Deprecated
    public int n1 = 10;
    @Deprecated
    public void hi(){
    }
}

0基础学java-day11-(枚举和注解)_第12张图片

3.3 @SuppressWarnings 注解的案例

@SuppressWarnings: 抑制编译器警告 

package com.hspedu.annotation_;

import java.util.ArrayList;
import java.util.List;

/**
 * @author 林然
 * @version 1.0
 */
@SuppressWarnings({"rawtypes", "unchecked", "unused"})
public class SuppressWarnings_ {
    //1. 当我们不希望看到这些警告的时候,可以使用 SuppressWarnings 注解来抑制警告信息
    //2. 在{""} 中,可以写入你希望抑制(不显示)警告信息
    //3. 可以指定的警告类型有
        // all,抑制所有警告
        // boxing,抑制与封装/拆装作业相关的警告
        // //cast,抑制与强制转型作业相关的警告
        // //dep-ann,抑制与淘汰注释相关的警告
        // //deprecation,抑制与淘汰的相关警告
        // //fallthrough,抑制与 switch 陈述式中遗漏 break 相关的警告
        // //finally,抑制与未传回 finally 区块相关的警告
        // //hiding,抑制与隐藏变数的区域变数相关的警告
        // //incomplete-switch,抑制与 switch 陈述式(enum case)中遗漏项目相关的警告
        // //javadoc,抑制与 javadoc 相关的警告
        // //nls,抑制与非 nls 字串文字相关的警告
        // //null,抑制与空值分析相关的警告
        // //rawtypes,抑制与使用 raw 类型相关的警告
        // //resource,抑制与使用 Closeable 类型的资源相关的警告
        // //restriction,抑制与使用不建议或禁止参照相关的警告
        // //serial,抑制与可序列化的类别遗漏 serialVersionUID 栏位相关的警告
        // //static-access,抑制与静态存取不正确相关的警告
        // //static-method,抑制与可能宣告为 static 的方法相关的警告
        // //super,抑制与置换方法相关但不含 super 呼叫的警告
        // //synthetic-access,抑制与内部类别的存取未最佳化相关的警告
        // //sync-override,抑制因为置换同步方法而遗漏同步化的警告
        // //unchecked,抑制与未检查的作业相关的警告
        // //unqualified-field-access,抑制与栏位存取不合格相关的警告
        // //unused,抑制与未用的程式码及停用的程式码相关的警告
    //4. 关于 SuppressWarnings 作用范围是和你放置的位置相关
    // 比如 @SuppressWarnings 放置在 main 方法,那么抑制警告的范围就是 main
    // 通常我们可以放置具体的语句, 方法, 类
    //5. 看看 @SuppressWarnings 源码
//(1) 放置的位置就是 TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE
//(2) 该注解类有数组 String[] values() 设置一个数组比如 {"rawtypes", "unchecked", "unused"}
    /*
    @Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
    @Retention(RetentionPolicy.SOURCE)
    public @interface SuppressWarnings {
        String[] value();
        }
     */
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("jack");
        list.add("tom");
        list.add("mary");
        int i;
        System.out.println(list.get(1));
    }
}

0基础学java-day11-(枚举和注解)_第13张图片

 4 JDK 的元 Annotation(元注解, 了解)

4.1 元注解的基本介绍 

  • JDK 的元 Annotation 用于修饰其他 Annotation
  • 元注解: 本身作用不大,讲这个原因希望同学们,看源码时,可以知道他是干什么.

 4.2 元注解的种类 (使用不多,了解, 不用深入研究)

  • 1) Retention //指定注解的作用范围,三种 SOURCE,CLASS,RUNTIME
  • 2) Target // 指定注解可以在哪些地方使用
  • 3) Documented //指定该注解是否会在 javadoc 体现
  • 4) Inherited //子类会继承父类注解

4.3 @Retention 注解 

只能用于修饰一个 Annotation 定义 , 用于指定该 Annotation 可以保留多长时间 , @Rentention 包含一个 RetentionPolicy 类型的成员变量, 使用 @Rentention 时必须为该 value 成员变量指定值
@Retention 的三种值
  • 1) RetentionPolicy.SOURCE: 编译器使用后,直接丢弃这种策略的注释
  • 2) RetentionPolicy.CLASS: 编译器将把注解记录在 class 文件中. 当运行 Java 程序时, JVM 不会保留注解。 这是默认值
  • 3) RetentionPolicy.RUNTIME:编译器将把注解记录在 class 文件中. 当运行 Java 程序时, JVM 会保留注解. 程序可以 通过反射获取该注解

0基础学java-day11-(枚举和注解)_第14张图片

 4.4 @Target

0基础学java-day11-(枚举和注解)_第15张图片

0基础学java-day11-(枚举和注解)_第16张图片 4.5 @Documented

0基础学java-day11-(枚举和注解)_第17张图片 0基础学java-day11-(枚举和注解)_第18张图片

4.6 @Inherited 注解 

0基础学java-day11-(枚举和注解)_第19张图片 三、作业

1.作业一 

0基础学java-day11-(枚举和注解)_第20张图片 2.作业二

0基础学java-day11-(枚举和注解)_第21张图片

package com.hspedu.annotation_;

/**
 * @author 林然
 * @version 1.0
 */
public class Homework02 {
    public static void main(String[] args) {

    }
}
class Frock{
    private static int currentNum =100000;//衣服出厂序列号
    private int serialNumber;
    public static int getNextNum(){
        currentNum=currentNum+100;
        return currentNum;
    }

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

    public int getSerialNumber() {
        return serialNumber;
    }

    public void setSerialNumber(int serialNumber) {
        this.serialNumber = serialNumber;
    }
}
class TestFrock{
    public static void main(String[] args) {
        System.out.println(Frock.getNextNum());//100100
        System.out.println(Frock.getNextNum());//100200
        Frock frock1 = new Frock();//100300
        Frock frock2 = new Frock();
        Frock frock3 = new Frock();
        System.out.println(frock1.getSerialNumber());
        System.out.println(frock2.getSerialNumber());
        System.out.println(frock3.getSerialNumber());

    }
}

 3.作业三

0基础学java-day11-(枚举和注解)_第22张图片

package com.hspedu.annotation_;

/**
 * @author 林然
 * @version 1.0
 */
public class Homework03 {
    public static void main(String[] args) {
        Animal cat =new Cat();
        cat.shout();
        Animal dog =new Dog();
        dog.shout();
    }
}
abstract class Animal{
    abstract void shout();
}
class Cat extends Animal{
    @Override
    void shout() {
        System.out.println("猫会喵喵叫");
    }
}
class Dog extends Animal{
    @Override
    void shout() {
        System.out.println("狗会汪汪叫");
    }
}

 4.作业四

0基础学java-day11-(枚举和注解)_第23张图片

package com.hspedu.annotation_;

/**
 * @author 林然
 * @version 1.0
 */
public class Homework04 {
    public static void main(String[] args) {
        Cellphone cellphone =new Cellphone();
        cellphone.testwork(new ICalculate() {
            @Override
            public double work(double n1, double n2) {
                return n1+n2;
            }
        },10,29);
    }
}
interface ICalculate{
    //work方法是完成计算,但是题目没有具体要求
    //方法具体完善交给匿名内部类
    double work(double n1,double n2);
}
class Cellphone{
    public void testwork(ICalculate iCalculate,double n1,double n2){

        System.out.println("计算的结果是"+iCalculate.work(n1,n2));
    }
}

5. 作业五

0基础学java-day11-(枚举和注解)_第24张图片

package com.hspedu.annotation_;

/**
 * @author 林然
 * @version 1.0
 */
public class Homework05 {
    public static void main(String[] args) {
        AA aa =new AA("aa");
        aa.f1();
    }

}
class AA{
    private String name;

    public AA(String name) {
        this.name = name;
    }

    public void f1(){
        class B{
            private  final String name="BB";
            void show(){
                System.out.println("局部内部类的name"+name+"外部类的name"+AA.this.name);
            }

        }
        B bb =new B();
        bb.show();
    }
}

 6.作业六

0基础学java-day11-(枚举和注解)_第25张图片

package com.hspedu.annotation_;

/**
 * @author 林然
 * @version 1.0
 */
public class Homework06 {
    public static void main(String[] args) {
        Person p1 =new Person("唐僧",new Horse());
        p1.common();//一般情况
        p1.passRiver();//过河

    }
}
interface Vehivles{
    void work();
}
class Horse implements Vehivles{

    @Override
    public void work() {
        System.out.println("Horse工作");
    }
}
class Boat implements Vehivles{
    @Override
    public void work() {
        System.out.println("Boat工作");
    }
}
class VehiclesFactory{
    //创建交通工具类,有两个方法分别获得交通工具Horse和Boat
    //马始终是同一个
    private static Horse horse=new Horse();//饿汉式
    public static Horse getHorse(){
        //return new Horse();
        return horse;
    }
    public static Boat getBoat(){
        return new Boat();
    }

    private VehiclesFactory() {
    }
}
class Person{
    private String name;
    private Vehivles vehivles;
    //在创建人对象时,事先给他一个交通工具
    public Person(String name, Vehivles vehivles) {
        this.name = name;
        this.vehivles = vehivles;
    }
    //可以把具体要求封装成方法
    //如何不浪费,在构建对象时,传入的交通工具对象
    //如何防止始终使用的是传入的马对象 instanceof
    public void passRiver(){
//        if (vehivles==null){
            //这里使用的是多态
        if (!(vehivles instanceof Boat)){
            vehivles =VehiclesFactory.getBoat();
        }

        vehivles.work();
    }
    public void common(){
        //得到马儿
        //判断vehicles属性是否已经存在
        //
        if (!(vehivles instanceof Horse)){
            //这里使用的是多态
            vehivles =VehiclesFactory.getHorse();
        }

        vehivles.work();
    }
}

 7.作业七

0基础学java-day11-(枚举和注解)_第26张图片

package com.hspedu.annotation_;

/**
 * @author 林然
 * @version 1.0
 */
public class Homework7 {
    public static void main(String[] args) {
        Car car1=new Car(34);
        car1.f();
        Car car2=new Car(43);
        car2.f();
        Car car3=new Car(-1);
        car3.f();
    }
}
class Car{
    private double temperature;
    class Air{
        public void flow(){
            if(temperature>40)
            {
                System.out.println("吹冷气");
            }
            else if(temperature>=0)
            {
                System.out.println("关闭空调");
            }
            else {
                System.out.println("吹暖气");
            }
        }
    }

    public Car(double temperature) {
        this.temperature = temperature;
    }
    public void f(){
        new Air().flow();
    }
}

 8.作业八

0基础学java-day11-(枚举和注解)_第27张图片

package com.hspedu.annotation_;

/**
 * @author 林然
 * @version 1.0
 */
public class Homework8 {
    public static void main(String[] args) {
        Color green = Color.GREEN;
        green.show();
        //在switch中放入枚举对象
        switch (green){
            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("颜色错误");break;
        }
    }
}
enum Color implements IColor{
    RED(255,0,0),BLUE(0,0,255),
    BLACK(0,0,0),YELLOW(255,255,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("属性值为:"+redValue+","+greenValue+","+blueValue);
    }
}
interface IColor{
    void show();
}

你可能感兴趣的:(韩顺平0基础学java,java,开发语言)