【高级编程】实用类详解（上）枚举定义及相关方法案例 包装类 Math类 随机数（含案例）

一、Enum 枚举

1.简述

枚举（enum）是一种特殊的数据类型，用于定义一组常量。

[Modifier] enum enumName{
    enumContantName1
    [,enumConstantName2...[;]]
    // [field, method] 
}

枚举命名约定

按照约定，枚举属于常量，因此采用所有字母大写，下划线分割的风格（UPPER_CASE）。也就是说枚举类名与普通类约定一样，而枚举中的变量与静态变量的命名规范一致。

枚举的构造方法

默认情况下，枚举类是不需要构造方法的，默认的变量就是声明时的字符串。也可以通过自定义构造方法，来初始化枚举的一些状态信息。通常情况下，我们会在构造参数中传入两个参数，比如，一个编码，一个描述。

public enum DayOfWeek {
    MONDAY(1, "Monday"),
    TUESDAY(2, "Tuesday");
    
    private final int code;       // 编码
    private final String description; // 描述
    
    // 自定义构造方法
    private DayOfWeek(int code, String description) {
        this.code = code;
        this.description = description;
    }
    public int getCode() {
        return code;
    }
    public String getDescription() {
        return description;
    }
}

2.常用方法

假设我们有一个简单的枚举类型 Day，用于表示一周中的七天

public enum Day {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

方法	描述
.name()	返回枚举常量的名称（字符串）
.values()	返回一个包含所有枚举常量的数组 可以使用这个方法遍历枚举中的所有常量
.ordinal()	返回枚举常量在枚举定义中的位置（从0开始的索引）
.valueOf(String name)	根据给定的名字返回对应的枚举常量。如果没有匹配的常量，会抛出 IllegalArgumentException
.toString()	返回枚举常量的名字，通常它与 .name() 方法返回的结果相同
.getDeclaringClass()	返回枚举常量所属的枚举类型
.compareTo(E o)	与 java.lang.Comparable 接口一起使用，用于比较当前枚举常量与给定枚举常量的顺序

public class Main {
    public static void main(String[] args) {
        
        // 1、使用 .name()
        Day day = Day.WEDNESDAY;
        String dayName = day.name();
        // 打印结果
        System.out.println("day is: " + dayName);  // 输出: day is: WEDNESDAY
        
        // 2、使用 .values()
        Day[] days = Day.values();
        for (Day day : days) {
            System.out.println(day);  // 输出: MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
        }
        
        // 3、使用 .ordinal()
        Day day = Day.WEDNESDAY;
        System.out.println(day.ordinal());  // 输出 2
        
        // 4、使用 .valueOf(String name)
        Day day = Day.valueOf("FRIDAY");
        System.out.println(day);  // 输出 FRIDAY
        
        // 5、使用 .toString()
        Day day = Day.SATURDAY;
        System.out.println(day.toString());  // 输出 SATURDAY
        
        // 6、使用 .getDeclaringClass()
        Day day = Day.MONDAY;
        System.out.println(day.getDeclaringClass());  // 输出 class Day
        
        // 7、使用 .compareTo(E o)
        Day day1 = Day.MONDAY;
        Day day2 = Day.FRIDAY;
        System.out.println(day1.compareTo(day2));  // 输出 -4，因为 MONDAY 在 FRIDAY 之前
    }
}

3.案例

案例1 需求说明

为大数据岗位课程三个学习阶段定义枚举：L1、L2、L3，分别表示第一、二、三阶段
编程输出每个单元的学习目标
L1：大数据开发工程师
L2：大数据挖掘工程师
L3：大数据架构师

public enum LearningStage {
    L1("大数据开发工程师"),
    L2("大数据挖掘工程师"),
    L3("大数据架构师");

    private final String goal;

    LearningStage(String goal) {
        this.goal = goal;
    }

    public String getGoal() {
        return goal;
    }

    public static void main(String[] args) {
        for (LearningStage stage : LearningStage.values()) {
            System.out.println(stage.name() + ": " + stage.getGoal());
        }
    }
}

案例2 需求说明

根据用户选择的月份，输出对应的季节，季节使用枚举定义。

public enum Season {
    WINTER("Winter"),
    SPRING("Spring"),
    SUMMER("Summer"),
    FALL("Fall");

    private final String name;
    private Season(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

public class Test {
    //根据用户选择的月份，输出对应的季节，季节使用枚举定义。
    public static Season getSeason(int month) {
        if (month < 1 || month > 12) {
            throw new IllegalArgumentException("请输入正确的月份");
        }

        // 根据月份判断季节
        if (month == 12 || month == 1 || month == 2) {
            return Season.WINTER;
        } else if (month >= 3 && month <= 5) {
            return Season.SPRING;
        } else if (month >= 6 && month <= 8) {
            return Season.SUMMER;
        } else {
            return Season.FALL;
        }
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("请输入月份(1-12): ");
        int month = scanner.nextInt();

        try {
            Season season = Test.getSeason(month);
            System.out.println(month + "月是: " + season.getName());
        } catch (IllegalArgumentException e) {
            System.out.println(e.getMessage());
        }

        scanner.close();
    }
}

常用Java API

• java.lang（Enum、包装类、Math、String、StringBuffer、System…）

• java.util

• java.io

• java.sql

• …

二、包装类

包装类把基本类型数据转换为对象。每个基本类型在java.lang 包中都有一个相应的包装类。

包装类提供了一系列实用的方法。集合不允许存放基本数据类型数据，存放数字时，要用包装类型

1.构造方法

所有包装类都可将与之对应的基本数据类型作为参数，来构造它们的实例。除Character类外，其他包装类可将一个字符串作为参数构造它们的实例。

public Type(String value)
// Integer i = new Integer(1);

public Type(type value)
// Integer i = new Integer("123");

2.数据类型转换

常用方法	描述
new 包装类(基本数据类型)	基本数据类型 ==> 包装类
new 包装类(字符串<除Character外>)	字符串 ==> 包装类
.xxxValue()	包装类 ==> 基本数据类型
包装类.tostring(基本数据类型)	基本数据类型 | 包装类 ==> 字符串
包装类.parsexxx(字符串)	字符串 ==> 基本数据类型 | 包装类
包装类.value0f(基本数据类型)	基本数据类型 ==> 包装类
包装类.value0f(字符串<除Character外>)	字符串 ==> 包装类

XXXValue()

包装类转换成基本类型

byteValue()、intValue()、longValue()、shortValue()、doubleValue()、floatValue()、charValue()、booleanValue()

Integer integerId = new Integer(25);
int intId = integerId.intValue();

toString()

以字符串形式返回包装对象表示的基本类型数据（基本类型 -> 字符串）

String sex = Character.toString('男');
String id = Integer.toString(25);
String sex = '男' + "";
String id = 25 + "";

parseXXX()

把字符串转换为相应的基本数据类型数据（Character除外）（字符串 -> 基本类型）

int num = Integer.parseInt("36");
boolean bool = Boolean.parseBoolean("false");
// public static  type parseType(String type)

valueOf()

所有包装类都有如下方法（基本类型 -> 包装类）

public static Type valueOf(type value)
//  Integer intValue = Integer.valueOf(21);

除Character类外，其他包装类都有如下方法（字符串 -> 包装类）

public static Type valueOf(String s)
//  Integer intValue = Integer.valueOf("21");

注意：

• Boolean 类构造方法参数为 String 类型时，若该字符串内容为 true (不考虑大小写)，则该 Boolean 对象表示 true，否则表示 false

• 当 Number 包装类构造方法参数为 String 类型时，字符串不能为 null，且该字符串必须可解析为相应的基本数据类型的数据，否则编译不通过，运行时会抛出 NumberFormatException 异常

3.装箱和拆箱

装箱：基本类型转换为包装类的对象

拆箱：包装类对象转换为基本类型的值

Integer intObject = 5;
int intValue = intObject;

包装类的特点

JDK1.5后,允许基本数据类型和包装类型进行混合数学运算

包装类并不是用来取代基本数据类型的,在基本数据类型需要用对象表示时使用

三、Math

java.lang.Math 类提供了常用的数学运算方法和两个静态常量E（自然对数的底数）和PI（圆周率）

// 返回绝对值
int abs = Math.abs(-3);
System.out.printn(abs);

// 比较两个数 获得最大
int max = Math.max(19,20);
System.out.printn(max);

// 比较两个数 获得最小
int min = Math.min(19,20);
System.out.printin(min);

随机数

// 获得[0, 1)之间的随机数
double random = Math.random() * 10 + 1;//获得1-10随机数
System.out.printin(random);

// 获得n, m之间的随机数(m > n)
// 规律: *差值 +最小值
// 例 25 ~ 37  [0,1) * 37-25 = 12  [0,12) + 25 [25,37)
int random = (int) (Math.random() * 12 + 25);

四、Random

生成随机数的其他方式：java.util.Random类

Random rand = new Random(); // 创建一个Random对象
for(int i = 0;i < 20; i++){ // 随机生成20个随机整数，并显示
	int num = rand.nextInt(10); // 返回下一个伪随机数，整型的   	
    System.out.println("第" + (i+1) + "个随机数是："+num);
} 

用同一个种子值来初始化两个 Random 对象，然后用每个对象调用相同的方法，得到的随机数也是相同的。