throws和try catch使用场景

try catch是一种错误处理机制，当代码中出现错误时可以使用try catch来捕捉异常并进行处理。如果在try中发生了错误，程序会跳转到catch并执行其中的代码。这种机制可以帮助我们避免程序崩溃，提高代码的健壮性。

相关问题

在setAge(int age)中对年龄进行判断，如果年龄介于1到100直接赋值，否则抛出异常 在测试类中创建对象并调用setAge(int age)方法使用try-catch捕获并处理异常

在Java中，如果你想在`setAge`方法中对输入的年龄进行有效性检查，你可以这样做：

首先，在`Person`类的`setAge`方法中添加如下代码：

public class Person {
    private int age;

    public void setAge(int age) throws IllegalArgumentException {
        if (age < 1 || age > 100) {
            throw new IllegalArgumentException("Age must be between 1 and 100.");
        } else {
            this.age = age;
        }
    }

    // 其他方法...
}

这里，我们使用了`throws`关键字声明`setAge`方法可能抛出`IllegalArgumentException`。如果年龄不在指定范围内，就会通过`throw new IllegalArgumentException(...)`语句抛出异常。

接着，在测试类（如`TestPerson`）中，你可以创建`Person`对象并调用`setAge`方法，同时用`try-catch`来捕获并处理可能出现的异常：

public class TestPerson {
    public static void main(String[] args) {
        try {
            Person person = new Person();
            person.setAge(25); // 正确设置年龄
            person.setAge(150); // 违反年龄限制，会抛出异常
        } catch (IllegalArgumentException e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

在这个测试场景中，如果年龄小于1或大于100，`setAge(150)`将会触发异常，然后`catch`块会捕获这个异常并打印出错误信息。

Java中 BIO的代码示例和使用场景

BIO全称是Blocking I/O，即阻塞I/O，在Java中主要体现在`java.io`包下的`InputStream`、`OutputStream`等流处理上。当从网络或其他源读取数据时，如果数据不可立即获取，BIO会一直阻塞等待，直到数据可用。

下面是一个简单的BIO网络通信的代码示例，使用`Socket`和`PrintWriter`进行服务器端和客户端的连接：

**服务器端（Server.java）**:

import java.io.*;
import java.net.*;

public class Server {
    public static void main(String[] args) throws IOException {
        ServerSocket server = new ServerSocket(8000);
        Socket client = null;

        while ((client = server.accept()) != null) {
            Thread thread = new Thread(new ClientHandler(client));
            thread.start();
        }
    }
}

class ClientHandler implements Runnable {
    private final Socket socket;

    public ClientHandler(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        try (BufferedReader reader = new BufferedReader(
                new InputStreamReader(socket.getInputStream()));
             PrintWriter writer = new PrintWriter(socket.getOutputStream(), true)) {

            String requestLine;
            while ((requestLine = reader.readLine()) != null) {
                System.out.println("Received: " + requestLine);
                writer.println("Hello from Server!");
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

**客户端（Client.java）**:

import java.io.*;
import java.net.InetAddress;
import java.net.UnknownHostException;

public class Client {
    public static void main(String[] args) {
        try {
            String host = "localhost";
            int port = 8000;

            Socket socket = new Socket(InetAddress.getByName(host), port);

            try (BufferedWriter writer = new BufferedWriter(
                    new OutputStreamWriter(socket.getOutputStream()));
                 BufferedReader reader = new BufferedReader(
                     new InputStreamReader(socket.getInputStream()))) {

                writer.write("GET / HTTP/1.1\n");
                writer.newLine();
                writer.write("Host: " + host + "\n");
                writer.newLine();
                writer.write("Connection: close\n");
                writer.newLine();

                System.out.println("Sent request to " + host + ":" + port);

                String responseLine;
                while ((responseLine = reader.readLine()) != null) {
                    System.out.println("Received: " + responseLine);
                }

            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (socket != null) {
                    try {
                        socket.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

BIO的主要应用场景是在并发不是特别高的场景下，因为其同步阻塞的特性，不适合大量并发连接的高性能网络服务，比如Web服务器。在现代应用中，非阻塞I/O（NIO）和反应式编程更受欢迎，它们提供了解决高并发的能力。