java基础（枚举、注解）

Haslett。

已于 2024-07-27 19:11:10 修改

阅读量289

点赞数 1

文章标签： java 开发语言

于 2024-07-25 10:47:40 首次发布

本文链接：https://blog.csdn.net/qq_74930471/article/details/140668209

版权

一、枚举

1.1自定义类实现枚举

给定一个需求：要求创建季节对象：

package com.enum_;

public class Enumeration01 {
    public static void main(String[] args) {
         //使用
        Season spring = new Season("春天", "温暖");
        Season winter = new Season("冬天", "寒冷");
        Season summer = new Season("夏天", "炎热");
        Season autumn = new Season("秋天", "凉爽");
        //因为对于季节而言，它的对象(具体值)，是固定的四个，不会更多
        //因此上述设计不合理，不能体现季节是固定的四个对象
    }
}
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;
    }
}

根据代码的问题给定一下几点要求：

（1）季节的值是有限的几个值

（2）只读，不需要修改

解决方案：枚举

枚举是一组常量的集合（枚举属于一种特殊的类，里面只包含一组有限的限定的对象）

package com.enum_;

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

//演示定义枚举实现
class Season{
    private String name;
    private String desc;//描述
    //定义了四个对象
    //1.将构造器私有化，防止直接被new
    //2.去掉set相关的方法，防止属性被修改
    //3.在Season内部,直接创建固定的对象
    //4.优化。可以加入final修饰符
    public static final Season SPRING = new Season("春天","温暖");
    public static final Season WINTER = new Season("冬天", "寒冷");
    public static final Season SUMMER = new Season("夏天", "炎热");
    public static final Season AUTUMN = new Season("秋天", "凉爽");
    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 + '\'' +
                '}';
    }
}

小结：

（1）构造器私有化

（2）本类内部创建一组对象

（3）对外暴露对象（通过为对象添加public final static 修饰符）

（4）可以提供get方法，但是不要提供set

1.2enum关键字

package com.enum_;

public class Enumeration03 {
    public static void main(String[] args) {
        System.out.println(Season2.AUTUMN);
        System.out.println(Season2.SPRING);
        System.out.println(Season2.WINTER);
        System.out.println(Season2.SPRING);
    }
}
//演示使用enum关键字来实现枚举类
enum  Season2{
    //如果使用enum来实现枚举类
    //1.使用关键字enum替代class
    //2.public static final Season SPRING = new Season("春天","温暖")直接使用
    //解读SPRING("春天","温暖");常量名(实参列表)
    //3.如果有多个常量(对象)，使用逗号间隔即可
    //4.如果使用enum来实现枚举，要将定义常量对象写在前面
    //5.如果我们使用无参构造器创建枚举对象，则实参列表和小括号都可以省略
    //6.当有多个枚举对象时，使用,间隔最后才带根号
    //7.
    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 + '\'' +
                '}';
    }
}

enum常用方法说明：使用关键字enum时，会隐式继承Enum类，这样我们就可以使用Enum类相关的方法。

1.3enum相关细节

1.使用enum关键字后，就不能再继承其它类了，因为enum会隐式继承Enum，而java是单继承机制

2.枚举类和普通类一样，可以实现接口。

package com.enum_;

public class enumDetail {
    public static void main(String[] args) {
        Music.CLASICMUSIC.playing();
    }
}
class A{
    
}
//1.使用enum关键字后，就不能再继承其它类了，因为enum会隐式继承Enum，而java是单继承机制
//enum Season3 extends A{
//}
//2.enum实现的枚举类，仍然是一个类，所以还是可以实现接口的
interface IPlaying{
    public void playing();
}
enum Music implements IPlaying{
    CLASICMUSIC;

    @Override
    public void playing() {
        System.out.println("播放好听的音乐");
    }
};

二、注解

1.1override

等于说是一个标记，如果写了Override你下面的方法不是重写的父类的方法就会报错，如果重写的父类的方法就会编译通过

1.2Dprecated

1.3SuppressWarnings

1.4四种元注解（了解就行）

三、异常

3.1异常的基本概念

package com;

public class exception {
    public static void main(String[] args) {
        int num1 = 10;
        int num2 = 0;
        //1.num1/num2=>10/0
        //2.当执行num1/num2因为num = 0.程序就会出现异常 ArithmeticException
        //3.当抛出异常后，程序就会退出，下面的代码就不在执行了
        //4.这样会出现一个问题，当一个代码很大时，出现一点小问题就整个程序崩溃
        //5.java设计者，提供了一个叫异常处理机制来解决问题
       // int res = num1/num2;
        //如果程序员认为一段代码可能出现异常/问题，可以使用try-catch异常处理机制来解决
        //从而保证程序的健壮性
        //将改代码块选中，在使用快捷键ctrl+alt+t选中try-catch
        //6.如果进行异常处理，那么即使出现了异常，程序可以继续执行

        try {
            int res = num1/num2;
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("程序继续运行....");
    }
}

3.2异常体系图

异常体系图的小结：

1.异常分为两大类，运行时异常和编译时异常。

2.运行时异常，编译器不要求强制处理的异常。编译器检查不出来一般是指编程时的逻辑错误，是程序员应该避免出现的异常。java.lang.RuntimeException类及它的子类都是运行时异常

3.对于运行时异常，可以不作处理，因为这类异常很普遍，若全处理可能会对程序的可读性和运行效率产生影响

4.编译时异常，是编译器要求必须处置的异常

3.3五大运行时异常

（1）空指针异常，当应用程序试图在需要对象的地方使用null时，抛出该异常

package com.exception_;

public class exception01 {
    public static void main(String[] args) {
            String name = null;
            System.out.println(name.length());
    }
}

（2）数学运算异常，当出现异常的运算条件时，抛出此异常。例如：一个整数“除以零”时，排除此类的一个实例（上面有讲过）

（3）数组下标越界异常，用非法索引访问数组时抛出的异常，如果索引为负或大于等于数组大小，则该索引为非法索引

package com.exception_;

public class exception01 {
    public static void main(String[] args) {
           int[] arr ={1,2,4};
           for(int i=0;i<=arr.length;i++)
           {
               System.out.println(arr[i]);//没有arr[3]
           }
    }
}

（4）当试图将对象强制转换为不是实力的子类时，抛出该异常

package com.exception_;

public class exception01 {
    public static void main(String[] args) {
          A b = new B();//向上转型
          B b2 = (B)b;//向下转型
          C c2 = (C)b;//这里抛出ClassCastException
    }
}
class A{
}
class B extends A{}
class C extends A{}

（5）数字格式不正确异常，当应用程序试图将字符串转换成一种数值类型，但该字符串不能转换为适当格式时，抛出该异常=>使用异常我们可以确保输入时满足条件数字

package com.exception_;

public class exception01 {
    public static void main(String[] args) {
        String name = "sssss";
        //将String 转成 int
        int num = Integer.parseInt(name);
    }
}

以下是几种编译异常因为还没学文件编程，先大致了解就行

3.4异常处理机制

3.4.1try-catch-finally处理机制

代码参考前面的。

try-catch相关细节

package com.try_;

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

        //1.如果异常发生了。则异常发生后面的代码不会执行，直接进入到catch块
        //2.如果异常没有发生，则顺序执行try的代码块，不会进入到catch
        //3.如果希望不管是否异常，都执行某段代码(比如关闭连接，释放资源等)则使用如下代码-finally
        try {
            String str = "ssj";
            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("程序继续");
    }
}

package com.try_;

public class TryCatchDetail02 {
    public static void main(String[] args) {
        //1.如果try代码块有可能有多个异常
        //2.可以使用多个catch分别捕获不同的异常，相应处理
        //3.要求子类异常写在前面，父类异常写在后面
        try {
            Person person = new Person();
            System.out.println(person.getName());//NullPointExcepton
            int n1 = 10;
            int n2 = 0;
            int res = n1/n2;
        } catch (NullPointerException e) {
            System.out.println("空指针异常="+e.getMessage());//ArithmeticException
        } catch (ArithmeticException e) {
            System.out.println("算术异常="+e.getMessage());
        }catch (Exception e){
            System.out.println(e.getMessage());
        }
        finally{

        }
    }
}
class Person{
    public String name="jack";
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

3.4.2throw的处理机制

package com.throws_;

import java.io.FileInputStream;
import java.io.FileNotFoundException;

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

    }
    public void f2()throws FileNotFoundException,NullPointerException,ArithmeticException {
        //创建了一个文件流对象
        //1.这里的异常时FileNotFoundException编译异常
        //2.使用前面讲过的try-catch-finally
        //3.使用throws，抛出异常，让调用f2方法的调用者处理
        //4.throw后面的异常类型可以是方法中产生的异常类型，也可以是它的父类
        //5.throws关键字后也可以是异常列表，即可以抛出多个异常
        FileInputStream fileInputStream = new FileInputStream("d://aa.txt");
    }
}

throws的相关细节

3.4.3自定义异常

当程序中出现了某些“错误”，但该错误信息并没有在Throwable子类中描述处理，这个时候可以自己设计异常类，用于描述该错误信息

package com.customexception;

public class customException {
    public static void main(String[] args) {
        int age = 80;
        //要求范围在10~120之间，否则抛出一个自定义异常
        if(!(age >= 18&&age <=120)){
            throw new AgeException("年龄需要再 18-120之间");//这就是异常信息
        }
        System.out.println("你的年龄范围正常");
    }
}
//1.一般情况下，我们自定义异常是继承RuntimeException
//2.即把自定义异常做成运行时异常，好处是，我们可以使用默认的处理机制
class AgeException extends RuntimeException{
    public AgeException(String message){
        super(message);
    }
}

阅读上述代码我们发现了一个throw，下面是throw和throws的区别：

Haslett。

关注

1
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
java基础（枚举、注解）

根据代码的问题给定一下几点要求：（1）季节的值是有限的几个值（2）只读，不需要修改枚举是一组常量的集合（枚举属于一种特殊的类，里面只包含一组有限的限定的对象）小结：（1）构造器私有化（2）本类内部创建一组对象（3）对外暴露对象（通过为对象添加public final static 修饰符）（4）可以提供get方法，但是不要提供set。
复制链接

扫一扫