JavaSE--第二阶段2

最新推荐文章于 2021-12-12 22:45:23 发布

梦~开始

最新推荐文章于 2021-12-12 22:45:23 发布

阅读量251

点赞数

分类专栏： JavaSE

本文链接：https://blog.csdn.net/HK_Milky/article/details/119704028

版权

本文详细介绍了JavaSE中的枚举和注解，包括枚举的自定义类实现和enum关键字的使用，以及JDK内置的基本注解类型。同时，文章还涵盖了异常处理的概念，如异常的分类、处理方式、throws和throw的区别。最后，文章列举了Java中常用的类，如包装类、String、StringBuffer和StringBuilder的特性与比较。

摘要由CSDN通过智能技术生成

1、枚举和注解

1、枚举介绍

枚举类【枚: 一个一个举：例举 , 即把具体的对象一个一个例举出来的类就称为枚举类】

2、自定义类实现枚举

不需要提供setXxx方法，因为枚举对象值通常为只读
对枚举对象 / 属性使用final+static共同修饰，实现底层优化
枚举对象名通常使用全部大写
枚举对象根据需要，也可以有多个属性
构造器私有化
本类内部创建一组对象
对外暴露对象（通常为对象添加public final static ）
可以提供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 + '\'' +
                '}';
    }
}

3、enum关键字实现枚举

1、注意事项

使用enum关键字开发一个枚举类时，默认会继承一个Enum类，而且是一个final类，所有使用enum关键字后就不能继承其他类了，但是可以实现接口
- 使用javap反编译可以查看
使用无参构造器创建枚举对象时，实参列表和小括号都可以省略
有多个枚举对象时，使用逗号间隔，最后使用一个分号结尾
枚举对象必须存放在枚举类的行首

2、常用方法

toString:Enum类已经重写过了，返回的是当前对象名子类可以重写该方法，用于返回对象的属性信息

name:返回当前对象名(常量名) ,子类中不能重写
ordinal:返回当前对象的位置号，默认从0开始
values:返回当前枚举类中所有的常量

valueOf:将字符串转换成枚举对象，要求字符串必须为己有的常量名，否则报异常!

compareTo:比较两个枚举常量，比较的就是位置号!

public class Enumeration03 {
   
    public static void main(String[] args) {
   
        System.out.println(Season2.AUTUMN);
        System.out.println(Season2.SUMMER);
    }
}
//演示使用enum关键字来实现枚举类
enum  Season2 {
   //类

    //定义了四个对象, 固定.
//    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. 如果我们使用的是无参构造器，创建常量对象，则可以省略 ()
    SPRING("春天", "温暖"), WINTER("冬天", "寒冷"), AUTUMN("秋天", "凉爽"),
    SUMMER("夏天", "炎热")/*, 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 + '\'' +
                '}';
    }
}

4、jdk内置的基本注解类型

1、注解

注解(Annotation)也被称为元数据(Metadata), 用于修饰解释包、类、方法、属性、构造器、局部变量等数据信息。
和注释一样，注解不影响程序逻辑，但注解可以被编译或运行，相当于嵌入在代码中的补充信息。

2、三个基本注解

@Override:限定某个方法，是重写父类方法，该注解只能用于方法
- @Target(ElementType.METHOD)
@Deprecated:用于表示某个程序元素(类，方法等)已过时
- @Target(value={CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE,MODULE,PARAMETER, TYPE})

@SuppressWarnings:抑制编译器警告

@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE, MODULE})

@SuppressWarning 中的属性介绍以及属性说明

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，抑制与未用的程式码及停用的程式码相关的警告

5、元注解：对注解进行注注解(了解)

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

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("没有匹配到..");
        }
    }
}

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

 */
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);
    }
}

2、异常

1、异常的概念

Java语言中，将程序执行中发生的不正常情况称为“异常"。(开发过程中的语法错误和逻辑错误不是异常)

执行过程中所发生的异常事件可分为两大类

Error(错误): Java虚拟机无法解决的严重问题。
Exception:其它因编程错误或偶然的外在因素导致的一般性问题，可以使用针对性的代码进行处理。例如空指针访问，试图读取不存在的文件，网络连接中断等。。。
- 运行时异常[程序运行时，发生的异常]
- 编译时异常[编程时，编译器检查出的异常]

2、异常处理

try-catch- finally 程序员在代码中捕获发生的异常，自行处理
throws：将发生的异常抛出，交给调用者(方法)来处理，最顶级的处理者就是JVM
try-catch：可以有多个catch语句，捕获不同的异常，要求父类异常在后，子类异常在前
try-finally：相当于没有捕获异常，程序会直接崩溃

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

        //老韩解读
        //1. 如果异常发生了，则异常发生后面的代码不会执行，直接进入到catch块
        //2. 如果异常没有发生，则顺序执行try的代码块，不会进入到catch
        //3. 如果希望不管是否发生异常，都执行某段代码(比如关闭连接，释放资源等)则使用如下代码- finally
        try {
   
            String str = "韩顺平";
            int a = Integer.parseInt(str);
            System.out.println("数字：" + a);
        } catch (NumberFormatException e) {
   
            System.out.println("异常信息=" + e.getMessage());
        } finally {
   
            System.out.println("finally代码块被执行...");
        }

        System.out.println("程序继续...");

    }
}

class ExceptionExe01 {
   
    public static int method() {
   
        int i = 1;//i = 1
        try {
   
            i++;// i=2
            String[] names = new String[3];
            if (names[1].equals("tom")) {
    //空指针
                System.out.println(names[1]);
            } else {
   
                names[3] = "hspedu";
            }
            return 1;
        } catch (ArrayIndexOutOfBoundsException e) {
   
            return 2;
        } catch (NullPointerException e) {
   
            return ++i;  // i = 3 => 保存临时变量 temp = 3;
        } finally {
   
            ++i; //i = 4
            System.out.println("i=" + i);// i = 4
        }
    }

    public static void main(String[] args) {
   
        System.out.println(method());// 3
    }
}

3、throws异常处理

1、基本介绍

如果个方法(中的语句执行时)可能生成某种异常，但是并不能确定如何处理这种异常，则此方法应显示地声明抛出异常，表明该方法将不对这些异常进行处理，而由该方法的调用者负责处理。
在方法声明中用throws语句可以声明抛出异常的列表，throws后面的异常类型可以是方法中产生的异常类型，也可以是它的父类。

2、注意事项

对于编译异常，程序中必须处理，比如try-catch或者throws
对于运行时异常，程序中如果没有处理，默认就是throws的方式处理
子类重写父类的方法时，对抛出异常的规定:子类重写的方法，所抛出的异常类型要么和父类抛出的异常一致，要么为父类抛出的异常的类型的子类型
在throws过程中，如果有方法try-catch ,就相当于处理异常，就可以不必throws

public class ThrowsDetail {
   
    public static void main(String[] args) {
   
        f2();
    }

    public static void f2() /*throws ArithmeticException*/ {
   
        //1.对于编译异常，程序中必须处理，比如 try-catch 或者 throws
        //2.对于运行时异常，程序中如果没有处理，默认就是throws的方式处理

        int n1 = 10;
        int n2 = 0;
        double res = n1 / n2;
    }

    public static void f1() throws FileNotFoundException {

最低0.47元/天解锁文章

梦~开始

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JavaSE--第二阶段2

1、枚举和注解1、枚举介绍枚举类【枚: 一个一个举：例举 , 即把具体的对象一个一个例举出来的类就称为枚举类】2、自定义类实现枚举不需要提供setXxx方法，因为枚举对象值通常为只读对枚举对象 / 属性使用final+static共同修饰，实现底层优化枚举对象名通常使用全部大写枚举对象根据需要，也可以有多个属性构造器私有化本类内部创建一组对象对外暴露对象（通常为对象添加public final static ）可以提供get方法，不不提供set方法
复制链接

扫一扫

专栏目录