枚举、泛型、异常

最新推荐文章于 2024-08-07 07:30:00 发布
最新推荐文章于 2024-08-07 07:30:00 发布
阅读量121 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43647383/article/details/106796562
版权

目录

一、枚举

1.概述

在JDK1.5中引入了一个新的类型——枚举。可以简单地理解枚举就是一种特殊的java类，在这个特殊的类当中定义几个静态变量，每个变量都是这个类的实例。通过关键字enum实现，自动继承自Enum类（枚举类）。

枚举（enum），是指一个经过排序的、被打包成一个单一实体的项列表。一个枚举的实例可以使用枚举项列表中任意单一项的值。枚举在各个语言当中都有着广泛的应用，通常用来表示诸如颜色、方式、类别、状态等等数目有限、形式离散、表达又极为明确的量。

2.枚举的定义

个数有限，离散形式，语义明确

/*红绿灯，红  黄   蓝
*/
public enum Color{
	RED,GREEN, YELLOW;
}

public class Test{
	public static void main(String[] args){
		Colorc=Color.RED;
		System.out.println(c);    
	}
}

3.枚举中声明属性和方法

/**
 * 定义枚举    红灯   绿灯   黄灯
 */
public enum EnumDefinition {
    Red(1,"红灯"),
    Green(2,"绿灯"),
    Yellow(3,"黄灯");

    int value;
    String key;
    
    EnumDefinition(int value, String key) {//构造函数
        this.value = value;
        this.key = key;
    }
}

4.内置方法

在这里插入图片描述

二、泛型<>

1.泛型概述

Java泛型是JDK1.5中引入的一个新特性，其本质是参数化类型，也就是说所操作的数据类型被指定为一个参数（type parameter）这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。

2.泛型的定义与使用

1）定义和使用含有泛型的类

定义格式：

修饰符 class 类名<代表泛型的变量> {  }

例如，API中的ArrayList集合：

class ArrayList<E>{ 
    public boolean add(E e){ }

    public E get(int index){ }
   	....
}

使用泛型： 即什么时候确定泛型

在创建对象的时候确定泛型

例如，
ArrayList<String> list = new ArrayList<String>();

此时，变量E的值就是String类型,那么我们的类型就可以理解为：

class ArrayList<String>{ 
     public boolean add(String e){ }

     public String get(int index){  }
     ...
}

2）自定义泛型

public class MyGenericClass<MVP> {
	//没有MVP类型，在这里代表 未知的一种数据类型 未来传递什么就是什么类型
	private MVP mvp;
     
    public void setMVP(MVP mvp) {
        this.mvp = mvp;
    }
     
    public MVP getMVP() {
        return mvp;
    }
}

使用:

public class GenericClassDemo {
  	public static void main(String[] args) {		 
         // 创建一个泛型为String的类
         MyGenericClass<String> my = new MyGenericClass<String>();    	
         // 调用setMVP
         my.setMVP("大胡子登登");
         // 调用getMVP
         String mvp = my.getMVP();
         System.out.println(mvp);
         //创建一个泛型为Integer的类
         MyGenericClass<Integer> my2 = new MyGenericClass<Integer>(); 
         my2.setMVP(123);   	  
         Integer mvp2 = my2.getMVP();
    }
}

3.含有泛型的方法

定义格式：

修饰符 <代表泛型的变量> 返回值类型 方法名(参数){  }

例如：

public class MyGenericMethod {	  
    public <MVP> void show(MVP mvp) {
    	System.out.println(mvp.getClass());
    }
    
    public <MVP> MVP show2(MVP mvp) {	
    	return mvp;
    }
}

使用格式：调用方法时，确定泛型的类型

public class GenericMethodDemo {
    public static void main(String[] args) {
        // 创建对象
        MyGenericMethod mm = new MyGenericMethod();
        // 演示看方法提示
        mm.show("aaa");
        mm.show(123);
        mm.show(12.45);
    }
}

4.含有泛型的接口

定义格式：

修饰符 interface接口名<代表泛型的变量> {  }

例如：

public interface MyGenericInterface<E>{
	public abstract void add(E e);
	
	public abstract E getE();  
}

使用格式：
1、定义类时确定泛型的类型

例如：

public class MyImp1 implements MyGenericInterface<String> {
	@Override
    public void add(String e) {
        // 省略...
    }

	@Override
	public String getE() {
		return null;
	}
}//此时，泛型E的值就是String类型。

2、始终不确定泛型的类型，直到创建对象时，确定泛型的类型
例如：

public class MyImp2<E> implements MyGenericInterface<E> {
	@Override
	public void add(E e) {
       	 // 省略...
	}

	@Override
	public E getE() {
		return null;
	}
}

确定泛型：

/*
 * 使用
 */
public class GenericInterface {
    public static void main(String[] args) {
        MyImp2<String>  my = new MyImp2<String>();  
        my.add("aa");
    }
}

5.泛型通配符

泛型的通配符:不知道使用什么类型来接收的时候,此时可以使用?,?表示未知通配符。

public static void getElement(Collection<?> coll){}
//？代表可以接收任意类型

6.通配符高级使用----受限泛型

之前设置泛型的时候，实际上是可以任意设置的，只要是类就可以设置。但是在JAVA的泛型中可以指定一个泛型的上限和下限。

泛型的上限：

  • 格式： 类型名称 <? extends 类 > 对象名称
  • 意义： 只能接收该类型及其子类

泛型的下限：

  • 格式： 类型名称 <? super 类 > 对象名称
  • 意义： 只能接收该类型及其父类型

比如：现已知Object类，String 类，Number类，Integer类，其中Number是Integer的父类

public static void main(String[] args) {
    Collection<Integer> list1 = new ArrayList<Integer>();
    Collection<String> list2 = new ArrayList<String>();
    Collection<Number> list3 = new ArrayList<Number>();
    Collection<Object> list4 = new ArrayList<Object>();
    
    getElement(list1);
    getElement(list2);//报错
    getElement(list3);
    getElement(list4);//报错
  
    getElement2(list1);//报错
    getElement2(list2);//报错
    getElement2(list3);
    getElement2(list4);
  
}
// 泛型的上限：此时的泛型?，必须是Number类型或者Number类型的子类
public static void getElement1(Collection<? extends Number> coll){}
// 泛型的下限：此时的泛型?，必须是Number类型或者Number类型的父类
public static void getElement2(Collection<? super Number> coll){}

三、异常

异常 ：指的是程序在执行过程中，出现的非正常的情况，最终会导致JVM的非正常停止。

在Java等面向对象的编程语言中，异常本身是一个类，产生异常就是创建异常对象并抛出了一个异常对象。Java处理异常的方式是中断处理。

1.异常分类

我们平常说的异常就是指Exception，因为这类异常一旦出现，我们就要对代码进行更正，修复程序。

异常(Exception)的分类:根据在编译时期还是运行时期去检查异常?

  • 编译时期异常（检查时异常）:checked异常。在编译时期,就会检查,如果没有处理异常,则编译失败。(如日期格式化异常)
  • 运行时期异常:runtime异常。在运行时期,检查异常.在编译时期,运行异常不会编译器检测(不报错)。(如数学异常)

在这里插入图片描述

2.异常的处理

Java异常处理的五个关键字：try、catch、finally、throw、throws

1）抛出异常throw

在编写程序时，我们必须要考虑程序出现问题的情况。比如，在定义方法时，方法需要接受参数。那么，当调用方法使用接受到的参数时，首先需要先对参数数据进行合法的判断，数据若不合法，就应该告诉调用者，传递合法的数据进来。这时需要使用抛出异常的方式来告诉调用者。

在java中，提供了一个throw关键字，它用来抛出一个指定的异常对象。那么，抛出一个异常具体如何操作呢？

  1. 创建一个异常对象。封装一些提示信息(信息可以自己编写)。

  2. 需要将这个异常对象告知给调用者。怎么告知呢？怎么将这个异常对象传递到调用者处呢？通过关键字throw就可以完成。throw 异常对象。

throw用在方法内，用来抛出一个异常对象，将这个异常对象传递到调用者处，并结束当前方法的执行。

使用格式：

throw new 异常类名(参数);

throw：

public class ThrowDemo {
    public static void main(String[] args) {
        //创建一个数组 
        int[] arr = {2,4,52,2};
        //根据索引找对应的元素 
        int index = 4;
        int element = getElement(arr, index);

        System.out.println(element);
        System.out.println("over");
    }
    /*
     * 根据 索引找到数组中对应的元素
     */
    public static int getElement(int[] arr,int index){ 
       	//判断  索引是否越界
        if(index<0 || index>arr.length-1){
             /*
             判断条件如果满足，当执行完throw抛出异常对象后，方法已经无法继续运算。
             这时就会结束当前方法的执行，并将异常告知给调用者。这时就需要通过异常来解决。 
              */
             throw new ArrayIndexOutOfBoundsException("哥们，角标越界了~~~");
        }
        int element = arr[index];
        return element;
    }
}

2） 声明异常throws

声明异常：将问题标识出来，报告给调用者。如果方法内通过throw抛出了编译时异常，而没有捕获处理（稍后讲解该方式），那么必须通过throws进行声明，让调用者去处理。

关键字throws运用于方法声明之上,用于表示当前方法不处理异常,而是提醒该方法的调用者来处理异常(抛出异常).

声明异常格式：

修饰符 返回值类型 方法名(参数) throws 异常类名1,异常类名2…{   }

throws用于进行异常类的声明，若该方法可能有多种异常情况产生，那么在throws后面可以写多个异常类，用逗号隔开。

public class ThrowsDemo2 {
    public static void main(String[] args) throws IOException {
        read("a.txt");
    }

    public static void read(String path)throws FileNotFoundException, IOException {
        if (!path.equals("a.txt")) {//如果不是 a.txt这个文件 
            // 我假设  如果不是 a.txt 认为 该文件不存在 是一个错误 也就是异常  throw
            throw new FileNotFoundException("文件不存在");
        }
        if (!path.equals("b.txt")) {
            throw new IOException();
        }
    }
}

3）捕获异常try…catch

如果异常出现的话,会立刻终止程序,所以我们得处理异常:

  1. 该方法不处理,而是声明抛出,由该方法的调用者来处理(throws)。
  2. 在方法中使用try-catch的语句块来处理异常。

try-catch的方式就是捕获异常。

  • 捕获异常：Java中对异常有针对性的语句进行捕获，可以对出现的异常进行指定方式的处理。

捕获异常语法如下：

try{
     编写可能会出现异常的代码
}catch(异常类型  e){
     处理异常的代码
     //记录日志/打印异常信息/继续抛出异常
}

注意：try和catch都不能单独使用,必须连用。

try…catch：

public class TryCatchDemo {
    public static void main(String[] args) {
        try {// 当产生异常时，必须有处理方式。要么捕获，要么声明。
            read("b.txt");
        } catch (FileNotFoundException e) {// 括号中需要定义什么呢？
          	//try中抛出的是什么异常，在括号中就定义什么异常类型
            System.out.println(e);
        }
        System.out.println("over");
    }
    /*
     *
     * 我们 当前的这个方法中 有异常  有编译期异常
     */
    public static void read(String path) throws FileNotFoundException {
        if (!path.equals("a.txt")) {//如果不是 a.txt这个文件 
            // 我假设  如果不是 a.txt 认为 该文件不存在 是一个错误 也就是异常  throw
            throw new FileNotFoundException("文件不存在");
        }
    }
}

如何获取异常信息：

Throwable类中定义了一些查看方法:

  • public String getMessage():获取异常的描述信息,原因(提示给用户的时候,就提示错误原因。

  • public String toString():获取异常的类型和异常描述信息(不用)。

  • public void printStackTrace():打印异常的跟踪栈信息并输出到控制台。

​ 包含了异常的类型,异常的原因,还包括异常出现的位置,在开发和调试阶段,都得使用printStackTrace。

4）finally 代码块

finally：有一些特定的代码无论异常是否发生，都需要执行。另外，因为异常会引发程序跳转，导致有些语句执行不到。而finally就是解决这个问题的，在finally代码块中存放的代码都是一定会被执行的

finally的语法:

 try...catch....finally:自身需要处理异常,最终还得关闭资源。

注意:finally不能单独使用。

try {
    read("a.txt");
} catch (FileNotFoundException e) {
    //抓取到的是编译期异常  抛出去的是运行期 
    throw new RuntimeException(e);
} finally {
    System.out.println("不管程序怎样，这里都将会被执行。");
}

当只有在try或者catch中调用退出JVM的相关方法,此时finally才不会执行,否则finally永远会执行。

3.异常注意事项

多个异常使用捕获又该如何处理呢？

  1. 多个异常分别处理。
  2. 多个异常一次捕获，多次处理。
  3. 多个异常一次捕获一次处理。

一般我们是使用一次捕获多次处理方式，格式如下：

try{
     编写可能会出现异常的代码
}catch(异常类型A  e){  当try中出现A类型异常,就用该catch来捕获.
     处理异常的代码
     //记录日志/打印异常信息/继续抛出异常
}catch(异常类型B  e){  当try中出现B类型异常,就用该catch来捕获.
     处理异常的代码
     //记录日志/打印异常信息/继续抛出异常
}

注意:这种异常处理方式，要求多个catch中的异常不能相同，并且若catch中的多个异常之间有子父类异常的关系，那么子类异常要求在上面的catch处理，父类异常在下面的catch处理。

4.自定义异常

异常类如何定义:

  1. 自定义一个编译期异常: 自定义类 并继承于java.lang.Exception。
  2. 自定义一个运行时期的异常类:自定义类 并继承于java.lang.RuntimeException。
zjhelloword
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
1-14 枚举和异常
WilsonDone的博客
10-23 186
Java中系统中提供了很多异常，但是这些异常并不能满足所有情况，判断腿的异常，身高异常，体中异常？当出现一些定制异常的时候，系统异常就不能满足需求，此时我们可以创建自己的异常自定义异常分为两个种类1.运行时自定义异常，创建一个自定义异常类，这个类继承于RuntimeException【程序运行时就提示有异常】2.编译时自定义异常，创建一个自定义异常类，这个类继承于Exception【编写代码时就提示有异常】无论是继承哪一个，都需要仿照父类生成自己的构造方法即可自定义异常。
枚举、异常
weixin_30595035的博客
08-17 112
1.访问权限修饰符 enum 枚举名{ //静态常量 常量A,常量B,常量C; }2.枚举只能给枚举对象赋值 枚举名 对象 = 枚举名.常量A; 对象存储的就是枚举值3.switch...case形式 switch(对象|枚举名.常量A){ //枚举中定义的常量 case 常量A: 执行语句; break; ...
枚举和注解以及异常处理
weixin_62570753的博客
11-19 285
枚举和注解以及异常处理 详细介绍
枚举与异常
Ab_999的博客
07-31 369
枚举 枚举的基本定义和使用 枚举的定义 定义枚举类型， 需要使用到关键字 enum 。 枚举的名字是一个标识符， 遵循大驼峰命名法。 public enum Gender { // 将这个枚举对象所有可能取到的值, 都列出来 // 枚举中的元素, 也是标识符, 遵循大驼峰命名法 Male, Female } public enum Month { Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec } public
返回值和异常枚举常量
to_real的博客
09-17 472
public class R extends HashMap<String, Object> { private static final long serialVersionUID = 1L; public R() { put("code", 0); put("msg", "success"); } public static R error() { return error(500, "未知异常，请联系管理.
Java泛型详解
09-02
泛型允许我们在编程时指定容器（如集合）中存储的数据类型，确保在运行时不会发生类型转换异常，同时提供了一种强类型检查的方式，避免了错误的数据类型被插入。 1. 引入泛型机制的原因： 在Java 5之前，集合类（如...
实验六 异常处理、泛型程序设计
05-09
在原有学生管理系统中，针对读文件、类型转换、数组等操作引入异常处理机制； 编写一个表示某门课程成绩的泛型类 class CourseScore，属性包括课程的编号和成绩。 要求：成绩可以是百分制，也可以是A-E（分别以字符...
JAVA8个人练习,异常,常用类,枚举，泛型,io流,网络编程,反射,动态代理等等
04-08
3. **枚举**：虽然枚举在 Java 5 中就已经引入，但 Java 8 对其进行了扩展，允许枚举实现接口并包含方法，增强了枚举的灵活性和可扩展性。 4. **泛型**：Java 8 对泛型的支持进一步加强，引入了类型推断，使代码更...
网络程序设计java第章泛型和枚举new优秀PPT.ppt
12-01
3. **枚举与switch**：枚举常量可以直接在`switch`语句中使用，增强了代码的可读性和安全性，避免了空指针异常。 4. **接口与枚举**：枚举可以实现接口，从而扩展其功能，如`public enum Color implements ...
泛型实例详解
10-29
在实际开发中，熟练运用泛型可以避免类型转换异常，提高代码的可维护性和灵活性。而enum_test文件可能包含与枚举（Enum）相关的示例，虽然不属于泛型的范畴，但也是Java中重要的面向对象特性，用于定义常量集。
初探C# 异常处理
程序员的良师益友
08-22 1081
一、基础在C# 里，异常处理就是C# 为处理错误情况提供的一种机制。它为每种错误情况提供了定制的处理方式，并且把标识错误的代码与处理错误的代码分离开来。对.NET类来说，一般的异常类 System.Exception 派生于 System.Object。还有许多定义好的异常类（如：System.SystemException、System.ApplicationException等），他们
一个用枚举类型定义错误码的Demo
漠北鹰的专栏
01-16 3965
/** * Created by gfj43958 on 2017/1/6. */ public enum WrapperEnumError { //网络超时 SOCKET_TIMEOUT("W001", "网络超时"), //网络链接异常 SOCKET_CONNECT_EROOR("W002", "网络链接异常"), //请求参数错误 REQ
枚举类型与自定义异常
Chengqb的博客
06-27 2251
枚举类型与自定义异常目录1、定义响应码与响应消息枚举型2、自定义异常（1）服务异常（2）业务异常3、自定义异常使用 注： 个人认为一个项目中，最好有2个自定义异常；一个是 服务 异常，一个是 业务 异常 1、定义响应码与响应消息枚举型 package com.xxx.xxx; /** * @Auther: Chengqb * @Date: 2019/6/27 8:40 */ ...
Day12 java异常
蒋亚文的博客
09-11 302
异常 简单分类 异常体系结构 Error Exception 异常处理机制 package com.jyw.exception; public class Test { public static void main(String[] args) { int a = 1; int b = 0; //假设要捕获多个异常，从小到大！ //快捷键ctrl+Alt+t try {//try监控区域
Java 枚举异常的类型
Hommiee的博客
05-26 328
public enum CustomExceptionType { USER_INPUT_ERROR(400,"用户输入异常"), SYSTEM_ERROR (500,"系统服务异常"), OTHER_ERROR(999,"其他未知异常"); CustomExceptionType(int code, String typeDesc) { this.code = code; this.typeDesc = typeDesc; }
枚举和异常
StephenYou的自习室
07-25 657
目录枚举定义枚举常用的方法异常异常的传播异常处理finally的使用异常体系自定义异常 枚举 定义 在Java编程语言中，可以使用enum关键字定义枚举类型。所有的枚举类都继承于java.lang.Enum类。 eg: //使用enum关键字声明一个枚举类 public enum Day { //枚举类的值，类型是Day SUNDAY,//星期天 MONDAY,//星期一 TUESDA...
枚举解决自定义异常
杨春建的博客
04-17 1677
原文地址：http://blog.csdn.net/sunhuwh/article/details/43545329 自定义异常： [java] view plain copy public interface ExceptionEnums {            public int getCode();            public String g
【Spring Boot】高效配置管理: 易用性与灵活性并重
最新发布
weixin_68020300的博客
08-07 1257
本文探讨了Spring Boot中多样化的配置读取方法及其应用场景，强调了配置管理的重要性，并展示了Spring Boot如何通过灵活多变的配置选项简化这一过程。此外，文章还展望了配置管理领域未来的技术趋势和发展方向。对于任何希望深入了解Spring Boot配置管理的开发者来说，这是一篇不容错过的好文。
TypeConverter ConvertFrom 转换所有类型，包含枚举 泛型和颜色 字体属性
05-31
下面是一个示例代码，演示了如何使用TypeConverter和ConvertFrom方法将字符串转换成枚举、泛型、颜色和字体属性： ```csharp using System; using System.ComponentModel; using System.Drawing; class Program { ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值