014.day14

最新推荐文章于 2025-09-09 08:37:13 发布

weixin_30594001

最新推荐文章于 2025-09-09 08:37:13 发布

阅读量59

点赞数

CC 4.0 BY-SA版权

文章标签： java

原文链接：http://www.cnblogs.com/yokii/p/9400161.html

本文深入讲解Java中的枚举类型定义与使用、异常处理机制及集合框架的基本操作，通过实例演示如何利用这些特性增强程序的健壮性和灵活性。

枚举
异常
集合

枚举

1.概述

引用类型，规定了取值范围的变量类型

2.定义方式

public enum Score {
    A("90-100", "优秀") {
        // 在枚举元素中可以覆盖外部定义的方法
        public boolean hasWork() {
            return false;
        }
    },
    B("80-90", "良好"), C("70-80", "及格"), D("60-70", "挂科"), E("无成绩", "缺考");
}

所有的值之间使用逗号分隔，结尾的分号可以省略

3.枚举类型

// TODO 枚举类型
        Score score = Score.B;
        // 获取枚举的序数
        System.out.println(score.ordinal());// 1
        // 枚举元素间的比较,序数做差(前减后)
        System.out.println(Score.A.compareTo(Score.B));// -1
        // 输入一个学生成绩，如果在90-100分，则为A，顺次排列，要求输入成绩后输出一个成绩的评价
        String grade = getGrade();
        // valueOf(Class<T> enumType, String name)
        // 返回一个枚举常量,第一个参数:指定枚举类型(Score.class),第二个参数:字符串->枚举常量
        // 能够将一个字符串变量与相应的枚举常量建立联系，可以实现动态的判断
        score = Score.valueOf(Score.class, grade);
        switch (score) {
        case A:
            System.out.println("优秀");
            break;
        case B:
            System.out.println("良好");
            break;
        case C:
            System.out.println("及格");
            break;
        case D:
            System.out.println("挂科");
            break;

        default:
            System.out.println("缺考");
            break;
        }

    }

4.枚举的遍历

// TODO 枚举的遍历
        //返回一个数组
        Score[] scores = Score.values();
        for (Score score : scores) {
            // 返回此枚举常量的名称
            System.out.print(score.name() + "\t"); //A B C D E
            // 返回枚举常量的序数（它在枚举声明中的位置，其中初始常量序数为零）。
            System.out.print(score.ordinal() + "\t");// 0 1 2 3 4 
        }

异常

1.异常的语法结构

// TODO 异常的语法结构
        System.out.println("开始运行");
        // try-catch引导代码块
        // try -> 执行相应的代码
        try {
            test();
        } catch (ArithmeticException e) {
            // catch(XXXException e) 要捕获的异常类型
            // 相应异常的解决方法
            e.printStackTrace();// 打印异常信息
            System.out.println("异常捕获");
        }
        System.out.println("运行结束");

2.常见的异常

// TODO 常见的异常
        // throw new NullPointerException();// 空指针->对象没有实例化(指向为null)
        // throw new ArrayIndexOutOfBoundsException();// 数组越界异常 -> 下标超出数组范围
        // throw new IllegalArgumentException();// 非法参数异常
        // throw new NumberFormatException();// 数字转换异常 -> 将字符串类型转换为数字类型
        // throw new ArithmeticException();// 算数异常 -> 计算时产生的异常
        // throw new ParseException();// 解析异常 -> 日期等解析方法
        // throw new OutOfMemoryError();// 内存溢出异常 -> 死循环造成的资源不足

3.自定义输出异常信息

        try {
            test1();
        } catch (Exception e) {
            // TODO: handle exception
            System.out.println(e.getMessage());
        }
public static void test1() throws ArithmeticException {
    // 自定义输出的异常信息
        throw new ArithmeticException("除数不能为0");
    }

集合

1.java中的集合

// TODO Java中的集合
        // Collection -> List/Set -> ArrayList,LinkedList,HashSet,TreeSet,Vector
        // Map -> HashMap,HashTable,TreeMap
        // 1.实例化ArrayList - 无元素类型的限制(Object[])
        List list = new ArrayList();
        // 2.向集合当中添加元素
        list.add("1");
        list.add(2);
        list.add(3.0);
        list.add(3.0);
        // list.add(new Student());
        // 3.获取数组中的元素
        // System.out.println(list.get(0));
        // System.out.println(list.get(1));
        // System.out.println(list.get(2));
        // System.out.println(((Student)list.get(3)).getName());
        // 4.无元素类型限制 - 优点:可以装不同类型的元素/缺点:不利于自定义类型(引用类型)元素的操作
        // 5.集合的遍历
        for(int i = 0;i < list.size();i ++) {
            System.out.println(list.get(i));
        }
        // 6.foreach遍历 - 基于迭代器的实现，避免在foreach中变动集合中的元素
        for (Object object : list) {
            System.out.println(object);
        }
        System.out.println(list.size());

2.add

// TODO ArrayList -> add插入方法
        List list = new ArrayList();
        list.add("1");
        list.add(2);
        list.add(3.0);
        list.add(3.0);
        // add(int index,E element)插入
        // 数组越界,能够取到的下标以当前的集合中的元素个数为准 list.size()
        list.add(3,5);
        System.out.println(list.get(3));

3.ArrayList

// TODO ArrayList -> 
        List list1 = new ArrayList();
        list1.add("1");
        list1.add(2);
        list1.add(3.0);
        List list2 = new ArrayList();
        list2.add("4");
        list2.add(5);
        list2.add(6.0);
        // 将某一个集合追加到尾部
        list1.addAll(list2);
        /*for (Object object : list1) {
            System.out.println(object);
        }*/
        // 从某一个位置插入整个集合的所有元素，原集合的元素不会丢失
        list1.addAll(1, list2);
        for (Object object : list1) {
            System.out.println(object);
        }

contains,isEmpty,remove,toArray

// TODO ArrayList -> 是否包含,是否为空,删除元素
        List list1 = new ArrayList();
        list1.add("1");
        list1.add(2);
        list1.add(3.0);
        // 底层是equals方法 -> 基本数据类型及字符串都能够查找成功
        System.out.println(list1.contains("1"));
        // 集合为空时返回true
        System.out.println(list1.isEmpty());
        // 删除元素,删除成功返回true,删除失败返回false
        System.out.println(list1.remove("1"));
        System.out.println(list1.remove("2"));

// TODO ArrayList -> toArray
        List list1 = new ArrayList();
        list1.add("1");
        list1.add(2);
        list1.add(3.0);
        // 将ArrayList转换为对应类型的数组
        Object[] objects = list1.toArray();
        for (int i = 0; i < objects.length; i++) {
            System.out.println(objects[i]);
        }

转载于:https://www.cnblogs.com/yokii/p/9400161.html