第三篇Java核心复习博客

一.异常
异常（Exception）是在程序执行过程中出现的意外情况或错误，它打破了正常的程序执行流程。在 Java 中，异常被封装成对象，并通过异常处理机制来捕获和处理。

Java 异常处理机制包括以下几个关键词和概念：

异常类（Exception Class）：Java 内置了许多异常类，用于表示各种不同类型的异常情况。常见的异常类包括 RuntimeException、NullPointerException、IOException 等。开发者也可以自定义异常类来表示特定的异常情况。

抛出异常（Throwing Exceptions）：当出现异常情况时，可以使用 throw 关键字手动抛出一个异常对象。抛出异常会中断当前的执行流程，并将异常传递给上层调用栈中的异常处理器。

异常捕获（Catching Exceptions）：使用 try-catch 块可以捕获并处理异常。try 块用于包裹可能会抛出异常的代码，catch 块用于捕获和处理异常。可以使用多个 catch 块来捕获不同类型的异常，并提供相应的处理逻辑。

异常处理（Exception Handling）：当程序抛出异常时，会根据调用栈的顺序依次查找匹配的 catch 块来处理异常。如果找到匹配的 catch 块，就会执行其中的代码来处理异常，然后程序会继续执行。如果没有找到匹配的 catch 块，异常会继续传递到调用栈的上层。

finally 块：finally 块用于定义一段无论是否发生异常都会执行的代码块。它通常用于释放资源、清理操作等。finally 块可以与 try-catch 块一起使用，也可以单独使用。

通过合理地使用异常处理机制，可以有效地处理程序中出现的异常情况，提高程序的健壮性和容错性。

1.try...catch和finally
try...catch 和 finally 是 Java 中用于异常处理的关键字和语句块。它们的作用如下：

try 块：try 块用于包裹可能会抛出异常的代码段。在 try 块中，我们可以放置可能会产生异常的代码。如果在 try 块中的代码抛出了异常，程序的控制流将会立即转移到相应的 catch 块。

catch 块：catch 块用于捕获和处理异常。在 catch 块中，我们可以指定捕获的异常类型，并提供相应的处理逻辑。当异常被抛出时，Java 会根据调用栈的顺序逐个匹配 catch 块，直到找到与抛出异常类型匹配的 catch 块。如果找到匹配的 catch 块，其中的代码将被执行；如果没有找到匹配的 catch 块，异常将会被传递到调用栈的上一层。

finally 块：finally 块用于定义一段无论是否发生异常都会执行的代码块。不论在 try 块中是否抛出了异常，finally 块中的代码都会被执行。finally 块通常用于释放资源、清理操作或确保某些关键代码一定会被执行。

下面是一个简单的示例代码，展示了 try...catch 和 finally 的使用：
 

public class Main {
    public static void main(String[] args) {
        try {
            int result = divide(10, 0);
            System.out.println("结果：" + result);
        } catch (ArithmeticException e) {
            System.out.println("除零异常：" + e.getMessage());
        } finally {
            System.out.println("无论是否发生异常，都会执行这里的代码");
        }
    }
 
    public static int divide(int num1, int num2) {
        return num1 / num2;
    }
}

在上述代码中，我们调用了 divide() 方法进行除法运算。由于除数为 0，会抛出 ArithmeticException 异常。在 main() 方法中的 try 块中，我们捕获了这个异常，并在 catch 块中处理异常。无论是否发生异常，finally 块中的代码都会被执行。 

总结一下，try...catch 用于捕获并处理可能发生的异常，finally 用于定义一段无论是否发生异常都会执行的代码块。它们在异常处理中起着重要的作用，可以确保程序的稳定性和安全性。

2.throws关键字
throws 关键字是用于方法声明中的一部分，用于表示方法可能抛出的异常类型。当一个方法可能会产生异常，但不想在方法内部进行异常处理时，可以使用 throws 关键字将异常抛出给方法的调用者处理。

使用 throws 关键字的语法如下：

返回类型 方法名(参数列表) throws 异常类型1, 异常类型2, ... {
    // 方法体
}

在方法声明中，可以指定一个或多个异常类型，使用逗号分隔。当方法内部可能会抛出被指定的异常类型时，就可以使用 throws 关键字将异常传递给方法的调用者。调用者可以选择捕获这些异常并进行处理，或者将异常继续向上层调用者传递。

下面是一个示例代码，展示了 throws 关键字的使用
 

public class Main {
    public static void main(String[] args) {
        try {
            process();
        } catch (IOException e) {
            System.out.println("发生了IO异常：" + e.getMessage());
        }
    }
 
    public static void process() throws IOException {
        // 可能会抛出IOException异常的代码
        throw new IOException("文件读取错误");
    }
}

在上述代码中，process() 方法声明使用了 throws IOException，表示该方法可能会抛出 IOException 异常。在 main() 方法中，我们调用了 process() 方法，并使用 try...catch 块捕获可能抛出的 IOException 异常进行处理。

使用 throws 关键字可以将异常的处理责任转移给方法的调用者，使得代码更加模块化和可维护。它提供了一种灵活的异常处理机制，使得异常处理可以在不同的层级进行，从而更好地组织和管理代码。

3.运行时异常和编译异常
运行时异常（Runtime Exception）和编译异常（Checked Exception）是 Java 异常体系中的两个主要类型。

运行时异常（Runtime Exception）：

1.运行时异常是指在程序执行过程中可能出现的异常情况。
2.运行时异常是 RuntimeException 类及其子类的实例，如 NullPointerException、ArithmeticException 等。
3.运行时异常通常是由程序逻辑错误或错误的输入引起的，例如访问空对象引用、除以零等。
4.运行时异常在编译时不需要强制捕获或声明，可以选择捕获和处理，也可以不捕获。如果没有显式处理运行时异常，程序将在发生异常时终止并抛出异常信息。
编译异常（Checked Exception）：

1.编译异常是指在程序编写过程中必须显式处理的异常。
2.编译异常是 Exception 类及其子类中除去运行时异常的其他异常，如 IOException、SQLException 等。
3.编译异常通常是由外部环境或资源错误引起的，例如文件读写错误、网络连接错误等。
4.编译异常在编译时要求强制捕获或声明，即要么使用 try...catch 块捕获异常并进行处理，要么在方法签名中使用 throws 关键字声明该异常。
区别：

1.运行时异常是在程序执行阶段才会被抛出，编译器不会对其进行强制检查，因此可以选择捕获或不捕获。
2.编译异常在编译阶段就会被检查，如果不进行处理（捕获或声明），编译器将会报错。
3.运行时异常通常是由程序逻辑错误引起的，而编译异常通常是由外部环境或资源错误引起的。
4.运行时异常是 RuntimeException 类及其子类，而编译异常是 Exception 类及其子类中除去运行时异常的其他异常。
总结：

1.运行时异常是可选的，可以选择捕获或不捕获，由程序员负责处理。
2.编译异常是强制的，需要进行显式处理，否则会导致编译错误。
3.运行时异常主要是程序逻辑错误引起的，编译异常主要是外部环境或资源错误引起的。
4.异常的处理方式取决于异常类型和具体业务需求，需要根据实际情况选择合适的处理方式。

4.自定义异常
在Java中，我们可以通过继承现有的异常类来自定义异常。自定义异常可以根据具体的业务需求来定义，并提供特定的异常信息和处理方式。

下面是创建自定义异常的步骤：

1.创建一个继承自现有异常类（如 Exception 或其子类）的新类。可以根据需要选择合适的异常类作为基类，例如 RuntimeException、IOException 等。

2.在自定义异常类中添加构造方法，用于初始化异常对象并设置异常信息。

3.可以选择添加其他自定义方法或属性，以提供更多的功能和灵活性。

下面是一个简单的例子，演示如何创建自定义异常类：
 

// 自定义异常类
class MyException extends Exception {
    public MyException(String message) {
        super(message);
    }
    
    // 自定义方法
    public void printErrorMessage() {
        System.out.println("自定义异常信息：" + getMessage());
    }
}
 
// 使用自定义异常
public class CustomExceptionExample {
    public static void main(String[] args) {
        try {
            // 抛出自定义异常
            throw new MyException("这是一个自定义异常");
        } catch (MyException e) {
            e.printStackTrace();
            e.printErrorMessage();
        }
    }
}

在上面的示例中，我们创建了一个名为 MyException 的自定义异常类，继承自 Exception 类。它具有一个带有异常信息的构造方法和一个自定义的方法 printErrorMessage()。在 CustomExceptionExample 类中，我们在 try 块中抛出了自定义异常，并在 catch 块中捕获并处理该异常。

自定义异常的好处是可以根据实际需求提供更具体和详细的异常信息，并根据业务逻辑定义异常的处理方式。这有助于更好地管理和调试代码，并提供有用的错误信息给开发人员或用户。

Java的四种访问级别

在Java中，有四种访问级别（访问修饰符）用于控制类、方法、变量和构造方法的可见性和访问范围。这些访问级别是：

公共（public）： 使用 public 修饰符表示最高级别的访问权限。公共成员可以被任何类访问，无论是同一个包中的类还是不同包中的类。

默认（默认访问级别）： 如果没有指定访问修饰符，即没有使用 public、private 或 protected，则成员具有默认访问级别。默认访问级别限定在同一个包中可见，对于不同包中的类则不可见。

受保护（protected）： 使用 protected 修饰符表示受保护的访问级别。受保护的成员在同一个包内可见，并且对于不同包中的子类也是可见的。

私有（private）： 使用 private 修饰符表示最低级别的访问权限。私有成员只能在同一个类中访问，对于其他类（包括同一包中的类和子类）都是不可见的。

下面是每个访问级别的总结：

public：对所有类可见。
默认（默认访问级别）：对同一包中的类可见。
protected：对同一包中的类和不同包中的子类可见。
private：仅对同一类可见。
通过正确选择适当的访问级别，可以实现封装性、安全性和灵活性。良好的访问级别设置可以提高代码的可维护性和可扩展性，并确保程序的安全性和正确性。

二.String类和StringBuffer类
String类和StringBuffer类都是Java中用于处理字符串的类，但它们在字符串的处理方式和特性上有一些区别。

String类：

不可变性：String类的对象是不可变的，一旦创建，其值不能被修改。每次对String对象的操作都会生成一个新的String对象。
线程安全：String类是不可变的，因此在多线程环境下可以被安全地共享。
字符串拼接：String类通过使用"+"操作符或concat()方法进行字符串拼接，但每次拼接操作都会生成一个新的String对象，因此频繁的字符串拼接会导致性能问题。
效率低：由于String对象的不可变性，每次对String对象进行修改或拼接操作都会生成新的对象，导致内存的频繁分配和垃圾回收，因此在频繁修改字符串内容的场景下，性能较低。
适用性：String类适用于不经常修改字符串内容的场景，如字符串常量、配置信息等。
 

StringBuffer类： 

可变性：StringBuffer类的对象是可变的，可以进行添加、修改、删除等操作，而不会生成新的对象。
线程安全：StringBuffer类是可变的，但为了保证线程安全性，StringBuffer提供了同步方法，可以在多线程环境下安全地进行字符串操作。
字符串拼接：StringBuffer类通过append()方法进行字符串拼接，可以直接在原始对象上修改，而不会生成新的对象，因此在频繁拼接字符串的场景下，性能更高。
效率高：由于StringBuffer对象是可变的，避免了频繁生成新的对象，因此在频繁修改字符串内容的场景下，性能较高。

适用性：StringBuffer类适用于需要频繁修改字符串内容的场景，如字符串拼接、字符串逆序等。
需要根据具体的需求选择使用String类还是StringBuffer类。如果字符串内容不会经常改变，且线程安全性不是关键问题，可以使用String类。如果字符串需要频繁修改，或在多线程环境下进行字符串操作，应选择StringBuffer类以确保线程安全和高效的字符串处理。此外，Java 5及以后的版本还提供了StringBuilder类，它与StringBuffer类类似，但不保证线程安全，适用于单线程环境下的高效字符串操作。 

1.String类的初始化
在Java中，可以使用多种方式对String类进行初始化。

字面值初始化：
String str1 = "Hello"; // 使用双引号括起来的字符串字面值进行初始化
String str2 = ""; // 空字符串

使用构造方法初始化：
String str3 = new String(); // 使用无参构造方法创建一个空字符串对象
String str4 = new String("World"); // 使用带参构造方法创建一个包含指定内容的字符串对象

使用字符数组初始化：
char[] charArray = {'H', 'e', 'l', 'l', 'o'};
String str5 = new String(charArray); // 使用字符数组初始化字符串对象

使用字节数组初始化：
byte[] byteArray = {72, 101, 108, 108, 111};
String str6 = new String(byteArray); // 使用字节数组初始化字符串对象

使用StringBuffer或StringBuilder对象初始化：     
StringBuffer buffer = new StringBuffer("Java");
String str7 = new String(buffer); // 使用StringBuffer对象初始化字符串对象

StringBuilder builder = new StringBuilder("Programming");
String str8 = new String(builder); // 使用StringBuilder对象初始化字符串对象

需要注意的是，String类是不可变的，即一旦创建，其值不能被修改。因此，对String对象的操作会生成一个新的String对象。使用字面值初始化的字符串会被放入常量池中，而使用构造方法或其他对象初始化的字符串会在堆内存中创建一个新的String对象。 

例如，使用字面值初始化的字符串可以被多个引用共享，而使用构造方法初始化的字符串每次都会创建一个新的对象。因此，在比较字符串时应使用equals()方法而不是"=="运算符，以确保比较的是字符串的内容而不是引用。

2.String类的常见操作

public class StringExample {
    public static void main(String[] args) {
        // 获取字符串长度
        String str = "Hello, World!";
        int length = str.length();
        System.out.println("字符串长度: " + length);
 
        // 字符串拼接
        String hello = "Hello";
        String world = "World";
        String greeting = hello + ", " + world;
        System.out.println("拼接后的字符串: " + greeting);
 
        // 字符串截取
        String sentence = "I love Java programming";
        String subString = sentence.substring(2, 6);
        System.out.println("截取的子字符串: " + subString);
 
        // 字符串查找
        String text = "Java is a widely used programming language";
        int index = text.indexOf("widely");
        System.out.println("字符串 \"widely\" 的索引位置: " + index);
 
        // 字符串替换
        String sentence2 = "I like cats. Cats are cute.";
        String replaced = sentence2.replace("cats", "dogs");
        System.out.println("替换后的字符串: " + replaced);
 
        // 字符串分割
        String fruits = "apple, banana, orange";
        String[] fruitArray = fruits.split(", ");
        System.out.println("分割后的字符串数组:");
        for (String fruit : fruitArray) {
            System.out.println(fruit);
        }
 
        // 字符串转换
        int num = Integer.parseInt("10");
        double value = Double.parseDouble("3.14");
        System.out.println("转换后的整数: " + num);
        System.out.println("转换后的浮点数: " + value);
    }
}

以上代码演示了String类的常见操作，包括获取字符串长度、字符串拼接、字符串截取、字符串查找、字符串替换、字符串分割和字符串转换。通过这些方法，可以方便地处理和操作字符串数据。

3.StringBuffer类
StringBuffer类是Java中可变的字符串类，它与String类的区别在于StringBuffer对象的值是可以修改的，而String对象的值是不可修改的。StringBuffer类提供了许多方法用于对字符串进行增删改查操作。

以下是StringBuffer类的一些常见操作：

public class StringAndStringBufferExample {
    public static void main(String[] args) {
        // String类的初始化
        String str1 = "Hello";
        String str2 = new String("World");
 
        // 字符串拼接
        String str3 = str1 + ", " + str2;
        System.out.println("拼接后的字符串：" + str3);
 
        // 字符串比较
        boolean isEqual = str1.equals(str2);
        System.out.println("字符串比较结果：" + isEqual);
 
        // String类的常见操作
        String str = "Hello, Java";
        int length = str.length();
        char ch = str.charAt(7);
        String subString = str.substring(7);
        System.out.println("字符串长度：" + length);
        System.out.println("第8个字符：" + ch);
        System.out.println("子字符串：" + subString);
 
        // StringBuffer类的使用
        StringBuffer sb = new StringBuffer();
        sb.append("Hello");
        sb.append(" World");
        sb.insert(5, ", Java");
        sb.delete(5, 10);
        sb.replace(0, 5, "Hi");
        sb.reverse();
 
        // 将StringBuffer对象转换为String对象
        String result = sb.toString();
        System.out.println("最终结果：" + result);
    }
}

上述示例演示了String类和StringBuffer类的常见操作。通过String类可以进行字符串的创建、拼接、比较以及获取子字符串等操作。而StringBuffer类则可以进行字符串的追加、插入、删除、替换以及反转等可变操作。这些操作使得字符串的处理更加灵活和高效。

4.System类
System 类是 Java 中的一个系统类，提供了与系统相关的一些方法和字段。它包含了标准输入、标准输出、错误输出流的访问方法，以及获取当前时间、获取系统属性等功能。

下面是 System 类的一些常用方法和字段：

out：标准输出流，类型为 PrintStream，可以使用 System.out.println() 方法将数据打印到控制台。
in：标准输入流，类型为 InputStream，可以使用 System.in.read() 方法从控制台读取输入数据。
err：错误输出流，类型为 PrintStream，用于输出错误信息。
currentTimeMillis()：静态方法，返回当前时间的毫秒数，用于计算程序执行时间等。
getProperty(String key)：静态方法，获取系统属性值，例如 System.getProperty("java.version") 可以获取 Java 的版本号。
exit(int status)：静态方法，用于终止当前正在运行的 Java 虚拟机。
除了上述方法和字段，System 类还提供了其他一些与系统相关的方法，例如 arraycopy() 用于数组的复制，gc() 用于运行垃圾回收器等。

使用 System 类可以方便地与系统交互，进行输入输出操作，获取系统信息和属性，以及控制程序的执行流程。

5.Runtime类
Runtime 类提供了与运行时环境交互的方法，以下是一些常用的 Runtime 类方法：

exec(String command)：在单独的进程中执行指定的命令。
totalMemory()：返回 Java 虚拟机中的总内存量。
freeMemory()：返回 Java 虚拟机中的空闲内存量。
maxMemory()：返回 Java 虚拟机的最大内存量。
gc()：运行垃圾回收器。
这些方法允许你在程序中与底层运行时环境进行交互。例如，exec() 方法可以用于执行外部命令，totalMemory() 和 freeMemory() 方法可以用于监控内存使用情况，gc() 方法可以手动触发垃圾回收。

需要注意的是，Runtime 类的构造函数是私有的，因此不能直接实例化 Runtime 对象，而是通过 Runtime.getRuntime() 方法获取一个 Runtime 实例。

以下是一个示例代码，展示了如何使用 Runtime 类的方法：

public class RuntimeExample {
    public static void main(String[] args) {
        Runtime runtime = Runtime.getRuntime();
 
        try {
            // 在单独的进程中执行命令
            Process process = runtime.exec("notepad.exe");
            process.waitFor();
 
            // 获取内存信息
            long totalMemory = runtime.totalMemory();
            long freeMemory = runtime.freeMemory();
            long maxMemory = runtime.maxMemory();
 
            System.out.println("Total Memory: " + totalMemory);
            System.out.println("Free Memory: " + freeMemory);
            System.out.println("Max Memory: " + maxMemory);
 
            // 手动触发垃圾回收
            runtime.gc();
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
        }
    }
}

上述代码演示了如何执行外部命令、获取内存信息以及手动触发垃圾回收操作。请注意，exec() 方法可能会抛出 IOException，而 waitFor() 方法可能会抛出 InterruptedException，因此需要适当处理这些异常。

6.Math类
Math 类是 Java 提供的一个数学工具类，它包含了许多常用的数学方法和常量。你可以直接使用 Math 类来执行各种数学运算，无需创建实例。

下面是一些 Math 类的常用方法和常量：

常量：

Math.PI：表示圆周率 π 的近似值。
Math.E：表示自然对数的底数 e 的近似值。
数值计算方法：

Math.abs(x)：返回参数 x 的绝对值。
Math.sqrt(x)：返回参数 x 的平方根。
Math.pow(x, y)：返回 x 的 y 次幂。
Math.exp(x)：返回 e 的 x 次幂。
Math.log(x)：返回参数 x 的自然对数（以 e 为底）。
Math.log10(x)：返回参数 x 的以 10 为底的对数。
Math.sin(x)、Math.cos(x)、Math.tan(x)：返回参数 x 的正弦、余弦和正切值。
Math.asin(x)、Math.acos(x)、Math.atan(x)：返回参数 x 的反正弦、反余弦和反正切值。
Math.max(x, y)：返回 x 和 y 中的较大值。
Math.min(x, y)：返回 x 和 y 中的较小值。
Math.round(x)：将参数 x 四舍五入为最接近的整数。
随机数生成：

Math.random()：返回一个 [0,1) 范围内的随机 double 值。
Math 类提供了许多用于数学计算的方法，可以进行各种常见的数值操作，如求绝对值、平方根、幂运算、三角函数、对数函数等。它还提供了常量 π 和 e，方便在数学计算中使用。

幂和指数运算：

double pow(double base, double exponent)：返回指定基数的指定次幂。
double sqrt(double value)：返回给定值的平方根。
double cbrt(double value)：返回给定值的立方根。
double exp(double value)：返回自然对数的底数 e 的给定次幂。
double log(double value)：返回给定值的自然对数（以 e 为底）。
double log10(double value)：返回给定值的以 10 为底的对数。
三角函数运算：

double sin(double angle)：返回给定角度的正弦值。
double cos(double angle)：返回给定角度的余弦值。
double tan(double angle)：返回给定角度的正切值。
double asin(double value)：返回给定值的反正弦值。
double acos(double value)：返回给定值的反余弦值。
double atan(double value)：返回给定值的反正切值。
double toRadians(double degrees)：将给定角度转换为弧度。
double toDegrees(double radians)：将给定弧度转换为角度。
取整和舍入运算：

int abs(int value)：返回给定整数的绝对值。
double abs(double value)：返回给定浮点数的绝对值。
int max(int a, int b)：返回两个整数中较大的值。
double max(double a, double b)：返回两个浮点数中较大的值。
int min(int a, int b)：返回两个整数中较小的值。
double min(double a, double b)：返回两个浮点数中较小的值。
int round(float value)：将给定浮点数四舍五入为最接近的整数。
long round(double value)：将给定浮点数四舍五入为最接近的长整数。
int ceil(double value)：返回不小于给定浮点数的最小整数。
int floor(double value)：返回不大于给定浮点数的最大整数。

7.Random类
Random 类是 Java 提供的一个随机数生成器类，用于生成伪随机数序列。它可以用于各种需要随机性的场景，如游戏、密码生成、随机排序等。

下面是 Random 类的一些常用方法：

构造方法：

Random()：创建一个新的 Random 对象，使用默认的种子。
生成随机数：

nextInt()：返回一个随机的 int 值。
nextInt(int bound)：返回一个范围在 [0, bound) 的随机 int 值。
nextLong()：返回一个随机的 long 值。
nextDouble()：返回一个范围在 [0.0, 1.0) 的随机 double 值。
nextBoolean()：返回一个随机的 boolean 值。
nextFloat()：返回一个范围在 [0.0, 1.0) 的随机 float 值。
设置种子：

setSeed(long seed)：设置随机数生成器的种子，用于确定随机数序列的起始值。
Random 类提供了一系列方法用于生成随机数，其中 nextInt() 是最常用的方法之一。你可以根据需要选择不同的方法来生成不同类型的随机数。通过设置种子，你可以控制随机数序列的起始值，从而使随机数序列可预测或可重复。

以下是一个使用 Random 类的示例代码：

import java.util.Random;
 
public class RandomExample {
    public static void main(String[] args) {
        Random random = new Random();
 
        // 生成随机整数
        int randomNumber = random.nextInt();
        System.out.println("Random number: " + randomNumber);
 
        // 生成范围在 [0, 10) 的随机整数
        int boundedRandomNumber = random.nextInt(10);
        System.out.println("Bounded random number: " + boundedRandomNumber);
 
        // 生成随机布尔值
        boolean randomBoolean = random.nextBoolean();
        System.out.println("Random boolean: " + randomBoolean);
 
        // 生成范围在 [0.0, 1.0) 的随机浮点数
        double randomDouble = random.nextDouble();
        System.out.println("Random double: " + randomDouble);
    }
}

8.包装类
在Java中，基本数据类型（如int、double、boolean等）是不具备对象特性的，无法直接参与面向对象的操作。为了使基本数据类型具备对象特性，Java提供了对应的包装类（Wrapper Class）。

包装类是一种将基本数据类型封装为对象的方式，每个基本数据类型都有对应的包装类。Java提供了8个基本数据类型的包装类，分别是：

Integer：对应int类型
Double：对应double类型
Boolean：对应boolean类型
Character：对应char类型
Byte：对应byte类型
Short：对应short类型
Long：对应long类型
Float：对应float类型
包装类提供了一系列方法来操作基本数据类型，例如转换为字符串、类型转换、比较等。此外，包装类还提供了常量和静态方法来处理基本数据类型的特定需求。

使用包装类的主要场景包括：

在集合类中存储基本数据类型的对象。
在泛型中使用基本数据类型。
通过包装类提供的方法进行基本数据类型的转换和操作。
以下是一些常见的包装类方法和用法：

自动装箱和拆箱：

自动装箱：将基本数据类型自动转换为对应的包装类对象。例如：Integer num = 10;
自动拆箱：将包装类对象自动转换为对应的基本数据类型。例如：int value = num;
值的获取和设置：

int intValue()：获取Integer对象的int值。
void setValue(int value)：设置Integer对象的值。
字符串转换：

static String toString(int value)：将int类型的值转换为字符串。
static int parseInt(String str)：将字符串转换为int类型的值。
类型转换：

double doubleValue()：将包装类对象转换为double类型的值。
int intValue()：将包装类对象转换为int类型的值。
boolean booleanValue()：将包装类对象转换为boolean类型的值。
比较操作：

int compareTo(Integer anotherInteger)：比较两个Integer对象的大小关系。
boolean equals(Object obj)：判断两个包装类对象是否相等。
使用包装类可以方便地处理基本数据类型的对象化需求，同时也提供了丰富的方法和功能来操作基本数据类型。需要注意的是，由于包装类是对象，因此在比较两个包装类对象是否相等时，应使用equals()方法而不是==运算符。

以下是一个示例代码，演示了使用包装类的一些常见操作：

public class WrapperClassExample {
    public static void main(String[] args) {
        Integer num1 = 10; // 自动装箱
        Integer num2 = Integer.valueOf("20"); // 字符串转换为Integer对象
 
        System.out.println("num1: " + num1);
        System.out.println("num2: " + num2);
 
        int value1 = num1.intValue(); // 获取Integer对象的int值
        int value2 = Integer.parseInt("30"); // 字符串转换为int类型的值
 
        System.out.println("value1: " + value1);
        System.out.println("value2: " + value2);
 
        System.out.println("num1 + num2: " + (num1 + num2)); // 自动拆箱和数值计算
 
        System.out.println("num1.compareTo(num2): " + num1.compareTo(num2)); // 比较大小
        System.out.println("num1.equals(num2): " + num1.equals(num2)); // 判断相等
    }
}

上述代码展示了Integer包装类的使用，包括自动装箱和拆箱、值的获取和设置、字符串转换、类型转换、比较操作等。根据实际需求，可以使用对应的包装类来处理基本数据类型的对象化操作。

9.JDK的新特性-switch语句支持字符串类型
在Java 7及之前的版本中，switch语句只支持整型、枚举和字符类型的表达式作为条件。然而，从Java 7开始，JDK引入了一个新的特性，即switch语句支持字符串类型作为条件表达式。

使用字符串类型的switch语句可以根据不同的字符串值执行相应的代码块，使代码逻辑更加清晰和简洁。以下是使用字符串类型的switch语句的基本语法：
 

String variable = "value";
 
switch (variable) {
    case "value1":
        // 执行与"value1"匹配的代码块
        break;
    case "value2":
        // 执行与"value2"匹配的代码块
        break;
    // 可以添加更多的case语句
    default:
        // 当没有任何case匹配时执行的代码块
}

在上述代码中，variable是一个字符串类型的变量，它可以根据不同的值执行相应的代码块。每个case标签表示一个可能的匹配值，当variable的值与某个case标签的值相等时，对应的代码块将被执行。如果没有任何case匹配，可以使用default关键字指定默认的代码块。

需要注意的是，字符串类型的switch语句在匹配时是基于值的比较，而不是基于引用的比较。这意味着两个不同的字符串对象，即使包含相同的字符序列，也被视为不同的值。

使用字符串类型的switch语句可以提高代码的可读性和维护性，尤其是在处理多个字符串值时。它使得代码更加直观，避免了使用大量的if-else语句。然而，需要注意在使用字符串类型的switch语句时，要确保考虑到所有可能的字符串值，并处理好默认情况，以避免意外的逻辑错误。

总结一下，JDK的新特性使得switch语句支持字符串类型，可以根据不同的字符串值执行相应的代码块，提高代码的可读性和简洁性。

结束力