java基础_day12

一 枚举

1.1枚举的使用

枚举是一种自定义的数据类型， 可以声明变量。 在使用的时候， 直接使用枚举类型.枚举值
这样的形式进行枚举值的获取。
​
​
public class Test {
    public static void main(String[] args) {
// 枚举的使用
    Gender gender1 = Gender.Male;
    Gender gender2 = Gender.Female;
    Month m1 = Month.Jan;
    Month m2 = Month.Nov;
    Week week1 = Week.Sat;
    }
}

1.2 枚举中的成员定义

枚举，其实实可以认为是Object类的一个最终子类。 不能被其他的类、枚举继承。
public class EnumTest {
public static void main(String[] args) {
// 1. 获取一个枚举对象
Gender gender = Gender.Male;
// 1.1. 证明方式1: 枚举对象，可以调用Object类中的方法，说明这些方法是从
Object类中继承到的。
String str = gender.toString();
// 1.2. 证明方式2: 可以向上转型为 Object 类型。
Object obj = gender;
    }
}
enum Gender {
Male, Female
}

1.3 枚举中的属性定义

public enum Gender {
    Male, Female;
// 1. 在枚举中定义属性、方法、构造方法... 是需要写在枚举元素的下方！
// 如果需要在枚举中定义成员，需要在最后一个枚举元素后面添加一个分号。
    public String desc;
}

1.4 枚举中的构造方法定义

public class Test2 {
// 为了防止和当前包中的Gender枚举重复，在这里写成了静态内部枚举
    private static enum Gender {
// 其实，所谓枚举中的元素，其实就是一个静态的、当前类的对象。
    Male("男"), Female("女");
// 添加属性
        private String desc;
// 添加构造方法，为这个属性赋值
// 在枚举中定义构造方法，一般情况下，只是在当前的枚举中使用
// 所以，枚举的构造方法，一般情况下，权限都是私有的
    Gender(String desc) {
    this.desc = desc;
    }
}
public static void main(String[] args) {
// 1. 枚举对象的获取
Gender gender = Gender.Male;
    }
}

二 异常

2.1异常的结构和分类

在Java中，用 Throwable 类来描述所有的不正常的情况。 Throwable 有两个子类：
Exception 和 Error 。
​
Error: 描述发生在JVM虚拟机级别的错误信息， 这些错误无法被处理， 不做为现在的重点。
StackOverflowError: 栈溢出错误。
Exception： 描述程序遇到的异常。 异常是可以被捕获处理的， 是现在考虑的重点内容。
​
根据创建异常类的主体
第一:系统异常,系统提前定义好的,我们直接使用
第二:自定义异常,需要我们自己定义.
​

2.2 异常的特点

程序出现异常的时候,会打印异常的信息并中断程序,所以当有多个异常同时出现的时候,默认只能执行第一个.
​
public class Demo8 {
    public static void main(String[] args) {
    int[] arr = new int[] {4,5,6,6};
//会报NullPointerException异常:空指针异常
    arr = null;
//会报ArrayIndexOutOfBoundsException异常:数组下标越界异常
//当前的情况下,这个异常不会执行,执行空指针异常时,程序中断
    System.out.println(arr[10]);
    }
}

2.3 异常的捕获处理

2.3.1 try-catch

​
 如果一个异常不去处理， 会导致程序无法编译或者运行。
 
 try {
// 将可能出现异常的代码写到这里
// 如果这里的代码出现了异常， 从出现异常的位置开始， 到try代码段结束， 所有的
代码不执行。
}
catch (异常类型 标识符) {//捕获异常
// 如果try中的代码出现了异常，并且异常的类型和catch的异常的类型是可以匹配上
的，就会执行这里的逻辑
}

2.3.2 多个catch子句

如果在try代码段中， 出现了多种类型的异常， 此时如果需要对这些异常进行不同的处理，可以写多个catch子句。
​
try{
可能发生异常的代码
}catch(异常一 e){ //捕获异常 e就是要捕获的异常对当前异常的处理
}catch(异常二 e){ //捕获异常 e就是要捕获的异常对当前异常的处理
}catch(Exception e){ //捕获异常 e就是要捕获的异常对当前异常的处理
}

2.3.3 一个catch捕获多种异常

使用场景:
如果try中出现了多种异常，并且某些类型的异常，处理方式相同。 并且与其他类型的处理方式不同。 此时， 可以使用一个catch捕获处理多种异常。区分一个catch里面的多个异常时通过instanceof.
缺点:这种分类方式代码很混乱,所以不推荐.
​
   示例代码：
   public class Handle3 {
public static void main(String[] args) {
// 需求:
// NullPointerException ArrayIndexOutOfBoundsException 这两种异常处理方式相同， 输出 “数组相关异常”
// ArithmeticException NumberFormatException 这两种异常处理方式相同, 输出 “格式异常”
try {
nullPointerTest(); // NullPointerException
outOfBoundsTest(); // ArrayIndexOutOfBoundsException
arithmeticTest(); // ArithmeticException
formatException(); // NumberFormatException
}
catch (NullPointerException | ArrayIndexOutOfBoundsException e) {
System.out.println("数组相关异常");
if (e instanceof NullPointerException) {
System.out.println("NullPointerException");
}else if (e instanceof ArrayIndexOutOfBoundsException)
{
System.out.println("ArrayIndexOutOfBoundsException");
}
}
catch (ArithmeticException | NumberFormatException e) {
System.out.println("格式异常");
}
}
// NullPointerException
private static void nullPointerTest() {
int[] array = null;
array[0] = 10;
}
// ArrayIndexOutOfBoundsException
private static void outOfBoundsTest() {
int[] array = new int[5];
array[5] = 10;
}
// ArithmeticException
private static void arithmeticTest() {
int a = 10 / 0;
}
// NumberFormatException
private static void formatException() {
Integer i = Integer.valueOf("123a");
}
}

2.3.4 finally子句

概念：
finally出现在try-catch子句的结尾， finally代码段中的内容， 始终会执行。
​
语法：
try{
可能发生异常的代码
}catch(Exception e){ //捕获异常 e就是要捕获的异常
对当前异常的处理
}finally{
必须执行的代码:主要用于资源的释放:比如关闭数据库,关闭流,关闭锁等
}
​
特点
无论try代码段中有没有异常出现，无论try里面出现的异常没有被捕获处理，finally中的代码始终会执行。基于这个特点，常常在finally中进行资源释放、流的关闭等操作
​
作用范围
我们发现在catch中执行return后main方法结束,finally还能正常执行catch中执行System.exit(0)后,程序退出,finally不能执行了
​
结论:只要当前的程序在运行,finally代码就能执行.
    
 try-finally语句
  try{
获取资源
}finally{
释放资源
}  
​
特点
这个结构跟异常没有关系,主要用于资源的管理.

2.3.5 两个关键字

throw

概念/使用场景：
一个异常对象，被实例化完成后，没有任何意义。不会影响到程序的编译或者运行。如果希望某一个异常对象生效（可以影响程序的编译、运行），需要使用关键字 throw 进行异常的抛出。
​
public class Handle5 {
    public static void main(String[] args) {
        int ret = calculate(10, 20);
        System.out.println(ret);
}
private static int calculate(int a, int b) {
    if (a > b) {
        return a - b;
        }
// 否则，视为实参有逻辑错误，抛出一个异常
RuntimeException exception = new RuntimeException();
// 让当前的exception异常生效，使其可以终止程序的运行。
// 而且，在一个方法中抛出了异常，从这个位置开始，向后所有的代码都不执行
了。
throw exception;
    }
}
​

throws

概念/使用场景：
用在方法的声明部分，写在参数列表后面，方法体前面。
定义在方法中，表示这个方法过程结束中，可能会遇到什么异常。
定义了throws异常抛出类型的方法，在当前的方法中，可以不处理这个异常，由调用方处理。
​

2.4 自定义异常

如何自定义异常：
其实，系统提供的每一种异常，都是一个类。所以，自定义异常，其实就是写一个自定义的
异常类。
    如果要自定义一个编译时的异常，需要继承自 Exception 类。
特点:对异常进行处理的所有工作都要我们手动完成
如果要自定义一个运行时的异常，需要继承自    RuntimeException 类。
​
特点:所有的工作我们都可以不管

三 字符串

3.1 不可变字符串

对应的类:String.
特点:字符串本身不能发生改变,与指向字符串的引用无关.
直接使用"",创建的是不可变字符串

3.2 可变字符串:

对应的类:StringBuilder/StringBuffer.
特点:字符串本身可以发生变化,与指向可变字符串的引用无关
创建可变字符串
StringBuffer stringBuffer = new StringBuffer("hello world");

3.3 字符串的常用方法

 

3.4 字符串的非静态方法