• Java异常编程题（巩固语法）

    • 处理异常，让含受检异常（checked Exception）的程序可以运行完成。个人觉得学完后，通过自己编几题，可以巩固一下知识，也可以测试一下这方面熟不熟悉吧。

    先复习一下异常用到的几个关键字：

    1. try：检测可能出现异常的代码块，如果出现异常就将其抛出

    2. catch：用于捕获异常，捕获try抛出来的异常

    3. finally：不管有无异常都会执行的语句块，一般用于回收try中所使用的资源。但需要注意是，当try语句块中抛出了异常，catch没有捕捉处理，就会交给JVM处理，但这样的话finally语句块执行后，在finally外的语句块不会被执行

    4. throw：用于抛出异常

    5. throws：用在方法定义时，（放方法参数括号的后面）用于声明该方法可能抛出的异常，就是在方法体内抛出的异常对象如果和throws后异常类相匹配的话，就会被它接受放表内，然后调用该方法时异常对象就会被抛出，和throws所供异常类不符的话就会向上抛出

    题目：

    一个小工厂处理员工工资问题。工厂有员工人数，以及老板能承受给出的最高薪水和员工要求的最低薪水。

    员工有姓名，年龄，⼯资，⾝份证号码等代表自身身份的属性。小工厂内有减工资和升工资措施，当工资小于最小薪水时会发生异常给予提醒小工厂老板，当工资大于最大老板能给予的薪水时也会给出异常提醒小工厂老板。
    当然小工厂没员工也会发现异常（就是工厂员工人数为0），还有员工的一些信息错误也会异常，比如身份证号错误（身份证号应有十八位），年龄不符合工作条件（年龄需满十八岁且不能高于60岁）

    阅读完题目，我们可以总结出我们需要完成的异常类有：空异常，年龄异常，工资异常，身份证非法异常。

    如图所示：

     根据画的图可以清楚的了解直接继承的关系，然后编写所需的异常类：

    1. //定义空异常类
    2. class nullException extends Exception{
    3. 	private String message;
    4. 	public nullException(String message) {
    5. 		this.message = message;
    6. 	}
    7. 	public String getmessage() {
    8. 		return message;
    9. 	}
    10. }
    11. //定义年龄异常类
    12. class AgeException extends Exception{
    13. 	private String message;
    14. 	public AgeException(String message) {
    15. 		this.message = message;
    16. 	}
    17. 	public String getmessage() {
    18. 		return message;
    19. 	}
    20. }
    21. //定义薪水异常类
    22. class SalaryException extends Exception{
    23. 	private String message;
    24. 	public SalaryException(String message) {
    25. 		this.message = message;
    26. 	}
    27. 	public String getmessage() {
    28. 		return message;
    29. 	}
    30. }
    31. //定义身份证异常类
    32. class IDcardException extends Exception{
    33. 	private String message;
    34. 	public IDcardException(String message) {
    35. 		this.message = message;
    36. 	}
    37. 	public String getmessage() {
    38. 		return message;
    39. 	}
    40. }

    定义完可能出现的异常类，那么现在就可以构建小工厂类和员工类了：

    1. //定义小工厂类
    2. class smallFactory{
    3. 	public static int number; //厂内人数
    4. 	public static int minSalary;
    5. 	public static int maxSalary;
    6. 	static {
    7. 		number = 10;
    8. 		minSalary = 600;
    9. 		maxSalary = 100000;
    10. 	}
    11. 	public smallFactory() {
    12. 		
    13. 	}
    14. 	//方便修改最低最高薪水
    15. 	public smallFactory(int minSalary,int maxSalary) {
    16. 		this.minSalary = minSalary;
    17. 		this.maxSalary = maxSalary;
    18. 	}
    19. }
    20. //定义员工类
    21. class Employee extends smallFactory{
    22. 	private String name; //员工姓名
    23. 	private int Age; //员工年龄
    24. 	public int Salary; //员工起始工资，不包含加薪和降薪后的工资(加薪降薪有些人有有些人没有)
    25. 	private String idCard; //员工身份证号
    26. }

    （薪水后续可能要改变，可能要被外界访问，所以就设为public访问权限）

    定义完属性后，现在可以构造可能发生的异常了，我们可以用throws关键字在员工类的构造函数中进行实现，然后再在员工类中添加两个方法，一个加薪，一个降薪。

    写好后员工类的代码如下：

    1. //定义员工类
    2. class Employee extends smallFactory{
    3. 	private String name; //员工姓名
    4. 	private int Age; //员工年龄
    5. 	public int Salary; //员工起始工资，不包含加薪和降薪后的工资(加薪降薪有些人有有些人没有)
    6. 	private String idCard; //员工身份证号
    7. 	
    8. 	public Employee(int Age,int Salary,String idCard) throws Exception{
    9. 		//可能出现的年龄异常
    10. 		if(Age<18) {
    11. 			System.out.println("还是先去读书吧，小小年纪别想着进厂");
    12. 			throw new AgeException("年龄小了！");
    13. 		}
    14. 		else if(Age>60)
    15. 			throw new AgeException("年龄太大了！");
    16. 		
    17. 		//可能出现的薪水异常
    18. 		this.Salary = Salary;
    19. 		if(Salary
    20. 			throw new SalaryException("工资也忒少了吧！");
    21. 		else if(Salary>smallFactory.maxSalary) {
    22. 			System.out.println("想屁吃呢？想拿这么高工资!");
    23. 			throw new SalaryException("工资太高了，应该统计错了");
    24. 		}
    25. 		
    26. 		//可能出现的身份证非法异常
    27. 		if(idCard.length()!=18)
    28. 			throw new IDcardException("身份证号非法异常");
    29. 	}
    30. 	
    31. 	//添加个加薪方法
    32. 	public void addSalary(int addSalaryNum)throws Exception {
    33. 		Salary = Salary+addSalaryNum;
    34. 		if(Salary
    35. 			throw new SalaryException("加了钱还这么少啊");
    36. 		else if(Salary>smallFactory.maxSalary) {
    37. 			System.out.println("想屁吃呢？想拿这么高工资!");
    38. 			throw new SalaryException("工厂付不起这工资");
    39. 		}
    40. 	}
    41. 	
    42. 	//添加个降薪方法
    43. 	public void cutSalary(int cutSalaryNum)throws Exception{
    44. 		Salary = Salary-cutSalaryNum;
    45. 		if(Salary
    46. 			throw new SalaryException("活该这么点工资");
    47. 		if(Salary>smallFactory.maxSalary)
    48. 			throw new SalaryException("降工资还这么高，应该算错了");
    49. 	}
    50. }

    最后我们在主函数内进行测试，看是否有异常，有的话进行捕获和解决，没的话输出该厂这名员工的这些信息。（那个抛出异常对象的那个信息是我自己写的，自己可以写认为看得顺眼的异常产生信息）

    总代码如下：

    1. import java.util. *;
    2.  
    3. //定义空异常类
    4. class nullException extends Exception{
    5. 	private String message;
    6. 	public nullException(String message) {
    7. 		this.message = message;
    8. 	}
    9. 	public String getmessage() {
    10. 		return message;
    11. 	}
    12. }
    13. //定义年龄异常类
    14. class AgeException extends Exception{
    15. 	private String message;
    16. 	public AgeException(String message) {
    17. 		this.message = message;
    18. 	}
    19. 	public String getmessage() {
    20. 		return message;
    21. 	}
    22. }
    23. //定义薪水异常类
    24. class SalaryException extends Exception{
    25. 	private String message;
    26. 	public SalaryException(String message) {
    27. 		this.message = message;
    28. 	}
    29. 	public String getmessage() {
    30. 		return message;
    31. 	}
    32. }
    33. //定义身份证异常类
    34. class IDcardException extends Exception{
    35. 	private String message;
    36. 	public IDcardException(String message) {
    37. 		this.message = message;
    38. 	}
    39. 	public String getmessage() {
    40. 		return message;
    41. 	}
    42. }
    43.  
    44.  
    45. //定义小工厂类
    46. class smallFactory{
    47. 	public static int number; //厂内人数
    48. 	public static int minSalary;
    49. 	public static int maxSalary;
    50. 	static {
    51. 		number = 10;
    52. 		minSalary = 600;
    53. 		maxSalary = 100000;
    54. 	}
    55. 	public smallFactory() {
    56. 		
    57. 	}
    58. 	//方便修改最低最高薪水
    59. 	public smallFactory(int minSalary,int maxSalary) {
    60. 		this.minSalary = minSalary;
    61. 		this.maxSalary = maxSalary;
    62. 	}
    63. }
    64. //定义员工类
    65. class Employee extends smallFactory{
    66. 	private String name; //员工姓名
    67. 	private int Age; //员工年龄
    68. 	public int Salary; //员工起始工资，不包含加薪和降薪后的工资(加薪降薪有些人有有些人没有)
    69. 	private String idCard; //员工身份证号
    70. 	
    71. 	public Employee(int Age,int Salary,String idCard) throws Exception{
    72. 		//可能出现的年龄异常
    73. 		if(Age<18) {
    74. 			System.out.println("还是先去读书吧，小小年纪别想着进厂");
    75. 			throw new AgeException("年龄小了！");
    76. 		}
    77. 		else if(Age>60)
    78. 			throw new AgeException("年龄太大了！");
    79. 		
    80. 		//可能出现的薪水异常
    81. 		this.Salary = Salary;
    82. 		if(Salary
    83. 			throw new SalaryException("工资也忒少了吧！");
    84. 		else if(Salary>smallFactory.maxSalary) {
    85. 			System.out.println("想屁吃呢？想拿这么高工资!");
    86. 			throw new SalaryException("工资太高了，应该统计错了");
    87. 		}
    88. 		
    89. 		//可能出现的身份证非法异常
    90. 		if(idCard.length()!=18)
    91. 			throw new IDcardException("身份证号非法异常");
    92. 	}
    93. 	
    94. 	//添加个加薪方法
    95. 	public void addSalary(int addSalaryNum)throws Exception {
    96. 		Salary = Salary+addSalaryNum;
    97. 		if(Salary
    98. 			throw new SalaryException("加了钱还这么少啊");
    99. 		else if(Salary>smallFactory.maxSalary) {
    100. 			System.out.println("想屁吃呢？想拿这么高工资!");
    101. 			throw new SalaryException("工厂付不起这工资");
    102. 		}
    103. 	}
    104. 	
    105. 	//添加个降薪方法
    106. 	public void cutSalary(int cutSalaryNum)throws Exception{
    107. 		Salary = Salary-cutSalaryNum;
    108. 		if(Salary
    109. 			throw new SalaryException("活该这么点工资");
    110. 		if(Salary>smallFactory.maxSalary)
    111. 			throw new SalaryException("降工资还这么高，应该算错了");
    112. 	}
    113. }
    114.  
    115.  
    116. public class Solution{
    117. 	public static void main(String[] args) {
    118. 		Scanner reader = new Scanner(System.in);
    119. 		String _name = reader.next();
    120. 		int _Age = reader.nextInt();
    121. 		String _idCard = reader.next();
    122. 		int _Salary = reader.nextInt();
    123. 		
    124. 		try {
    125. 			Employee human = new Employee(_Age,_Salary,_idCard);
    126. 			//上面如果没有发生异常的话，对有加薪降薪的人进行操作
    127. 			/*int addSalaryNum = reader.nextInt();
    128. 			human.addSalary(addSalaryNum);*/
    129. 			/*int cutSalaryNum = reader.nextInt();
    130. 			human.cutSalary(cutSalaryNum);*/
    131. 			
    132. 			//都没有异常的话，就打印该人的信息
    133. 			System.out.print("姓名\t年龄\t身份证号\t\t\t薪水\n");
    134. 			System.out.print(_name + '\t' + _Age + '\t' + _idCard + '\t' + human.Salary + '\n');
    135. 		}
    136. 		catch(Exception e) {
    137. 			//获取有关异常的信息
    138. 			e.printStackTrace();
    139. 		}
    140. }
    141. }

    测试几条自己想测试的案例会发现，方法体内有一个异常对象被抛出的话，那么它后续的代码都不会被执行。

    相信如果你自己单独写完这题会有收获的。

  • 相关阅读:
    Python制作GUI学生管理系统【毕设必备】
    Unity中SmoothStep介绍和应用: 溶解特效优化
    Kotlin 环境下解决属性初始化问题
    【css揭秘】- 47个不可不知的 css 技巧(上篇0-19)
    29. 【Android教程】折叠列表 ExpandableListView
    solidworks 2024新功能之-打造更加智能的工作 硕迪科技
    C++11（下）
    Unity中location和rotation赋值和更改
    【brpc学习实战二】brpc client构建基本流程
    《下一代互联网（IPv6）搭建与运维》1+X证书
  • 原文地址：https://blog.csdn.net/qq_63691275/article/details/126915485