java学习笔记(11) 第11 章 - 枚举和注解

最新推荐文章于 2023-02-22 09:39:05 发布
最新推荐文章于 2023-02-22 09:39:05 发布
阅读量933 收藏 7
点赞数 2
分类专栏： java 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_50736744/article/details/121538972
版权

枚举和注解

11.1先看一个需求

要求创建季节(Season) 对象，请设计并完成。

如下代码设计有个问题。因为对于季节而已，他的对象(具体值)，是固定的四个，不会有更多。按下边的这个设计类的思路，不能体现季节是固定的四个对象。因此，这样的设计不好，引出枚举===> 枚举类[枚: 一个一个 举： 例举 , 即把具体的对象一个一个例举出来的类 就称为枚举类]

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

11.2 分析问题

  1. 创建Season 对象有如下特点
    (1) 季节的值是有限的几个值(spring, summer, autumn, winter)
    (2) 只读，不需要修改。
  2. 解决方案-枚举
    (1) 枚举对应英文(enumeration, 简写enum)
    (2) 枚举是一组常量的集合。
    (3) 可以这里理解：枚举属于一种特殊的类，里面只包含一组有限的特定的对象。
  3. 枚举的二种实现方式
    (1) 自定义类实现枚举
    (2) 使用enum 关键字实现枚举

11.3 自定义类实现枚举

  1. 不需要提供setXxx方法，因为枚举对象值通常为只读.
  2. 对枚举对象/属性使用final + static共同修饰，实现底层优化.
  3. 枚举对象名通常使用全部大写，常量的命名规范.
  4. 枚举对象根据需要,也可以有多个属性//Enumeration02.java

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

    小结：进行自定义类实现枚举，有如下特点：
    (1) 构造器私有化
    (2) 本类内部创建一组对象[四个春夏秋冬]
    (3) 对外暴露对象（通过为对象添加public final static 修饰符）
    (4) 可以提供get 方法，但是不要提供set

public class Enumeration02 {
    public static void main(String[] args) {
        System.out.println(Season.AUTUMN);
        System.out.println(Season.SPRING);
    }
}

//演示字定义枚举实现
class Season {//类
    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 内部，直接创建固定的对象
    //4. 优化，可以加入 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() {
        return "Season{" +
                "name='" + name + '\'' +
                ", desc='" + desc + '\'' +
                '}';
   }
}

11.4 enum 关键字实现枚举-快速入门、课堂练习

说明:使用enum 来实现前面的枚举案例，看代码演示，主要体会和自定义类实现枚举不同的地方。

  • enum 关键字实现枚举注意事项
  1. 当我们使用enum 关键字开发一个枚举类时，默认会继承Enum 类, 而且是一个final 类[如何证明],使用javap 工具来演示
  2. 传统的public static final Season2 SPRING = new Season2(“春天”, “温暖”); 简化成SPRING(“春天”, “温暖”)， 这里必须知道，它调用的是哪个构造器.
  3. 如果使用无参构造器创建枚举对象，则实参列表和小括号都可以省略
  4. 当有多个枚举对象时，使用 , 间隔，最后有一个分号结尾
  5. 枚举对象必须放在枚举类的行首.
    在这里插入图片描述
    代码：
public class Enumeration03 {
    public static void main(String[] args) {
        System.out.println(Season2.AUTUMN);
        System.out.println(Season2.SUMMER);
    }
}
//演示使用enum关键字来实现枚举类
enum  Season2 {//类
    //定义了四个对象, 固定.
    //如果使用了enum 来实现枚举类
    //1. 使用关键字 enum 替代 class
    //2. public static final Season SPRING = new Season("春天", "温暖") 直接使用
    //   SPRING("春天", "温暖") 解读 常量名(实参列表)
    //3. 如果有多个常量(对象)， 使用 ,号间隔即可
    //4. 如果使用enum 来实现枚举，要求将定义常量对象，写在前面
    //5. 如果我们使用的是无参构造器，创建常量对象，则可以省略 ()
    SPRING("春天", "温暖"), WINTER("冬天", "寒冷"), AUTUMN("秋天", "凉爽"),
    SUMMER("夏天", "炎热") ,WHAT/*, What()*/;

    private String name;
    private String desc;//描述

    private Season2() {//无参构造器 }
    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() {
        return "Season{" +
                "name='" + name + '\'' +
                ", desc='" + desc + '\'' +
                '}';
    }
}
  • 课堂练习

  1. 下面代码是否正确, 并说明表示的含义?

    enum Gender{ //1min
    BOY , GIRL; //这里其实就是调用Gender 类的无参构造器
    }
    (1) 上面语法是ok
    (2) 有一个枚举类Gender， 没有属性。
    (3) 有两个枚举对象BOY, GIRL, 使用的无参构造器创建.

  2. 下面代码输出什么? EnumExercise01.java
    在这里插入图片描述

11.5 enum 常用方法说明、课堂练习

  • 说明：使用关键字enum 时，会隐式继承Enum 类, 这样我们就可以使用Enum 类相关的方法。[看下源码定义.]
    public abstract class Enum<E extends Enum>
    implements Comparable, Serializable {
    }
    我们一起来举例说明enum 常用的方法的使用，对Season2 测试. EnumMethod.java
  1. toString:Enum 类已经重写过了，返回的是当前对象名,子类可以重写该方法，用于返回对象的属性信息
  2. name：返回当前对象名（常量名），子类中不能重写
  3. ordinal：返回当前对象的位置号，默认从0 开始
  4. values：返回当前枚举类中所有的常量
  5. valueOf：将字符串转换成枚举对象，要求字符串必须为已有的常量名，否则报异常！
  6. compareTo：比较两个枚举常量，比较的就是编号！
public class EnumMethod {
    public static void main(String[] args) {
        //使用Season2 枚举类，来演示各种方法
        Season2 autumn = Season2.AUTUMN;

        //输出枚举对象的名字
        System.out.println(autumn.name());
        //ordinal() 输出的是该枚举对象的次序/编号，从0开始编号
        //AUTUMN 枚举对象是第三个，因此输出 2
        System.out.println(autumn.ordinal());
        //从反编译可以看出 values方法，返回 Season2[]
        //含有定义的所有枚举对象
        Season2[] values = Season2.values();
        System.out.println("===遍历取出枚举对象(增强for)====");
        for (Season2 season: values) {//增强for循环,末尾与详解
            System.out.println(season);
        }

        //valueOf：将字符串转换成枚举对象，要求字符串必须为已有的常量名，否则报异常
        //执行流程
        //1. 根据你输入的 "AUTUMN" 到 Season2的枚举对象去查找
        //2. 如果找到了，就返回，如果没有找到，就报错
        Season2 autumn1 = Season2.valueOf("AUTUMN");
        System.out.println("autumn1=" + autumn1);
        System.out.println(autumn == autumn1);//true 是同一个对象

        //compareTo：比较两个枚举常量，比较的就是编号
        //解读
        //1. 就是把 Season2.AUTUMN 枚举对象的编号 和 Season2.SUMMER枚举对象的编号比较
        //2. 看看结果
        /* 原码
        public final int compareTo(E o) {

            return self.ordinal - other.ordinal;
        }
        Season2.AUTUMN的编号[2] - Season2.SUMMER的编号[3]
         */
        System.out.println(Season2.AUTUMN.compareTo(Season2.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);
//        }
    }
}
enum  Season2 {//类

    SPRING("春天", "温暖"), WINTER("冬天", "寒冷"), AUTUMN("秋天", "凉爽"),
    SUMMER("夏天", "炎热");

    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 () {
            return "Season{" +
                    "name='" + name + '\'' +
                    ", desc='" + desc + '\'' +
                    '}';
        }
    }

  • 课堂练习

    声明Week 枚举类，其中包含星期一至星期日的定义； MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY,SATURDAY, SUNDAY;使用values 返回所有的枚举数组, 并遍历。要求返回“星期一”-“星期天”（重写toString的时候删一删就行了，只留下name）

public class EnumExercise02 {
    public static void main(String[] args) {
        //获取到所有的枚举对象， 即数组
        Week[] weeks = Week.values();
        //遍历，使用增强for
        System.out.println("===所有星期的信息如下===");
        for (Week week : weeks) {
            System.out.println(week);
        }
    }
}

enum Week   {
    //定义Week的枚举对象
    MONDAY("星期一"), TUESDAY("星期二"), WEDNESDAY("星期三"), THURSDAY("星期四"),
    FRIDAY("星期五"), SATURDAY("星期六"), SUNDAY("星期日");
    private String name;

    private Week(String name) {//构造器
        this.name = name;
    }
    @Override
    public String toString() {
        return name;
    }
}

11.6 enum 实现接口

EnumDetail.java

  1. 使用enum 关键字后，就不能再继承其它类了，因为enum 会隐式继承Enum，而Java 是单继承机制。
  2. 枚举类和普通类一样，可以实现接口，如下形式。
    enum 类名implements 接口1，接口2{}
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("播放好听的音乐...");
    }
}

11.7注解的理解、基本的Annotation介绍

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

  • 基本的Annotation 介绍

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

    三个基本的Annotation:
    (1) @Override: 限定某个方法，是重写父类方法, 该注解只能用于方法
    (2) @Deprecated: 用于表示某个程序元素(类, 方法等)已过时
    (3) @SuppressWarnings: 抑制编译器警告

11.7.1 @Override 注解的使用说明、案例

  • @Override使用说明

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

  1. @Override表示指定重写父类的方法（从编译层面验证)，如果父类没有fly方法，则会报错
  2. 如果不写@Override注解,而父类仍有public void fly（），仍然构成重写
  3. @Override只能修饰方法，不能修饰其它类，包，属性等等
  4. 查看@Override注解源码为@Target(ElementType.METHOD),说明只能修饰方法
  5. @Target是修饰注解的注解,称为元注解,记住这个概念.

  • 案例演示 Override_.java

    补充说明:@interface的说明
    @interface不是interface，是注解类,是jdk5.0之后加入的

public class Override_ {
    public static void main(String[] args) {
    }
}
class Father{//父类
    public void fly(){
        int i = 0;
        System.out.println("Father fly...");
    }
}

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  父类没有say()方法，写了 @Override 就报错
    public void say() {}
}

11.7.2 @Deprecated 注解的使用说明、案例

Deprecated_.java

@Deprecated: 用于表示某个程序元素(类, 方法等)已过时代码，但是过时了还可以用。

@Deprecated的说明

  1. 用于表示某个程序元素(类,方法等)已过时
  2. 可以修饰方法，类,字段,包,参数等等
  3. @Target(value={CONSTRUCTOR, FIELD, LOCAL_VARIABLE,METHOD,PACKAGE, PARAMETER, TYPE)
  4. @ Deprecated的作用可以做到新旧版本的兼容和过渡
public class Deprecated_ {
    public static void main(String[] args) {
        A a = new A();
        a.hi();
        System.out.println(a.n1);
    }
}
//解读
//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(){
    }
}

11.7.3 @SuppressWarnings 注解的案例

SuppressWarnings_.java

@SuppressWarnings: 抑制编译器警告

说明各种值：

  1. unchecked是忽略没有检查的警告
  2. rawtypes是忽略没有指定泛型的警告(传参时没有指定泛型的警告错误)
  3. unused是忽略没有使用某个变量的警告错误
  4. @SuppressWarnings 可以修饰的程序元素为,查看@Target
  5. 生成@SupperssWarnings时，不用背,直接点击左侧的黄色提示，就可以选择(注意可以指定生成的位置)
import java.util.ArrayList;
import java.util.List;

@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));

    }

    public void f1() {
//        @SuppressWarnings({"rawtypes"})
        List list = new ArrayList();

        list.add("jack");
        list.add("tom");
        list.add("mary");
//        @SuppressWarnings({"unused"})
        int i;
        System.out.println(list.get(1));
    }
}

11.8 JDK 的元Annotation(元注解， 了解)

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

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

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

11.8.1 @Retention 注解

说明
只能用于修饰一个Annotation 定义, 用于指定该Annotation 可以保留多长时间, @Rentention 包含一RetentionPolicy
类型的成员变量, 使用@Rentention 时必须为该value 成员变量指定值:
@Retention 的三种值

  1. RetentionPolicy.SOURCE: 编译器使用后，直接丢弃这种策略的注释
  2. RetentionPolicy.CLASS: 编译器将把注解记录在class 文件中. 当运行Java 程序时, JVM 不会保留注解。这是默认值
  3. RetentionPolicy.RUNTIME:编译器将把注解记录在class 文件中. 当运行Java 程序时, JVM 会保留注解. 程序可以通过反射获取该注解

在这里插入图片描述

11.8.2 @Target

在这里插入图片描述在这里插入图片描述

11.8.3 @Documented

在这里插入图片描述
在这里插入图片描述

11.8.4 @Inherited 注解

被它修饰的Annotation将具有继承性.如果某个类使用了被@Inherited修饰的Annotation,则其子类将自动具有该注解
说明:实际应用中，使用较少，了解即可。
元注解:本身作用不大，讲这个原因希望,看源码时,可以知道他是干什么.

11.9 本章练习题

  1. 试写出以下代码的执行结果
public class Homework01 {
    public static void main(String[] args) {
        Car c =new Car();
        Car c1=new Car(100);
        System.out.println(c);//9.0,red
        System.out.println(c1);//100.0,red
    }
}
class Car{
    double price=10;
    static String color="white";
    public String toString(){
        return price+"\t"+color;
    }
    public Car(){
        this.price=9;
        this.color="red";
    }
    public Car(double price){
        this.price=price;
    }
}
  1. 编程题Homework02.java 3min要求->代码

(1) 在Frock类中声明私有的静态属性currentNum[int类型]，初始值为100000，作为衣服出厂的序列号起始值。
(2) 声明公有的静态方法getNextNum，作为生成上衣唯一序列号的方法。每调用一次,将currentNum增加100，并作为返回值。
(3) 在TestFrock类的main方法中，分两次调用getNextNum方法,获取序列号并打印输出。
(4) 在Frock类中声明serialNumber(序列号)属性，并提供对应的get方法;
(5) 在Frock类的构造器中，通过调用getNextNum方法为Frock对象获取唯一序列号，赋给serialNumber属性。
(6) 在TestFrock类的main方法中，分别创建三个Frock对象，并打印三个对象的序列号，验证是否为按100递增。

public class Homework02 {
    public static void main(String[] args) {
    }
}

class Frock {
    private static  int currentNum = 100000;
    private int serialNumber;

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

    public static int getNextNum() {
        currentNum += 100; //将currentNum增加100
        return currentNum;
    }

    public int getSerialNumber() {
        return serialNumber;
    }
}
class TestFrock {
    public static void main(String[] args) {
        System.out.println(Frock.getNextNum());//100100
        System.out.println(Frock.getNextNum());//100200
        Frock frock = new Frock();//序列号就是 100300
        Frock frock1 = new Frock();//序列号就是 100400
        Frock frock2 = new Frock();//序列号就是 100500
        System.out.println(frock.getSerialNumber());//100300
        System.out.println(frock1.getSerialNumber());//100400
        System.out.println(frock2.getSerialNumber());//100500
    }
}

  1. 编程题 HomeworkO3.java

    按要求实现下列问题:1min完成->抽象类的使用
    (1) 动物类Animal包含了抽象方法shout();
    (2) Cat类继承了Animal，并实现方法shout，打印“猫会哺瞄叫”
    (3) Dog类继承了Animal，并实现方法shout，打印“狗会汪汪叫”
    (4) 在测试类中实例化对象Animal cat =new Cat(),并调用cat的shout方法
    (5) 在测试类中实例化对象Animal dog=new Dog0,并调用dog的shout方法

public class Homework03 {
    public static void main(String[] args) {
        Animal cat = new Cat();
        Animal dog = new Dog();
        cat.shout();
        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("狗会汪汪叫");
    }
}
  1. 编程题 Homework04.java 2min
    考察对匿名内部类的使用
    (1) 计算器接口具有work方法，功能是运算，有一个手机类Cellphone，定义方法testWork测试计算功能,调用计算接口的work方法,
    (2) 要求调用CellPhone对象的testWork方法,使用上匿名内部类
public class Homework04 {
    public static void main(String[] args) {
        Cellphone cellphone = new Cellphone();
        //解读:匿名内部类是
        /*
            new ICalculate() {
                @Override
                public double work(double n1, double n2) {
                    return n1 + n2;
                }
            }, 同时也是一个对象
            他的编译类型 ICalculate, 他的运行类型就是 匿名内部类
         */
        cellphone.testWork(new ICalculate() {
            @Override
            public double work(double n1, double n2) {
                return n1 + n2;
            }
        }, 10, 8);//18.0

        cellphone.testWork(new ICalculate() {
            @Override
            public double work(double n1, double n2) {
                return n1 * n2;
            }
        }, 10, 8);
    }
}
//编写接口
interface ICalculate {
    //work方法 是完成计算，但是题没有具体要求，所以自己设计
    //至于该方法完成怎样的计算，我们交给匿名内部类完成
    public double work(double n1, double n2) ;
}
class Cellphone {
    //解读，当我们调用testWork方法时，直接传入一个实现了ICalculate接口的匿名内部类即可
    //该匿名内部类，可以灵活的实现work,完成不同的计算任务
    public void testWork(ICalculate iCalculate, double n1, double n2) {
        double result = iCalculate.work(n1, n2);//动态绑定
        System.out.println("计算后的结果是=" + result);
    }
}
  1. 编程题 HomeworkO5.java
    内部类
    1．编一个类A，在类中定义局部内部类B，B中有一个私有final常量name，有一个方法show( )打印常量name。进行测试
    2 . 进阶: A中也定义一个私有的变量name.在show方法电打印测试
public class Homework05 {
    public static void main(String[] args) {
        new A().f1();
    }
}

class A {
    private String NAME = "hello";
    public void f1() {

        class B { //局部内部类
            private final String NAME = "Java教育";
            public void show() {
                //如果内部类和外部类的属性重名，可以同 外部类.this.属性名来指定
                System.out.println("NAME=" + NAME + " 外部类的name=" + A.this.NAME);
            }
        }
        B b = new B();
        b.show();
    }
}

  1. 编程题Homework06.java

    （1）有一个交通工具接口类Vehicles（就是指的接口），有work接口
    （2）有Horse类和Boat类分别实现Vehicles
    （3）创建交通工具工厂类，有两个方法分别获得交通工具Horse和Boat
    （4）有Person类，有name和Vehicles属性，在构造器中为两个属性赋值
    （5）实例化Person对象“唐僧”，要求一般情况下用Horse作为交通工具，遇到大河时用Boat作为交通工具
    （6）增加一个情况，如果唐僧过火焰山, 使用 飞机 ==> 程序扩展性, 我们前面的程序结构就非常好扩展

主类和1-3小问的代码

import com.cmLianXi.modifier.A;

public class LianXi {
    public static void main(String[] args) {
        Person tang = new Person("唐僧", new Horse());
        tang.common();//一般情况下
        tang.passRiver();//过河
        tang.common();//一般情况下
        tang.passRiver();//过河
        tang.passRiver();//过河
        tang.passRiver();//过河
        //过火焰山
        tang.passFireHill();
    }
}
interface Vehicles{ //第一小问
    public 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 Plane implements Vehicles {
    @Override
    public void work() {
        System.out.println("过火焰山，使用飞机...");
    }
}

class VehiclesFactory {
    //马儿始终是同一匹
    private static Horse horse = new Horse(); //饿汉式

    private VehiclesFactory(){}
    //创建交通工具工厂类，有两个方法分别获得交通工具Horse和Boat
    //这里，我们将方法做成static
    public static Horse getHorse() {
//        return new Horse();
        return horse;
    }
    public static Boat getBoat() {
        return new Boat();
    }
    public static Plane getPlane() {
        return new Plane();
   }
}

4-6小问的Person类代码：

public class Person {
    private String name;
    private Vehicles vehicles;

    //在创建人对象时，事先给他分配一个交通工具
    public Person(String name, Vehicles vehicles) {
        this.name = name;
        this.vehicles = vehicles;
    }

    //实例化Person对象“唐僧”，要求一般情况下用Horse作为交通工具，遇到大河时用Boat作为交通工具
    //这里涉及到一个编程思路，就是可以把具体的要求，封装成方法-> 这里就是编程思想
    //思考一个问题，如何不浪费，在构建对象时，传入的交通工具对象->动脑筋
    public void passRiver() { //过河情况
        //先得到船
        //判断一下，当前的 vehicles 属性是null, 就获取一艘船
//        Boat boat = VehiclesFactory.getBoat();
//        boat.work();
        //如何防止始终使用的是传入的马 instanceOf
        //if (vehicles == null) {
        //vehicles instanceof Boat 是判断 当前的 vehicles是不是Boat
        //(1) vehicles = null  : vehicles instanceof Boat  => false
        //(2) vehicles = 马对象 ：vehicles instanceof Boat  => false
        //(3) vehicles = 船对象 ：vehicles instanceof Boat  => true
        if (!(vehicles instanceof Boat)) {
            vehicles = VehiclesFactory.getBoat();
        }
        vehicles.work();
    }
    public void common() { //一般情况下
        //得到马儿
        //判断一下，当前的 vehicles 属性是null, 就获取一匹马
        //if (vehicles == null) {
        if (!(vehicles instanceof Horse)) {
            //这里使用的是多态
            vehicles = VehiclesFactory.getHorse();
        }
        //这里体现使用接口调用
        vehicles.work();
    }
    //过火焰山
    public void passFireHill() {
        if (!(vehicles instanceof Plane)) {
            //这里使用的是多态
            vehicles = VehiclesFactory.getPlane();
        }
        //这里体现使用接口调用
        vehicles.work();
    }
}
  1. 内部类练习编程题 HomeworkO7.java

有一个Car类，有属性temperature(温度)，车内有Air(空调)类，有吹风的功能flow，Air会监视车内的温度，如果温度超过40度则吹冷气。如果温度低于0度则吹暖气，如果在这之间则关掉空调。实例化具有不同温度的Car对象，调用空调的flow方法，测试空调吹的风是否正确。//体现类与类的包含关系的案例类(内部类【成员内部类】)

public class LianXi {
    public static void main(String[] args) {
        Car car = new Car(50);
        car.getAir().flow();

        Car car1 = new Car(-1);
        car1.getAir().flow();

        Car car2 = new Car(20);
        car2.getAir().flow();
    }
}

class Car{
    private double temperature;

    public Car(double temperature) {
        this.temperature = temperature;
    }

    //Air 成员内部类
    class Air{
        public void  flow(){
            if (temperature >= 40){
                System.out.println("温度大于40 空调吹冷气");
            }else if(temperature < 0){
                System.out.println("温度低于0度 吹暖气");
            }else{
                System.out.println("关闭空调");
            }
        }
    }
    //返回一个Air对象
    public Air getAir(){
        return new Air();
    }
}

  1. 枚举类编程题 Homework08.java

    （1）创建一个Color枚举类
    （2）有RED,BLUE BLACK, YELLOW,GREEN这个五个枚举值/对象;
    （3）3. Color有三个属性redValue, greenValue,blueValue,
    （4）创建构造方法，参数包括这三个属性，
    （5）每个枚举值都要给这三个属性赋值，三个属性对应的值分别是
    （6） red: 255,0,0 blue:0,0,255 black:0,0,0 yellow:255,255,0 green:0,255,0
    （7）定义接口，里面有方法show，要求Color实现该接口
    （8）show方法中显示三属性的值
    （9）将枚举对象在switch语句中匹配使用

public class Homework08 {
    public static void main(String[] args) {
        //演示一下枚举值得switch使用
        Color green = Color.GREEN;
        green.show();
        //比较一下
        //switch () 中，放入枚举对象
        //在每个case 后，直接写上在枚举类中，定义的枚举对象即可
        switch (green) {
            case YELLOW:
                System.out.println("匹配到黄色");
                break;
            case BLACK:
                System.out.println("匹配到黑色");
                break;
            default:
                System.out.println("没有匹配到..");
        }
    }
}
interface IMyInterface {
    public void show();
}

enum Color implements IMyInterface {
    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);
    }
}
码农小C
关注
  • 2
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
第8章 枚举与注解
ITlundao的博客
09-10 735
8.3 练习 1、 声明Week枚举类，其中包含星期一至星期日的定义； 在TestWeek类中声明方法中printWeek(Week week)，根据参数值打印相应的中文星期字符串。 提示，使用switch语句实现。 在main方法中从命令行接收一个1-7的整数(使用Integer.parseInt方法转换)，分别代表星期一至星期日，打印该值对应的枚举值，然后以此枚举值调用printWe...
JAVA基础(二十五)——枚举
qq_37466661的博客
08-21 489
java 枚举类 enum Enum
Java（十四）
二锅头的博客
07-10 127
知识点一：回顾Java基础 1.变量 定义：内存中的一块空间，可以保存数据。 2.数据类型 定义：变量名，数据类型决定了空间大小，还决定了数据的范以及数据能做什么！！ 按照数据类型来分： 1）基本数据类型：值本身 2）引用数据类型：其他数据的地址(内存中某个字节的编号，本质上是正数) 按照声明的位置来分： 1）局部变量：在方法中声明的变量：范围小，寿命短，在栈中存活。 2）成员变量：在类中方法体外声明的变量：范围大，寿命长，在堆中存活。 ①实例变量（对象属性），存活在GC堆中。 ②类变量（类属性），存活在方
枚举
qq_51907130的博客
02-01 1443
问题 定义一个表示一周七天的枚举类型，并在主方法main()中遍历枚举所有成员。 代码如下 enum Week // enum 枚举类型，下面为它的成员 { MONDAY,TUESDAY,WEDNESDAY,THUSDAY,FRIDAY,SATURDAY,SUNDAY } public class Test { public static void main(String[] args) { Week day = Week.MONDAY; Week day1 = Week.valueO
java学习之路 之 枚举&注解-枚举类及练习题
OnlyLove_longshao的博客
08-16 2615
枚举类 JDK1.5之前需要自定义枚举类 JDK 1.5 新增的 enum 关键字用于定义 枚举类若枚举只有一个成员, 则可以作为一种单例模式的实现方式 枚举类的属性: 枚举类对象的属性不应允许被改动, 所以应该使用 private final 修饰 枚举类的使用 private final 修饰的属性应该在构造器中为其赋值 若枚举类显式的定义了带参数的构造器, 则在列出枚举值时
java学习笔记(11) 第11 章 - 枚举和注解（csdn）————程序.pdf
12-01
java学习笔记(11) 第11 章 - 枚举和注解（csdn）————程序
java注解和反射的个人学习笔记
03-01
java注解和反射的个人学习笔记
Java工作笔记-枚举类型反射
12-21
这里枚举类型有自己的反射方式： 这里我先总结下逻辑： 1. 通过getEnumConstatnts返回目前枚举中存在的对象。 2. 通过getMehod获取方法。 3. 最后用这个对象调用其方法。 程序运行截图如下： 其中对应的枚举： ...
java学习笔记-Scokect.pdf
11-29
java学习笔记-Scokect.pdf
Java基础 学习笔记 Markdownr版
06-27
Java基础 java学习笔记 Java Java基础Markdown学习笔记，可转换成PDF、Word等格式
Java_枚举类
臭憨的博客
09-25 379
枚举，是JDK1.5引入的新特性，可以通过关键字enum来定义枚举类。 枚举类是一种特殊的类，它和普通类一样可以使用构造器、定义成员变量和方法，也能实现一个或多个接口。 枚举其实也是一种类，同时还是一个final修饰的类。 枚举类型都会默认继承一个父类型(java.lang.Enum)，这还是一个抽象的泛型类。 枚举中所定义的对象，其实就是类里面的public static final修饰的常量，并且这些常量会在静态代码块中做初始化。 枚举类型中还一个默认的私有构造器，说明在枚举类的外面并不能自己去创建枚
java 枚举 数字 星期_java 枚举类的简单介绍及使用枚举类的内部类编写的星期几的小案例...
weixin_42500866的博客
03-05 1184
为什么需要枚举？一些方法在运行时，它需要的数据不能是任意的，而必须是一定范围内的值，此类问题在JDK5以前采用自定义带有枚举功能的类解决，Java5以后可以直接使用枚举予以解决。JDK5新增的enum关键字用于定义一个枚举类。枚举类是什么？¨枚举类也是一种特殊形式的Java类。¨枚举类和普通类的区别？1. 使用enum定义的枚举类默认继承了java.lang.Enum类2.枚举类的构造器只能使...
枚举的定义和使用
Tankee888
09-08 923
枚举 在JDK 1.5时推出枚举类型什么是枚举 就是表示有几个固定的值 星期,月份,季节,性别,红绿灯等等 和常量类似 用来保护系统的安全性和提高了含义确定性枚举的格式 Enum 枚举名{ }枚举的调用 在定义User类时 定义成员变量需如下定义:public class User { //类的成员变量---属性
3.5 jmu-枚举WeekDay(补全代码) (5分)
m0_53062159的博客
12-01 1815
题目要求 本题要求编写一个枚举类WeekDay，包含周一至周日7个常量。7个常量的名字为对应的英文单词大写，常量的顺序则可观察样例获得。 本题还要求编写将从控制台输入的字符串转化为WeekDay类型变量，然后使用swith根据该变量执行相应代码。 最后，本题要求输出统计结果，并得到WeekDay的常量数组，然后对其进行排序并输出。以下为代码框架，请在相应位置补全代码： import java.util.Arrays; import java.util.Scanner; //这里编写泛型类WeekDay的定义
枚举类型的使用，利用枚举类型表示一周的每一天，然后通过数据来输出对应周几
JYMA12358的博客
11-26 1534
枚举类型的使用，利用枚举类型表示一周的每一天，然后通过数据来输出对应周几
Java 中的枚举 (enum)
bitcarmanlee的博客
02-08 1470
枚举类 (enum) 1.在某些情况下，一个类的对象时有限且固定的，如季节类，它只有春夏秋冬4个对象这种实例有限且固定的类，在 Java 中被称为枚举类； 2.在 Java 中使用 enum 关键字来定义枚举类，其地位与 class、interface 相同； 3.枚举类是一种特殊的类，它和普通的类一样，有自己的成员变量、成员方法、构造器 (只能使用 private 访问修饰符，所以无法从外部
java练习 星期枚举
weixin_64284821的博客
02-22 531
控制台输入要查询的英文星期简写（小写，如mon）后，控制台输出该星期简称的中英文对照（例如：MONDAY----星期一）。
2021-11-07 C语言中 枚举的使用：周一至周日的输出
toulan_xiaochang的博客
11-07 2295
第10行代码 void f(enum Weekday i) //刚刚不小心把Weekday 写成WeekDay, d写错了 # include <stdio.h> //只定义一个数据类型，没有定义变量，该数据类型的名字是enum WeekDay enum Weekday { MonDay = 0, TuesDay, WednesDay, ThursDay, Friday, SaturDay, SunDay }; //注意分号 //函数目的只是期望接受0-6之间的数字，故将形参...
第八章-注解的实现
09-27 163
参考博文： （1）关于注解Annotation第一篇 （2）关于注解Annotation第二篇 （3）Annotate类 （4）JavacProcessingEnvironment类解读 （5）Java的注解相关的命令 调用步骤： （1）调用JavacProcessingEnvironment的doProcessing()方法 其中的主要逻辑代码如下...
Spring学习笔记（一）----Spring概念
最新发布
06-01
它提供了一个全面的编程和配置模型，用于现代基于 Java 的企业应用程序 - 从单个服务器应用程序到云原生应用程序。Spring 框架的核心是 IoC（控制反转）和 AOP（面向切面编程）。 控制反转（IoC）是一种编程模型，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

码农小C

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值