枚举Enum及常用类

枚举Enum

枚举本质也是一种类。

枚举使用方式一、自定义枚举类

package com.wxl.enum_;

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


    }
}

//演示自定义 枚举类
class Season{//类
    private String name;
    private String desc;//描述

    // 定义了四个对象，固定
    public static final Season SPRING = new Season("春天", "温暖");
    public static final Season SUMMER = new Season("夏天", "炎热");
    public static final Season AUTUMN = new Season("秋天", "凉爽");
    public static final Season WINNER = new Season("冬天", "寒冷");

    // 自定义枚举类
    // 1、 将构造器私有化， 防止直接new
    // 2、 去掉set（）， 可以保留get（）。防止属性被修改
    // 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 + '\'' +
                '}';
    }
}

枚举使用方式二、将class改为enum。（枚举有一个隐藏的继承父类Enum）

package com.wxl.enum_;

public class Enumeration01 {
    public static void main(String[] args) {
        System.out.println(Season1.SPRING);
    }
}

//演示使用enum定义枚举类
enum Season1 {//类

    SPRING("春天", "温暖"),
    SUMMER("夏天", "炎热");
    private String name;
    private String desc;//描述



    // 如果使用enum定义枚举类
    // 1、 将class换成enum
    // 2、 public static final Season SPRING = new Season("春天", "温暖"); 直接使用，
    //  使用方式 SPRING("春天", "温暖")
    // 3、 如果有多个常量（对象），使用，号间隔即可
    // 4、 将定义常量（对象）写在前面

    private Season1(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 + '\'' +
                '}';
    }
}

枚举常用的方法。

异常Exception

小入门：

package com.wxl.exception_;
// 异常介绍
public class Exception01 {
    public static void main(String[] args) {
        int num1 = 10;
        int num2 = 0;
        int result = 0;
        try {
            result = num1 / num2;
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 正常情况下程序抛出异常时，程序会停止运行，这样程序的健壮性就较差。
        // 可通过异常处理，使得即使出现异常，程序也可以继续运行
        // 处理方法：选中可能会出现异常的语句，按下快捷键（快捷键Ctrl + Alt + t）
        System.out.println(result);
        System.out.println("程序继续运行、、、、、");
    }
}

try-catch-finally处理方法

try{
    //代码可能有异常
    }catch(Exception e){
    //捕获到异常
    //1.异常发生时
    //2.系统讲异常封装成Exception对象e，传递给catch
    //3.得到异常后，程序员自己处理
    //4.注意，没有发生异常时，catch代码块不执行
    }finally{
    //不管有没有发生异常，finally都要执行
    }

默认处理机制：如果没有显式的调用try-catch,系统默认调用throws

异常有编译异常和运行异常。

运行异常不要求程序员显式处理，因为有默认处理机制。

异常体系图：

String

String创建机制

String/ StringBuffer/ StringBuilder 的不同

Math

1. abs 绝对值

2. pow 求幂

3. ceil 向上取整

4. floor 向下取整

5. round 四舍五入

6. sqrt 求开方

7. random 随机数（返回[0, 1)之间的一个随机小数）例如：返回2~7之间的整数

int i = ((int)(2 + Math.random() * (7 - 2 + 1)))

8. max(), min(),  返回两个数中的最大值或最小值

Arrays

Arrays也有许多静态方法

int[] integers = {1,2,3,4};
        // 1.
        System.out.println(Arrays.toString(integers));

        // 2. sort方法
        Integer[] arrs = {1, -2, 3, 45, 34};
        // arrs是引用类型，直接影响原数组
        Arrays.sort(arrs);
        System.out.println("====排序后======");
        System.out.println(Arrays.toString(arrs));
        // 定制排序， 使用了匿名内部类
        Arrays.sort(arrs, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {

                return o1 - o2;
            }
        });
        System.out.println("====定制排序后======");
        System.out.println(Arrays.toString(arrs));

        // 3. binarySearch利用二分搜索法（前提是数组是有序的）查找。
        int[] arrs2 = {1, 3, 45, 100, 567};
        int index = Arrays.binarySearch(arrs2, 3);
        System.out.println("二分查找： " + index);

        // 4. copyOf 数组的复制
        // Arrays.copyOf(arrs, length_num)   length_num拷贝的长度

        // 5. fill 数组的填充

        // 6. equals 比较两个数组是否完全一样

        // 7. asList 将一组值，转换为list

Arrays的排序问题。且看下面代码

public class HomeWork {
    public static void main(String[] args) {
        Book[] books = new Book[4];
        books[0] = new Book("龙族", 49.9);
        books[1] = new Book("凡人修仙传", 89.9);
        books[2] = new Book("浮生物语", 39.9);
        books[3] = new Book("哈利波特", 99.9);

        // 按照价格排序
        Arrays.sort(books, new Comparator() { //匿名内部类
            @Override
            public int compare(Object o1, Object o2) {
                Book book1 = (Book) o1;
                Book book2 = (Book) o2;
                double d = book1.price - book2.price;
                if(d > 0){
                    d =  1;
                } else if (d < 0) {
                    d =  -1;
                } else if (d == 0) {
                    d = 0;
                }
                return (int)d;
            }
        });
        System.out.println(Arrays.toString(books));

        // 按照书名长短排序
        Arrays.sort(books, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                Book book1 = (Book) o1;
                Book book2 = (Book) o2;
                return book1.name.length() - book2.name.length();
            }
        });
        System.out.println("第二次排序后");
        System.out.println(Arrays.toString(books));
    }
}

class Book{
    public String name;
    public double price;

    public Book(String name, double price) {
        this.name = name;
        this.price = price;
    }

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