JAVA SE学习day_07:异常处理、TCP通信

痛定思痛。 2023-03-12 13:29 41阅读 0赞

### 一、异常中常见的方法 ###

public static void main(String[] args) { 
    		System.out.println("程序开始了");
    		try { 
    			String str = "";
    			/* * 当我们将一个字符串解析为基本类型时,如果字符串内容不能正确 * 表示基本类型值时,就会抛出NumberFormatException */
    			System.out.println(Integer.parseInt(str));
    		} catch (Exception e) { 
    			System.out.println("出错了!");
    			//输出错误堆栈信息,便于debug
    			e.printStackTrace();
    			//获取错误消息
    			String message = e.getMessage();
    			System.out.println(message);
    		}
    		System.out.println("程序结束了");
    	}

### 二、自定义异常 ###

**通常自定义异常用在符合语法但是不符合业务逻辑问题时的异常。**

*  自定义异常最重要的就是名字，要做到见名知意  
    **自定义异常实现步骤:：**
 *  1:定义类名
 *  2:继承Exception(直接或间接继承)
 *  3:提供所有构造方法
 *  4:定义序列化版本号(避免代码出现警告)

public class IllegalAgeException extends Exception{ 
    
    	/** * 序列号 */
    	private static final long serialVersionUID = 1L;
    /* *右键选中Source后选定Generate Constructors from Superclass... *生成下列内容 */
    	public IllegalAgeException() { 
    		super();
    		// TODO Auto-generated constructor stub
    	}
    
    	public IllegalAgeException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) { 
    		super(message, cause, enableSuppression, writableStackTrace);
    		// TODO Auto-generated constructor stub
    	}
    
    	public IllegalAgeException(String message, Throwable cause) { 
    		super(message, cause);
    		// TODO Auto-generated constructor stub
    	}
    
    	public IllegalAgeException(String message) { 
    		super(message);
    		// TODO Auto-generated constructor stub
    	}
    
    	public IllegalAgeException(Throwable cause) { 
    		super(cause);
    		// TODO Auto-generated constructor stub
    	}
    	
    	
    }

### 三、throw（异常的抛出） ###

throw关键字用于主动对外抛出一个异常  
通常以下两种情况会主动抛出异常:  
\* 1:满足语法，但是不满足业务逻辑要求(当前案例一就是这个情况)。  
\* 2:当前方法确实执行时出现了异常，但是当前方法不应该处理这个异常时，可以抛出给调用当前方法的代码片段去处理。

public void setAge(int age) throws IllegalAgeException { 
    		if(age<0||age>100) { 
    			/* * 当我们使用throw抛出一个异常时(除了RuntimeException及其子类型 * 异常)编译器要求我们必须处理该异常。而这里处理异常的方式就是在 * 当前方法上使用throws声明该异常的抛出 */
    			throw new IllegalAgeException("年龄不合法!");
    		}
    		this.age = age;
    	}

当调用一个含有throws声明异常抛出的方法时，编译器要求我们必须定义**处理异常的手段**，而处理异常有两种方式:  
\* 1:使用try-catch捕获其抛出的异常  
\* 2:在当前方法上继续使用throws声明该异常的抛出。  
具体使用哪种视处理异常的责任而定，需要当前代码片段处理的就try-catch 否则就继续往外抛。但是永远不应当在main方法上声明throws。

public static void main(String[] args) { 
    		System.out.println("程序开始了...");
    		Person p = new Person();
    		/* * 满足语法，但是不满足业务逻辑要求 */
    		try { 
    			p.setAge(10000);
    		} catch (IllegalAgeException e) { 
    			e.printStackTrace();
    		}
    
    		System.out.println("今年:"+p.getAge()+"岁");
    		System.out.println("程序结束了...");
    
    	}

### 四、throws ###

子类重写父类含有throws声明异常抛出的方法时，重写throws的一些特殊规则

public class ThrowsDemo { 
    
    	public void dosome() throws IOException,AWTException{ 
    		
    		}
    	}
    
    	class SubClass extends ThrowsDemo{ 
    	允许抛出父类所有的异常
    	public void dosome() throws IOException,AWTException{ 	
    	}
    	
    	允许不再抛出任何异常
    	public void dosome(){ 
    		
    	}
    	
    	允许仅抛出父类方法抛出的部分异常
    	public void dosome() throws IOException{ 
    		
    	}
    	允许抛出父类方法抛出异常的子类型异常
    	public void dosome() throws FileNotFoundException{ 
    		
    	}
    	
    	
    	不允许抛出额外的异常(父类方法没有抛出的异常,也不是子类型异常)
    	public void dosome() throws SQLException{ 
    		
    	}
    	
    	不允许抛出父类方法抛出异常的父类型异常
    	public void dosome() throws Exception{ 
    		
    	}
    
    }

### 五、TCP通信的实现 ###

**java.net.Socket 套接字**  
Socket封装了TCP协议的通讯细节，使用它就可以与服务端建立网络连接了，并且进行通讯。这里的通讯是以两条流的读写完成与服务端的数据交换的。  
**Socket提供的方法:**  
\* OutputStream getOutputStream()  
\* 通过socket的该方法获取的输出流写出的字节会通过网络发送给远端计算机。  
\* InputStream getInputStream();  
\* 通过该方法获取的输入流读取的字节是远端计算机发送过来的字节

#### **客户端实例化Socket时需要传入两个参数:** ####

*  1:服务端的地址信息(IP)
 *  2:服务端打开的端口

#### **服务端使用的是ServerSocket** ####

它有两个作用:  
\* 1:向系统申请端口。  
\* 2:接收请求该端口的所有客户端的连接。  
**实例化ServerSocket**  
实例化的同时向系统申请服务端口，客户端Socket就是通过这个端口与服务端建立连接的。  
\* 如果该端口被系统其他程序占用了则会抛出异常:  
\* java.net.BindException:address already in use: JVM\_bind  
\*  
\* 遇到该错误时解决办法:  
\* 1:首先检查是否自己开启过两次服务端，因为第一次启动已经占用了 该端口，如果再启动一遍时还申请该端口就会提示被占用了。  
\* 2:如果没有启动过两次，那说明系统其他程序占用该端口了，需要更换一个可用的。  
**ServerSocket提供的方法:**  
\* Socket accept()  
\* 该方法是一个阻塞方法，调用该方法后程序"卡住",此时开始等待客户端的连接，一旦客户端实例化Socket并连接服务端这边申请的端口(8088)时，accept方法会立即返回一个Socket实例，此时等于和客户端建立了连接。服务端通过返回的这个Socket就可以与客户端进行交互了。  
\* 多次调用accept方法可以接收多个客户端的连接。

#### 5.1聊天室客户端 ####

package socket;
    
    import java.io.BufferedWriter;
    import java.io.OutputStream;
    import java.io.OutputStreamWriter;
    import java.io.PrintWriter;
    import java.net.Socket;
    import java.util.Scanner;
    
    /** * 聊天室的客户端 * @author 毛 * */
    public class Client { 
    	/* * java.net.Socket 套接字 * Socket封装了TCP协议的通讯细节，使用它就可以与服务端建立网络连接了， * 并且进行通讯。这里的通讯是以两条流的读写完成与服务端的数据交换的。 */
    	private Socket socket;
    	/** * 客户端构造方法，用于初始化客户端 */
    	public Client() { 
    		try { 
    			/* * 实例化Socket时需要传入两个参数: * 1:服务端的地址信息(IP) * 2:服务端打开的端口 * * 我们可以通过IP找到网络上的服务端计算机，通过其打开的端口 * 可以连接到服务端应用程序。 */
    			System.out.println("正在连接服务端...");
    			socket = new Socket("localhost",8088);
    			System.out.println("已连接服务端!");
    		} catch (Exception e) { 
    			e.printStackTrace();
    		}
    	}
    	/** * 客户端开始工作的方法 */
    	public void start() { 
    		try { 
    			
    			/* * Socket提供的方法: * OutputStream getOutputStream() * 通过socket的该方法获取的输出流写出的字节会通过网络发送给远端计算机。 */
    			OutputStream out = socket.getOutputStream();
    			
    			OutputStreamWriter osw = new OutputStreamWriter(out,"UTF-8");
    			BufferedWriter bw = new BufferedWriter(osw);
    			PrintWriter pw = new PrintWriter(bw,true);
    			
    			Scanner scanner = new Scanner(System.in);
    			while(true) { 
    				String message = scanner.nextLine();
    				pw.println(message);
    			}
    			
    		} catch (Exception e) { 
    			e.printStackTrace();
    		}
    	}
    	
    	public static void main(String[] args) { 
    		Client client = new Client();
    		client.start();
    	}
    }

#### 5.2聊天室服务端 ####

package socket;
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    /** * 聊天室的客服端 * @author 毛 * */
    public class Server { 
    	/* * 服务端使用的是ServerSocket * 它有两个作用: * 1:向系统申请端口。 * 2:接收请求该端口的所有客户端的连接。 */
    	private ServerSocket server;
    	/** * 服务端构造方法，用来初始化服务端 */
    	public Server() { 
    		try { 
    			/* * 实例化的同时向系统申请服务端口，客户端Socket就是通过这个端口与服务端建立连接的。 * 如果该端口被系统其他程序占用了则会抛出异常: * java.net.BindException:address already in use: JVM_bind * * 遇到该错误时解决办法: * 1:首先检查是否自己开启过两次服务端，因为第一次启动已经占用了 * 该端口，如果再启动一遍时还申请该端口就会提示被占用了。 * 2:如果没有启动过两次，那说明系统其他程序占用该端口了，需要更 * 换一个可用的。 */
    			System.out.println("正在启动服务端...");
    			server = new ServerSocket(8088);
    			System.out.println("服务端启动完毕!");
    		} catch (IOException e) { 
    			e.printStackTrace();
    		}
    	}
    	/** * 服务端开始工作的方法 */
    	public void start() { 
    		try { 
    			/* * ServerSocket提供的方法: * Socket accept() * 该方法是一个阻塞方法，调用该方法后程序"卡住",此时开始等待 * 客户端的连接，一旦客户端实例化Socket并连接服务端这边申请的 * 端口(8088)时，accept方法会立即返回一个Socket实例，此时等于 * 和客户端建立了连接。服务端通过返回的这个Socket就可以与客户端 * 进行交互了。 * 多次调用accept方法可以接收多个客户端的连接。 */
    			System.out.println("等待客户端连接...");
    			Socket socket = server.accept();
    			System.out.println("一个客户端连接了!");
    			/* * Socket提供的方法: * InputStream getInputStream(); * 通过该方法获取的输入流读取的字节是远端计算机发送过来的字节 */
    			InputStream in = socket.getInputStream();
    			InputStreamReader isr = new InputStreamReader(in,"UTF-8");
    			BufferedReader br = new BufferedReader(isr);
    			
    			String message = "";
    			while((message = br.readLine())!=null) { 
    				System.out.println("客户端说:"+message);
    			}
    		} catch (Exception e) { 
    			e.printStackTrace();
    		}
    	}
    	
    	public static void main(String[] args) { 
    		Server server = new Server();
    		server.start();
    	}
    
    }