CGBTN2111-DAY09总结复习

DAY09 复习

1 异常

1. 异常的继承结构

异常层次结构中的根是Throwable
Error：目前我们编码解决不了的问题
Exception:异常
编译异常：未运行代码就报错了，强制要求处理
运行时异常：运行代码才报错，可以通过编译，不强制要求处理

1. Throwable:异常的顶级父类
2. --Error:错误,程序无法处理
3. --Exception:异常,我们可以通过编码修复
4. -- 编译异常:还没运行已经报错了
5. -- 运行时异常:可以通过编译,一运行就报错

复制代码

2.异常的解决方案

1. 捕获处理try-catch–自己解决

异常捕获处理的格式：

1. try{
2. 可能会抛出异常的代码
3. }catch(异常的类型 异常的名字){
4. 万一捕获到了异常，进行处理的解决方案
5. }

复制代码

1. try-catch结构可以嵌套，如果有多种异常类型需要特殊处理的话
2. 使用多态的思想，不论是什么子异常，统一看作父类型Exception
   做出更加通用的解决方案，甚至可以只写这一个

2.向上抛出throws–交给别人解决

异常抛出的格式：
在方法的小括号与大括号之间，写：throws 异常类型
如果有多个异常，使用逗号分隔即可

1. private static void method3() throws ArithmeticException,InputMismatchException,Exception{ }
3. private static void method3() throws Exception{ }

复制代码

1. 如果一个方法抛出了异常，那么谁来调用这个方法，谁就需要处理这个异常，这里的处理也有两种方案：捕获解决 或者 继续向上抛出
2. 不能直接把异常抛给main(),因为调用main()是JVM，没人解决了，该报错还报错，所以我们一般会在main()调用之前将异常解决掉

3. 抽象

1.抽象类

1. 被abstract修饰的方法是抽象方法,抽象方法没有方法体
2. 一旦一个类中有抽象方法,这个类必须被声明成抽象类
3. 如果一个子类继承了一个抽象父类,有两种解决方案:
   1)抽象子类:不实现/实现一部分抽象父类中的抽象方法
   2)普通子类:实现抽象父类中全部的抽象方法
4. 抽象类不能实例化
5. 抽象类有构造函数的,但是不是为了自己使用,为了子类super()调用
6. 抽象类可以定义成员变量/成员常量
7. 抽象类中可以定义全普/全抽/半普半抽
8. 如果一个类不想被外界实例化,可以把这个类声明成抽象类
9. abstract关键字不可以与private static final共用

2 抽象方法

1. 被关键字abstract 修饰的方法就是抽象方法
2. 抽象方法没有方法体{ }，直接以分号结束

4. 练习案例1:

1. package cn.tedu.oop2;
2. /*本类用于面向抽象编程的推导*/
3. public class DesignTeacher {
4. }
5. //3.抽取共性,向上形成父类
6. abstract class Teacher{
7. String name;
8. int id;
9. public abstract void ready();
10. public abstract void teach();
11. }
13. //1.创建培优CGB老师类
14. //业务:主打互联网架构与微服务
15. class CGBTeaher extends Teacher{
16. @Override
17. public void ready(){
18. System.out.println("正在备课:互联网架构与微服务");
19. }
20. @Override
21. public void teach(){
22. System.out.println("正在讲课:互联网架构与微服务");
23. }
24. }
25. //2.创建高手加薪班老师类
26. //主打:基础加强 框架加强 高新技术
27. class ACTTeacher extends Teacher{
28. @Override
29. public void ready(){
30. System.out.println("正在备课:基础加强 框架加强 高新技术");
31. }
32. @Override
33. public void teach(){
34. System.out.println("正在讲课:基础加强 框架加强 高新技术");
35. }
36. }
38. //创建抽象父类的子实现类SCDTeacher
39. //这是一个抽象子类,只实现抽象父类中的一个抽象方法
40. abstract class SCDTeacher extends Teacher{
41. @Override
42. public void ready() {
43. System.out.println("正在研发中...");
44. }
45. }

复制代码

5 练习案例2:

1. 定义父类小鸟类Bird :

腿legNumbers的数量为2
下蛋eggNumbers数量可以自定义
拥有飞行fly()功能 下蛋layEggs()功能

2. 定义子级鸽子类Pigeon：

它既会飞，也会下蛋

3. 定义子级燕子类Swallow：

它既会飞，也会下蛋,还有自己的特有功能筑巢makeNest()

1. package cn.tedu.exec;
2. /*本类用作OOP综合案例*/
3. public class TestAnimal {
4. public static void main(String[] args) {
5. //11.创建鸽子类对象
6. Pigeon p = new Pigeon();
7. System.out.println(p.LEG_NUMBERS);//2
8. System.out.println(p.eggNumbers);//0,还是父类的默认值
9. p.layEggs();//鸽子的下蛋数量为:2个
10. p.fly();//小鸟飞呀飞~
12. //12.创建燕子类的对象
13. Swallow s = new Swallow();
14. System.out.println(s.LEG_NUMBERS);//2
15. System.out.println(s.eggNumbers);//6
16. s.fly();//继承过来的方法
17. s.layEggs();//实现了的抽象方法
18. s.makeNest();//自己的特有方法
19. }
20. }
21. //1.定义父类小鸟类
22. abstract class Bird{
23. //2.定义小鸟类中的成员常量,腿的数量为2
24. final int LEG_NUMBERS = 2;
25. //3.定义小鸟类中的成员变量,下蛋的数量
26. int eggNumbers;
27. //4.定义小鸟类中的普通方法
28. public void fly(){
29. System.out.println("小鸟飞呀飞~");
30. }
31. //5.定义小鸟类中的抽象方法
32. public abstract void layEggs();
33. }
34. //6.创建子类鸽子类
35. class Pigeon extends Bird{
36. //7.实现抽象父类中未实现的方法
37. @Override
38. public void layEggs() {
39. System.out.println("鸽子的下蛋数量为:2个");
40. }
41. }
42. //8.创建第2个子类燕子类
43. class Swallow extends Bird{
44. //7.1定义子类自己的成员变量
45. int eggNumbers = 6;
46. //7.2实现抽象父类中未实现的方法
47. @Override
48. public void layEggs() {
49. System.out.println("燕子的下蛋数量:"+eggNumbers);
50. }
51. //8.定义子类特有的方法
52. public void makeNest(){
53. System.out.println("燕子筑巢~");
54. }
55. }

复制代码

4. 定义父类昆虫类Insect:

腿的数量为6，产卵的数量可以自定义，拥有飞行的功能还有产卵spawn的功能

5. 定义子级蚂蚁类Ant：

它既会飞，也会产卵

6. 定义子级蜜蜂类Bee：

它既会飞，也会产卵,还有自己的特有功能制作蜂蜜makeHoney

1. package cn.tedu.review;
2. /*本类用于实现设计案例*/
3. public class TestAnimal {
4. public static void main(String[] args) {
5. //1.创建蚂蚁类对象
6. Ant a = new Ant();
7. System.out.println(a.LEG_NUMBERS);//6
8. System.out.println(a.eggNumbers);//0
9. a.fly();//使用继承过来的方法
10. a.sqawn();//使用子类实现的方法
12. //2.创建蜜蜂类对象
13. Bee b = new Bee();
14. System.out.println(b.LEG_NUMBERS);//6
15. System.out.println(b.eggNumbers);//200
16. b.fly();//使用继承过来的方法
17. b.sqawn();//使用子类实现的方法
18. b.makeHoney();//使用子类的特有功能
19. }
20. }
22. //1.创建抽象父类
23. abstract class Insect{
24. //2.定义成员常量
25. final int LEG_NUMBERS = 6;//腿的数目是6条
26. //3.定义成员变量
27. int eggNumbers;//产卵的数量
29. //4.定义一个普通方法--飞行功能
30. public void fly(){
31. System.out.println("昆虫的飞行功能~");
32. }
33. //5.定义抽象方法--产卵功能
34. public abstract void sqawn();
35. }
37. //6.创建普通子类蚂蚁类
38. class Ant extends Insect{
39. //7.添加父类中未实现的抽象方法
40. @Override
41. public void sqawn() {
42. System.out.println("蚂蚁产卵的数量为:300");
43. }
44. }
45. //8.创建普通子类蜜蜂类
46. class Bee extends Insect{
47. //9.定义子类自己的同名成员变量
48. int eggNumbers = 200;
49. @Override
50. public void sqawn() {
51. System.out.println("蜜蜂的产卵数量为:"+eggNumbers);
52. }
53. //10.定义子类自己的特有功能
54. public void makeHoney(){
55. System.out.println("蜜蜂正在产蜂蜜~");
56. }
57. }

复制代码

来源：https://blog.csdn.net/weixin_43884234/article/details/121853144
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！