Java语言高级-05异常与多线程-第1节 异常

于 2022-09-11 11:16:41 发布
阅读量172 收藏
点赞数
分类专栏： Java学习教程 文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37975179/article/details/126571995
版权

异常概念&异常体系
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
异常分类
在这里插入图片描述

package demo21;

import java.text.SimpleDateFormat;
import java.util.Date;

import com.sun.xml.internal.messaging.saaj.packaging.mime.internet.ParseException;

/*
	java.lang.Throwable:类是Java语言中所有的错误或异常的超类
	Exception：编译器异常，进行编译(写代码)java程序出现的问题
	RuntimeException：运行期异常，java程序运行过程中出现的问题
	异常就相当于程序得了一个小毛病（感冒，发烧），把异常处理掉，程序可以继续执行（吃点药，打点滴，）
	Error：错误
	错误就相当于程序得了一个无法治愈的毛病
 */
public class Demo01Exception {
	public static void main(String[] args)/*throws ParseException*/{
		//Exception:编译期异常，进行编译(写代码)Java程序出现的问题
		/*SimpleDateFormat sdf = new SimpleDateFormat("yyyy-NM-dd");//用来格式化日期
		Date date = null;
	
		try {
			date = sdf.parse("1999-0909");//把字符串格式的日期，解析为Date格式的日期
		} catch (ParseException e) {
			e.printStackTrace();
		} 
		System.out.println(date);*/
		
		//RuntimeException;运行期异常，Java程序运行过程中出现的问题
		
		/*int[] arr = {1,2,3};
		//System.out.println(arr[0]);
		try {
			//可能会出现异常的代码
			System.out.println(arr[3]);
		}catch(Exception e) {
			//异常的处理逻辑
			System.out.println(e);//java.lang.ArrayIndexOutOfBoundsException
		}*/
		
		/*
		 Error：错误
		 int[] arr = new int[1024*1024*1024];
		//必须修改代码，创建的数组小一点
		 OutOfMemoryError:Java heap space
		 内存溢出的错误，创建的数组太大了，超出了给Java分配的字符
		 */
		
		System.out.println("后续代码");
	}
}

异常的产生过程解析
在这里插入图片描述

package demo21;
/*
异常产生过程解析(分析异常是怎么产生的，如何处理异常)
 */
public class Demo02Exception {

	public static void main(String[] args) {
		// 创建int类型的数组并赋值
		int[] arr = {1,2,3};
		int e = getElement(arr,3);//java.lang.ArrayIndexOutOfBoundsException: 3
		System.out.println(e);
	}

	/*
	定义一个方法，获取数组指定索引处的元素
	参数：
	int[] arr
	int index
	 */
	public static int getElement(int[] arr,int index) {
		int ele = arr[index];
		return ele;
	}
}

throw关键字
在这里插入图片描述

package demo21;
/*
	throw关键字
	作用：
		可以使用throw关键字在指定的方法中抛出指定的异常
	使用格式
		throw new XXXException("异常产生的原因");
	注意：
		1、throw关键字必须写在方法地内部
		2、throw关键字后边new地对象必须是Exception或者Exception的子类对象
		3、throw关键字抛出指定的异常对象，我们就必须处理这个异常
			throw关键字后边创建的是RunTimeException或者是RunTimeException的子类对象，
			我们可以不处理，默认交给jvm处理（打印异常对象，中断程序）
			throw关键字后边若创建的是编译异常(写代码的时候报错)，我们就必须处理这个异常，
			要么throws，要么try...catch...
			
 */
public class Demo03Throw {

	public static void main(String[] args) {
		//int[] arr = null;
		int[] arr = new int[3];
		int e = getElement(arr,3);
		System.out.println(e);//java.lang.NullPointerException: 传递的数组的值是null
		
	}
 
	/*
	定义一个方法，获取数组指定索引处的元素
	参数：
	int[] arr
	int index
	工作中我们首先就必须对方法传递过来的参数进行合法性校验
	如果参数不合适，那么我们就必须使用抛出异常的方式，告知方法的调用者，
	传递的参数有问题
	注意：
		NullPointerException是一个运行期异常，我们不用处理，默认交给jvm处理
		ArrayIndexOutOfBoundsException是一个运行期异常，我们不用处理，默认交给jvm处理
	 */
	public static int getElement(int[] arr,int index) {
		/*
		 我们可以对传递过来的参数数组，进行合法性校验
		 如果数组arr的值是null
		 那么我们就抛出空指针异常，告知方法的调用者"传递的数组的值是null"
		 */
		if(arr == null) {
			throw new NullPointerException("传递的数组的值是null");
		}
		/*
		我们可以对传递过来的参数index进行合法性校验
		如果index的范围不在数组的索引范围内
		那么我们就抛出数组索引越界异常，告知方法的调用者"传递的索引超出了数组的使用范围"
		 */
		if(index<0 || index>arr.length-1) {
			throw new ArrayIndexOutOfBoundsException("传递的索引超出了数组的使用范围");
		}
		int ele = arr[index];
		return ele;
	}
}

Objects非空判断requireNonNul
在这里插入图片描述

package demo21;

import java.util.Objects;

/*
Objects类中的静态方法
public static <T> T requireNonNull(T obj):查看指定引用对象不是null
源码：
	public static <T> T requireNonNull(T obj){
		if(obj == null)
			throw new NullPointerException();
		return obj;	
	}
 */
public class Demo04Objects {
	public static void main(String[] args) {
		method(null);
	}

	public static void method(Object obj) {
		//对传递过来的参数进行合理判断，判断是否为null
		if(obj == null) {
			throw new NullPointerException("传递的对象值是null");//java.lang.NullPointerException: 传递的对象值是null
		}
		
		//Objects.requireNonNull(obj);
		Objects.requireNonNull(obj,"传递的对象值是null");
		
	}
}

throws关键字异常处理的第一种方法
在这里插入图片描述

package demo21;

import java.io.FileNotFoundException;
import java.io.IOException;

/*
throws关键字：异常处理的第一种方式，交给别人处理
作用：
	当方法内部抛出异常对象的时候，那么我们就必须处理这个异常
	可以使用throws关键字处理异常对象，会把异常对象声明给抛出给方法的调用者处理
	(自己不处理，给别人处理)，最终交付给JVM处理-->中断处理
使用格式：在方法声明时使用
修饰符 返回值类型 方法名称(参数列表) throws AAAExceptions,BBBException...{
	throw new AAAExceptions("产生原因");
	throw new BBBExceptions("产生原因");
}	
	
	注意：
	1、throws关键字必须写在方法声明处
	2、throws关键字后边声明的异常必须是Exception或者是Exception的子类
	3、方法内部如果抛出了多个异常对象，那么throws后边必须也声明多个异常
	如果抛出的多个异常对象就有父子类关系，那么直接声明父类异常即可
	4、调用了一个声明抛出异常的方法，我们就必须得处理声明的异常
	要么继续调用throws声明抛出，交给方法的调用者处理，最终交给JVM
	要么try catch自己处理异常
 */
public class Demo05Throws {
	/*
	FileNotFoundException extends IOException extends Exception
	如果抛出多个异常对象有父子关系，那么直接声明父类异常即可
	 */
	//public static void main(String args) throws FileNotFoundException ,IOException{
	//public static void main(String args) throws IOException{
	public static void main(String args) throws Exception{
		readFile("c:\\a.xt");
	}
	
	/*
	 定一个方法，对传递的文件路径进行合法性的判断
	 如果路劲不是"c:\\a.txt"，那么我们就跳出文件找不到异常对象，告知方法的调用者
	 注意：
	 	FileNotFoundException是编译异常，抛出了编译异常，就必须处理这个异常
	 	可以使用throws继续声明抛出FileNotFoundException这个异常对象，让方法调用者处理
	 */
	public static void readFile(String fileName) throws IOException{
		if(!fileName.equals("c:\\\\a.txt")) {
			throw new FileNotFoundException("传递的文件路径不是c:\\\\a.txt");
		}
		/*
		如果传递的路径，不是.txt结尾
		那么我们就抛出IO异常对象，告知方法的调用者，文件的后缀名不对
		 */
		
		if(!fileName.endsWith(".txt")) {
			throw new IOException("文件后缀名不对");
		}
		
		System.out.println("路径没有问题，读取文件");
	}
	

}

try catch异常处理的第二种方式

package demo21;

import java.io.FileNotFoundException;
import java.io.IOException;

/*
try...catch:异常处理的第二种方式，自己处理异常
格式：
	try{
		可能产生异常的代码
	}catch(定义一个异常变量，用来接收try中抛出的异常对象){
		异常的处理逻辑，异常异常对象之后，怎么处理异常对象
		一般在工具中，会把异常的信息记录到一个日志中
	}
	...
	catch(异常类名 变量名){
	
	}
	注意：
	1、try中可能会抛出多个异常对象，那么就可以使用多个catch来处理这些异常对象
	2、如果try中产生了异常，那么就会执行catch中的异常处理逻辑，执行完毕catch中的处理逻辑
	继续执行try...catch之后的代码
	如果try中没有产生异常，那么就不会执行catch中异常的处理逻辑，执行完try中的代码，继续执行try... catch之后的代码
	
	
 */
public class Demo01TryCatch {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		try {
			//可能产生异常的代码
			readFile("d:\\a.tx");
		} catch (IOException e) {//try中抛出什么异常对象，catch就定义什么异常变量，用来接收这个异常对象
			// 异常的处理逻辑，异常异常对象之后，怎么处理异常对象
			System.out.println("catch - 传递的文件后缀不是.txt");
		}
		System.out.println("后续代码");
	}
	
	/*
	如果传递的路径，不是.txt结尾
	那么我们就抛出IO异常对象，告知方法的调用者，文件的后缀名不对
	 */
	public static void readFile(String fileName) throws IOException{

		if(!fileName.endsWith(".txt")) {
			throw new IOException("文件后缀名不对");
		}
		
		System.out.println("路径没有问题，读取文件");
	}
}

throwable类中3个异常处理的方法

package demo21;

import java.io.FileNotFoundException;
import java.io.IOException;

/*
try...catch:异常处理的第二种方式，自己处理异常
格式：
	try{
		可能产生异常的代码
	}catch(定义一个异常变量，用来接收try中抛出的异常对象){
		异常的处理逻辑，异常异常对象之后，怎么处理异常对象
		一般在工具中，会把异常的信息记录到一个日志中
	}
	...
	catch(异常类名 变量名){
	
	}
	注意：
	1、try中可能会抛出多个异常对象，那么就可以使用多个catch来处理这些异常对象
	2、如果try中产生了异常，那么就会执行catch中的异常处理逻辑，执行完毕catch中的处理逻辑
	继续执行try...catch之后的代码
	如果try中没有产生异常，那么就不会执行catch中异常的处理逻辑，执行完try中的代码，继续执行try... catch之后的代码
	
	
 */
public class Demo01TryCatch {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		try {
			//可能产生异常的代码
			readFile("d:\\a.tx");
		} catch (IOException e) {//try中抛出什么异常对象，catch就定义什么异常变量，用来接收这个异常对象
			// 异常的处理逻辑，异常异常对象之后，怎么处理异常对象
			//System.out.println("catch - 传递的文件后缀不是.txt");
			
			/*
			 Throwable类中定义了3个异常处理的方法
			 String getMessage() 返回此throwable的简短描述
			 String toString() 返回此throwable的详细消息字符串
			 void printStackTrace() JVM打印异常对象，默认此方法，打印的异常信息是最全面的
			 */
			//System.out.println(e.getMessage());//文件后缀名不对
			//System.out.println(e.toString());//重写Object类的toString    java.io.IOException: 文件后缀名不对
			//System.out.println(e);//java.io.IOException: 文件后缀名不对
			
			/*
			java.io.IOException: 文件后缀名不对
				后续代码
					at demo21.Demo01TryCatch.readFile(Demo01TryCatch.java:60)
					at demo21.Demo01TryCatch.main(Demo01TryCatch.java:33)
			 */
			e.printStackTrace();
		}
		System.out.println("后续代码");
	}
	
	/*
	如果传递的路径，不是.txt结尾
	那么我们就抛出IO异常对象，告知方法的调用者，文件的后缀名不对
	 */
	public static void readFile(String fileName) throws IOException{

		if(!fileName.endsWith(".txt")) {
			throw new IOException("文件后缀名不对");
		}
		
		System.out.println("路径没有问题，读取文件");
	}
}

finally代码块

在这里插入图片描述

package demo21;

import java.io.IOException;

/*
finally代码块
格式：
	try{
		可能产生异常的代码
	}catch(定义一个异常变量，用来接收try中抛出的异常对象){
		异常的处理逻辑，异常异常对象之后，怎么处理异常对象
		一般在工具中，会把异常的信息记录到一个日志中
	}
	...
	catch(异常类名 变量名){
	
	}finally{
		无论是否出现异常都会执行
	}
	注意：
		1、finally不能单独使用，必须和try一起使用
		2、finally一般用于资源回收（资源释放），无论程序是否出现异常，最后都要资源释放
		
 */
public class Demo02TryCatchFinally {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		try {
			//可能会产生异常的代码
			readFile("c:\\a.tx");
		} catch (IOException e) {
			// 异常的处理逻辑
			e.printStackTrace();
		} finally {
			//无论是否出现异常，都会执行
			System.out.println("资源释放");
		}
	}
	
	
	/*
	如果传递的路径，不是.txt结尾
	那么我们就抛出IO异常对象，告知方法的调用者，文件的后缀名不对
	 */
	public static void readFile(String fileName) throws IOException{

		if(!fileName.endsWith(".txt")) {
			throw new IOException("文件后缀名不对");
		}
		
		System.out.println("路径没有问题，读取文件");
	}
}

异常注意事项_多异常的捕获处理
在这里插入图片描述

package demo22;

import java.util.List;

/*
 异常的注意事项
 */
public class Demo01Exception {

 public static void main(String[] args) {
  /*
  多个异常使用捕获又该如何处理呢？
  1、多个异常分别处理
  2、多个异常一次捕获，多次处理
  3、多个异常一次捕获一次处理  
   */
  
  //1、多个异常分别处理
	 try {
		  int[] arr = {1,2,3};
		  //System.out.println(arr[3]);//java.lang.ArrayIndexOutOfBoundsException: 3
	 } catch (ArrayIndexOutOfBoundsException e) {
		 System.out.println(e);
	 }

	 try {
		  List<Integer> list = List.of(1,2,3);
		  System.out.println(list.get(3));//ArrayIndexOutOfBoundsException: Index 3 out of bounds for length
	 } catch (Exception e) {
		  System.out.println(e);
	 }
   
	 //2、多个异常一次捕获，多次处理
	 try {
		  int[] arr = {1,2,3};
		  //System.out.println(arr[3]);//java.lang.ArrayIndexOutOfBoundsException: 3
		  List<Integer> list = List.of(1,2,3);
		  System.out.println(list.get(3));//IndexOutOfBoundsException: Index 3 out of bounds for length 3
	 } catch (ArrayIndexOutOfBoundsException e) {
		 System.out.println(e);
	 } catch (IndexOutOfBoundsException e) {
		 System.out.println(e);
	 }
	 
	 /*
	 一个try多个catch注意事项：
	 catch里边定义的异常变量，如果有字符类关系，那么子类的异常变量必须写在上面，否则就会报错
	 ArrayIndexOutOfBoundsException extends IndexOutOfBoundsException
	  */
	 
//	 try {
//		  int[] arr = {1,2,3};
//		  //System.out.println(arr[3]);//java.lang.ArrayIndexOutOfBoundsException: 3
//		  List<Integer> list = List.of(1,2,3);
//		  System.out.println(list.get(3));//IndexOutOfBoundsException: Index 3 out of bounds for length 3
//	 } catch (IndexOutOfBoundsException e) {
//		 System.out.println(e);
//	 } catch (ArrayIndexOutOfBoundsException e) {
//		 System.out.println(e);
//	 }
	 
	 //3、多个异常一次捕获一次处理  
	 try {
		  int[] arr = {1,2,3};
		  System.out.println(arr[3]);//ArrayIndexOutOfBoundsException: 3
		  List<Integer> list = List.of(1,2,3);
		  System.out.println(list.get(3));//IndexOutOfBoundsException: Index 3 out of bounds for length 3
	 } catch (Exception e) {
		 System.out.println(e);
	 }
	 
	 //运行时异常被抛出可以不处理，即不捕获也不声明抛出
	 //默认给虚拟机处理，终止程序，什么时候不跑出运行时异常了，在继续执行程序
	 int[] arr = {1,2,3};
	 System.out.println(arr[3]);//ArrayIndexOutOfBoundsException: 3
	 List<Integer> list = List.of(1,2,3);
	 System.out.println(list.get(3));//IndexOutOfBoundsException: Index 3 out of bounds for length 3
  
	 System.out.println("后续代码");

 }
}

异常·处理注意事项 finally有return语句
在这里插入图片描述

package demo22;

/*
如果finally有return语句，永远返回finally中的结果，避免该情况
 */
public class Demo02Exception {
	public static void main(String[] args) {
		int a = getA();
		System.out.println(a);
	}
	
	//定义一个方法，返回变量a的值
	public static int getA() {
		//
		int a = 10;
		try {
			return a;
		} catch (Exception e) {
			System.out.println(e); 
		} finally {
			//一定会执行的代码
			a = 100;
			return a;
		}
	}
}

异常注意事项 字符类异常注意事项

package demo22;
/*
子父类的异常：
	如果父类抛出多个异常，子类重写父类方法时，抛出和父类相同的异常或者是父类异常的子类或者是不抛出异常
	父类方法没有抛出异常，子类重写父类方法时也不可抛出异常。此时子类产生异常，只能捕获处理，不能声明抛出
注意：
	父类异常是什么样，子类异常就是什么样
 */
public class Fu {
	public void show01() throws NullPointerException,ClassCastException{}
	public void show02() throws IndexOutofBoundsException{}
	public void show03() throws IndexOutofBoundsException{}
	public void show04() {}
}

class Zi extends Fu{
	//子类重写父类方法时，抛出和父类相同的异常
	public void show01() thorws NullPointerException,ClassCastException{}
	//子类重写父类方法时，抛出和父类相同的子类
	public void show02() thorws ArrayIndexOutofBoundsException{}
	//子类重写父类方法时，抛出和父类相同的子类
	public void show03() {}
	
	/*
	 父类方法没有抛出异常，子类重写父类方法时也不可抛出异常。
	 
	 */
	//public void show04() throws Exception{}
	
	//此时子类产生该异常，只能捕获处理，不能声明抛出
	public void show04() {
		try {
			throw new Exception("编译器异常");
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
		
	}
}

自定义异常类
在这里插入图片描述

package demo22;

/*
自定义异常类：
	java提供的异常类，不够我们使用，需要自己定义一些异常类
格式：
	public class XXXException extends Exception | RuntimeException{
		添加一个空参数的构造方法
		添加一个带异常信息的构造方法
	}
注意：
	1、自定义异常类一般都是以Exception结尾，说明该类都是一个异常类
	2、自定义异常类，必须的继承Exception或者RuntimeException
		继承Exception:那么我们自定义的异常类就是一个编译期异常，
		如果方法内部抛出了编译器异常，就必须处理这个异常，要么throws，要么try...catch
		
		继承RuntimeException:那么自定义的异常类就是一个运行期异常，无需处理，交给虚拟机处理（中断处理）
 */
public class RegisterException extends Exception{

	public static void main(String[] args) {
		
		

	}
	
	//添加一个空参数的构造方法
	public RegisterException() {
		
	}
	
	/*
	添加一个带异常信息的构造方法
	查看源码发现，所有的异常类都会有一个带异常信息的构造方法，
	方法内部会调用父类带异常信息的构造方法，让父类来处理这个异常信息
	 */
	public RegisterException(String message) {
		super(message);
	}

}

自定义异常类的练习

package demo22;

import java.util.Scanner;



/*
 要求：我们模拟注册操作，如果用户名已存在，则抛出异常并提示：亲，该用户名已经被注册。
 
 分析：
 	1、使用数组保存已经注册个的用户名(数据库)
 	2、使用Scanner获取用户输入的注册的用户名(前端，页面)
 	3、定义一个方法，对用户输入注册的用户名进行判断
 		遍历存储已经注册过用户名的数组，获取每一个用户名
 		使用获取到的用户名和用户输入的用户名比较
 			true：
 				用户名已经存在，抛出RegisterException异常，告知用户"亲，该用户名已经被注册"
 			false：
 				继续遍历比较
 		如果循环结束了，还没有找到重复的用户名，提示用户"恭喜您，注册成功！"		
 
 */
public class Demo01RegisterException {
	
	//1、使用数组保存已经注册个的用户名(数据库)
	static String[] usernames = {"张三","李四","王五"};
	
	public static void main(String[] args) throws RegisterException {
		//2、使用Scanner获取用户输入的注册的用户名(前端，页面)
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入您注册的用户名：");
		String username = sc.next();
		checkUsernames(username);
	
	}

	//3、定义一个方法，对用户输入注册的用户名进行判断
	public static void checkUsernames(String username) /*throws RegisterException*/{
		//遍历存储已经注册过用户名的数组，获取每一个用户名
		for (String name : usernames) {
			//使用获取到的用户名和用户输入的用户名比较
			if(name.equals(username)) {
				//true：用户名已经存在，抛出RegisterException异常，告知用户"亲，该用户名已经被注册"
				try {
					throw new RegisterException("亲，该用户名已经被注册");
				} catch (Exception e) {
					e.printStackTrace();
					return;//结束方法
				}
			}
		}

		//如果循环结束了，还没有找到重复的用户名，提示用户"恭喜您，注册成功！"		
		System.out.println("恭喜您，注册成功!");
	}
}


package demo22;

/*
自定义异常类：
	java提供的异常类，不够我们使用，需要自己定义一些异常类
格式：
	public class XXXException extends Exception | RuntimeException{
		添加一个空参数的构造方法
		添加一个带异常信息的构造方法
	}
注意：
	1、自定义异常类一般都是以Exception结尾，说明该类都是一个异常类
	2、自定义异常类，必须的继承Exception或者RuntimeException
		继承Exception:那么我们自定义的异常类就是一个编译期异常，
		如果方法内部抛出了编译器异常，就必须处理这个异常，要么throws，要么try...catch
		
		继承RuntimeException:那么自定义的异常类就是一个运行期异常，无需处理，交给虚拟机处理（中断处理）
 */
public class RegisterException extends /*Exception*/ RuntimeException{

	public static void main(String[] args) {

	}
	
	//添加一个空参数的构造方法
	public RegisterException() {
		super();
	}
	
	/*
	添加一个带异常信息的构造方法
	查看源码发现，所有的异常类都会有一个带异常信息的构造方法，
	方法内部会调用父类带异常信息的构造方法，让父类来处理这个异常信息
	 */
	public RegisterException(String message) {
		super(message);
	}

}


package demo22;

import java.util.Scanner;



/*
 要求：我们模拟注册操作，如果用户名已存在，则抛出异常并提示：亲，该用户名已经被注册。
 
 分析：
 	1、使用数组保存已经注册个的用户名(数据库)
 	2、使用Scanner获取用户输入的注册的用户名(前端，页面)
 	3、定义一个方法，对用户输入注册的用户名进行判断
 		遍历存储已经注册过用户名的数组，获取每一个用户名
 		使用获取到的用户名和用户输入的用户名比较
 			true：
 				用户名已经存在，抛出RegisterException异常，告知用户"亲，该用户名已经被注册"
 			false：
 				继续遍历比较
 		如果循环结束了，还没有找到重复的用户名，提示用户"恭喜您，注册成功！"		
 
 */
public class Demo02RegisterException {
	
	//1、使用数组保存已经注册个的用户名(数据库)
	static String[] usernames = {"张三","李四","王五"};
	
	public static void main(String[] args) throws RegisterException {
		//2、使用Scanner获取用户输入的注册的用户名(前端，页面)
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入您注册的用户名：");
		String username = sc.next();
		checkUsernames(username);
	
	}

	//3、定义一个方法，对用户输入注册的用户名进行判断
	public static void checkUsernames(String username) /*throws RegisterException*/{
		//遍历存储已经注册过用户名的数组，获取每一个用户名
		for (String name : usernames) {
			//使用获取到的用户名和用户输入的用户名比较
			if(name.equals(username)) {
				//true：用户名已经存在，抛出RegisterException异常，告知用户"亲，该用户名已经被注册"
				throw new RegisterException("亲，该用户名已经被注册");
				//抛出运行期异常，无需处理，交给jvm，中断处理
				
			}
		}

		//如果循环结束了，还没有找到重复的用户名，提示用户"恭喜您，注册成功！"		
		System.out.println("恭喜您，注册成功!");
	}
}
朗朗乾坤光风霁月
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值