Java基础 -- 枚举、包装类、异常

一、枚举

1. 定义

枚举指由一组固定的常量组成的类型。

2. 实现

// 枚举类
public enum Gender{
male,female
}
	
// 使用
public class Student{
	Gender sex;

	public Student(){
		sex = Gender.male;
	}
}

3. 意义

限定数据的取值，使数据更加安全，简单，易于理解。

二、包装类

1. 定义

每个基本类型在 java.lang 包中都有一个相应的包装类。

2. 作用

包装类把基本类型数据转换为对象，提供了一系列实用的方法。
集合不允许存放基本数据类型数据，存放数字时，要用包装类型。

3. 分类

4. 构造包装类的实例

所有包装类都可将与之对应的基本数据类型作为参数，来构造它们的实例：

public Type（type value）

// 示例
Integer i = new Integer(1);

除 Character 类外，其他包装类可将一个字符串作为参数构造它们的实例：

public Type（String value）

// 示例
Integer i = new Integer("123");

Boolean 类构造方法参数为 String 类型时，若该字符串内容为 true (不考虑大小写)，则该 Boolean对象表示 true ，否则表示 false 。

当 Number 包装类构造方法参数为 String 类型时，字符串不能为 null ，且该字符串必须可解析为相应的基本数据类型的数据，否则编译通过，运行时 NumberFormatException 异常。

5. 包装类转为基本类型

XXXValue()：包装类转换成基本类型。

// 示例
Integer integerId = newInteger(25);
int intId = integerId. intValue();

6. 基本类型转为字符串

toString()：以字符串形式返回包装对象表示的基本类型数据。

// 示例
String sex = Character.toString('男');
String id = Integer.toString(25);

// 等同于
String sex = '男'+"";
String id = 25+"";

7. 字符串转为基本类型

parseXXX()：把字符串转换为相应的基本数据类型数据（Character除外）。

// 示例
int num = Integer.parseInt("36");
boolean bool = Boolean.parseBoolean("false");

8. 基本类型或字符串转为包装类

valueOf

8.1 基本类型转为包装类

所有包装类都有如下方法：

public static Type valueOf(type value)

// 示例
Integer intValue = Integer.valueOf(21);

8.2 字符串转为包装类

除 Character 类外，其他包装类都有如下方法：

public static Type valueOf(String s)

// 示例
Integer intValue = Integer.valueOf("21");

9. 拆箱和装箱（基本类型和包装类的自动转换）

装箱：基本类型转换为包装类的对象：包装类 . valueOf();。
拆箱：包装类对象转换为基本类型的值：包装类 . xxxValue();。
自动装箱、拆箱：

// JDK1.5之前是不支持自动装箱和自动拆箱的，定义 Integer对象，必须这样
Integer i = new Integer(8);
 
// JDK1.5开始，提供了自动装箱的功能，定义 Integer对象可以这样
Integer i = 8;

// 自动拆箱
int n = i;

10. 包装类的特点

• JDK1.5后，允许基本数据类型和包装类型进行混合数学运算
• 包装类并不是用来取代基本数据类型的
• 在基本数据类型需要用对象表示时使用

三、异常

1. 定义

异常就是在程序的运行过程中所发生的不正常的事件，它会中断正在运行的程序。Java编程语言使用异常处理机制为程序提供了错误处理的能力。

2. JAVA中如何进行异常处理

2. try-catch 块

public void method(){
try {
	// 代码段 A
} catch (异常类型 变量e) {
	// 对异常进行处理的代码段 B
}
// 代码段 C
}

使用 try-catch 块捕获异常，分为三种情况：

• 若代码段 A 未产生异常，则程序在执行完代码段A后，直接执行代码段 C 。
• 若代码段 A 产生异常，则产生异常对象，若异常对象匹配正确，则继续执行代码段 B、C ；若异常对象匹配不正确，则程序中断运行。

3. 在catch块中处理异常

调用异常对象的方法输出异常信息：

4. 多重CATCH块

一段代码可能会引发多种类型的异常，当引发异常时，会按顺序来查看每个 catch 语句，并执行第一个与异常类型匹配的catch语句。执行其中一条 catch 语句后，其后catch 语句将被忽略。

// 示例
try {
	// 代码段（省略）
} catch (InputMismatchException e) {
	System.err.println("被除数和除数必须是整数");
} catch (ArithmeticException e) {
	System.err.println("除数不能为零");
} catch (Exception e) {
	System.err.println("其他未知异常");
}

5. finally 块

在 try-catch 块后加入 finally 块，可以确保无论是否发生异常，finally 块中的代码总能被执行。

finally块中语句不执行的唯一情况——异常处理代码中执行 System.exit(1) 退出Java虚拟机

6. 常见的异常类型

异常是一种特殊的对象，类型为 java.lang.Exception 或其子类。

• Throwable：Exception 和 Error 类的父类
• Error：仅靠程序本身无法恢复的严重错误
• Exception：由Java应用程序抛出和处理的非严重错误
• Checked 异常（下图 Exception 左子树）：程序必须处理该类异常
• 运行时异常（下图 Exception 右子树）：不要求程序必须对它们做出处理

7. 声明异常

Java语言中通过 throws 声明某个方法可能抛出的各种异常，若同时声明多个异常，之间由逗号隔开。

public class Test7 {
	// divide()方法没有处理异常，而是声明异常
	public static void divide() throws Exception {
		Scanner in = new Scanner(System.in);
		System.out.print("请输入被除数:");
		int num1 = in.nextInt();
		System.out.print("请输入除数:");
		int num2 = in.nextInt();
		System.out.println(String.format("%d / %d = %d",
		num1, num2, num1/ num2));
	}

	// 方式1：调用者通过 try-catch 捕获并处理异常
	public static void main(String[] args) {
		try {
			divide();
		}catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	/* 方式2：调用者通过 throws 继续声明异常
	public static void main(String[] args) throws Exception {
		divide()；
	}
}
*/

8. 抛出异常

8.1 系统自动抛出的异常

所有系统定义的编译和运行异常都可以由系统自动抛出，称为标准异常，并且 Java 强烈地要求应用程序进行完整的异常处理，给用户友好的提示，或者修正后使程序继续执行。

8.2 语句抛出的异常

用户程序自定义的异常和应用程序特定的异常,必须借助于 throws 和 throw 语句来定义抛出异常。

public class Person {
	private String name = "";// 姓名
	private int age = 0;// 年龄
	private String sex = "男";// 性别
	
	public void setSex(String sex) throws Exception {
		if ("男".equals(sex) || "女".equals(sex))
			this.sex = sex;
		}else {
			throw new Exception("性别必须是“男”或者“女”！");
		}
	}
	public void print() {
		System.out.println(this.name + "（" + this.sex
		+ "，" + this.age + "岁）");
	}
}

public class Test8 {
	public static void main(String[] args) {
		Person person = new Person();
		try {
			person.setSex("Male");
			person.print();
		}catch (Exception e) {
			e.printStackTrace();
		}
	}
}

9. throw 和 throws 的区别

9.1 throw

throw 是语句抛出一个异常。
语法：throw (异常对象);

 throw e;

9.2 throws

throws 是方法可能抛出异常的声明。(用在声明方法时，表示该方法可能要抛出异常)
语法：(修饰符)(方法名)([参数列表])[throws(异常类)]{…}

public void doA(int a) throws Exception1,Exception3{......}

9.3 举例

throws E1,E2,E3只是告诉程序这个方法可能会抛出这些异常，方法的调用者可能要处理这些异常，而这些异常 E1，E2，E3 可能是该函数体产生的。

throw则是明确了这个地方要抛出这个异常。

// 示例 
void doA(int a) throws Exception1,Exception3{
	try{
	......
	
	}catch(Exception1 e) {
		throw e;
	}catch(Exception2 e) {
		System.out.println("出错了！");
	}
	if(a!=b) {
		throw new  Exception3("自定义异常");
	}
}

代码块中可能会产生3个异常( Exception1、Exception2、Exception3 )。

• 如果产生 Exception1 异常，则捕获之后再抛出，由该方法的调用者去处理。
• 如果产生 Exception2 异常，则该方法自己处理了（ 即 System.out.println(“出错了！”); ）。所以该方法就不会再向外抛出 Exception2 异常了，void doA() throws Exception1, Exception3 里面的 Exception2 也就不用写了。
• 而 Exception3 异常是该方法的某段逻辑出错，程序员自己做了处理，在该段逻辑错误的情况下抛出异常 Exception3，则该方法的调用者也要处理此异常。

9.4 对比

• throw 语句用在方法体内，表示抛出异常，由方法体内的语句处理。
  throws 句用在方法声明后面，表示再抛出异常，由该方法的调用者来处理。

• throws 主要是声明这个方法会抛出这种类型的异常，使它的调用者知道要捕获这个异常。
  throw 是具体向外抛异常的动作，所以它是抛出一个异常实例。

• throws 说明你有那个可能、倾向。
  throw 的话，那就是你把那个倾向变成真实的了。

• 两者都是消极处理异常的方式，这里的消极并不是说这种方式不好，只是抛出或者可能抛出异常，但是不会由函数去处理异常，真正的处理异常由函数的上层调用处理。