学习日志-day14-5.23

完成目标：



知识点：


1.多态转型

知识点	焦点内容	重点
多态转型	向上转型（父类引用指向子类对象） 与向下转型（逼迫类型转换）的机制与区别	向上转型主动完成，向下转型需显式强转
向上转型	雷同double b = 1的小类型主动提升为大类型	多态调用时无法使用子类特有方法
向下转型	通过逼迫转换（如 Dog dog = (Dog) animal）恢复子类类型以调用特有功能	类型不匹配会抛出ClassCastException
转型应用场景	需调用子类特有功能时（如dog.lookDoor()）必须向下转型	转型前发起用instanceof查抄类型安全性

2.多态实例

定义条记本类，具备开机，关机和使用USB设备的功能。具体是什么USB设备，条记本并不关心，只要符合USB规格的设备都可以。鼠标和键盘要想能在电脑上使用，那么鼠标和键盘也必须遵守USB规范，不然鼠标和键盘的生产出来无法使用;
进行形貌条记本类，实现条记本使用USB鼠标、USB键盘
- USB接口，包含开启功能、关闭功能
- 条记本类，包含运行功能、关机功能、使用USB设备功能
- 鼠标类，要符合USB接口
- 键盘类，要符合USB接口

1. public interface USB {
2.     public abstract void open();
3.     public abstract void close();
4. }
10. public class Mouse implements USB{
11.     @Override
12.     public void open() {
13.         System.out.println("鼠标开启");
14.     }
16.     @Override
17.     public void close() {
18.         System.out.println("鼠标关闭");
19.     }
21.     //特有方法
22.     public void click(){
23.         System.out.println("点我");
24.     }
25. }
32. public class KeyBoard implements USB{
33.     @Override
34.     public void open() {
35.         System.out.println("键盘开启");
36.     }
38.     @Override
39.     public void close() {
40.         System.out.println("键盘关闭");
41.     }
43.     //特有功能
44.     public void input(){
45.         System.out.println("敲我");
46.     }
47. }
52. public class NoteBook {
53.     //开机
54.     public void start(){
55.         System.out.println("开机");
56.     }
58.     //使用USB
59.     /*
60.        USB usb = mouse  多态
61.        USB usb = keyBoard 多态
62.      */
63.     public void useUSB(USB usb){
64.         if (usb instanceof Mouse){
65.             Mouse mouse = (Mouse) usb;
66.             mouse.open();
67.             mouse.click();
68.             mouse.close();
69.         }else{
70.             KeyBoard keyBoard = (KeyBoard) usb;
71.             keyBoard.open();
72.             keyBoard.input();
73.             keyBoard.close();
74.         }
75.         //usb.open();
76.         //usb.close();
77.     }
79.     //关机
80.     public void stop(){
81.         System.out.println("关机");
82.     }
83. }
89. public class Test01 {
90.     public static void main(String[] args) {
91.         NoteBook noteBook = new NoteBook();
92.         Mouse mouse = new Mouse();
93.         noteBook.start();
94.         noteBook.useUSB(mouse);
95.         noteBook.stop();
97.         System.out.println("===========");
98.         KeyBoard keyBoard = new KeyBoard();
99.         noteBook.start();
100.         noteBook.useUSB(keyBoard);
101.         noteBook.stop();
102.     }
103. }

复制代码

知识点	焦点内容	重点
USB接口计划	定义抽象接口包含open()和close()方法，要求设备类（鼠标/键盘）必须实现	接口与实现类的多态调用关系
条记本类功能	包含开机、关机、使用USB设备方法（useUSB），通过多态调用差别设备的接口方法	useUSB方法参数类型为接口，需明白多态的现实应用
设备类实现	鼠标类（Mouse）和键盘类（Keyboard）实现USB接口，并重写open/close方法	特有方法（如click()、input()）需通过向下转型调用
多态与类型判断	在useUSB中通过instanceof判断设备类型，安全调用特有功能	制止直接强转导致的类型转换异常
案例流程	1. 开机 → 2. 插入设备（触发接口方法） → 3. 调用特有功能 → 4. 关机	实验次序与多态调用的联动逻辑

3.权限修饰符

知识点	焦点内容	重点
权限修饰符	Java中四种访问权限：public（公共）、protected（受掩护）、default（默认）、private（私有）	default不能显式声明，仅在接口中隐式使用
同类访问	四种权限修饰的成员在同类中均可访问	无特殊限定
同包差别类	public/protected/default可访问，private不可访问	protected与default易肴杂（同包时行为相同）
差别包子父类	public/protected可访问，default/private不可访问	protected跨包需继承关系
差别包非子父类	仅public可访问，其余均不可	现实开发中优先用public和private
开发实践	属性用private（封装）、方法用public、构造方法用public	private构造方法会阻止实例化

4.final

知识点	焦点内容	重点
final修饰类	使类不能被继承（终极类）	public final class 类名 语法格式
final修饰方法	使方法不能被重写	与abstract关键字冲突（不能同时使用）
final修饰局部变量	变量成为常量（不可二次赋值）	声明时可以不初始化（但初次赋值后不可更改）
final修饰对象	对象引用地点不可变（但属性值可修改）	setter方法仍可修改对象属性
final修饰成员变量	必须显式初始化且不可二次赋值	会导致有参构造和setter方法失效
final关键字的本质	表示"终极的"、"不可改变的"特性	差别修饰对象的不可变性表现差别（类/方法/变量）

5.代码块

知识点	焦点内容	重点
构造代码块	格式：{ }内直接写代码; 实验特点：优先于构造方法实验，每次创建对象时都会实验	与构造方法的实验次序关系
静态代码块	格式：static { }; 实验特点：优先于构造代码块和构造方法，且仅实验一次	与构造代码块的实验次序及次数差别
静态代码块应用场景	JDBC毗连数据库的四大参数初始化： 1. 注册驱动; 2. 数据库地点; 3. 用户名; 4. 暗码; （需最早初始化且仅一次）	为何不重复初始化？静态代码块的不可替换性
代码块对比	静态代码块 vs 构造代码块： - 实验时机：静态>构造>构造方法; - 实验次数：静态（1次） vs 构造（N次）	现实开发中优先使用静态代码块

6.内部类

知识点	焦点内容	重点
内部类定义	类内部定义的类，用于形貌外部类中必要完备结构（属性和行为）的成员	区分内部类与嵌套类概念
使用场景	当外部类某成员需独立属性和行为，且仅服务于外部类时（如人类与心脏）	明白“只为外部事物提供服务”的焦点逻辑
JAVA语法规则	类A包含类B时，A为外部类，B为内部类（class A { class B {...} }）	静态/非静态成员内部类的语法差别
内部类分类	成员内部类（静态/非静态）、局部内部类、匿名内部类（重点）	匿名内部类的现实应用场景（如事件监听）
案例	人的心脏作为内部类，需独立形貌跳动频率、供血功能等属性和行为	类比其他生物结构（如汽车与发动机）

7.成员内部类

知识点	焦点内容	重点
静态成员内部类	定义时添加static关键字（如static class B），可包含属性/方法/构造器，支持final或abstract修饰（不可同时使用）	静态内部类不能调用外部类非静态成员；权限修饰符使用规则与外部类相同
非静态成员内部类	定义时不加static，其余结构与静态内部类雷同	调用方式需通过外部类实例 （new Outer().new Inner()）
调用方式对比	静态内部类：Outer.Inner obj = new Outer.Inner(); 非静态内部类：Outer.Inner obj = new Outer().new Inner()	语法差别：非静态需先实例化外部类
修饰符限定	final修饰后不可继承；abstract修饰后不可实例化	注意final与abstract互斥性
现实应用示例	Person.Heart静态内部类模拟心脏跳动方法（jump()）	通过Person.Heart heart = new Person.Heart()调用

8.局部内部类

知识点	焦点内容	重点
局部内部类	定义在方法、代码块或构造器中的内部类，作用域与局部变量一致	外部类无法直接实例化局部内部类，需通过封装方法间接调用
匿名内部类	局部内部类的特殊形式，无显式类名，直接通过接口/父类实例化	语法糖特性，需明白new 接口(){...}的底层实现逻辑
调用限定	局部内部类仅能在定义它的方法/块内实例化，外部需通过封装方法（如eat()）间接调用	成员内部类 vs 局部内部类的实例化权限差别
语法示例	class Heart { void jump() {...} } 在eat()方法内定义， 通过new Heart().jump()调用	方法内定义的类不能使用static修饰

8.局部内部类现实操作

知识点	焦点内容	重点
局部内部类的现实操作	现实操作复杂，需通过接口、抽象类作为方法参数传递和返回值返回来明白	局部内部类的现实操作方式
接口作为方法参数传递	定义接口类型，实现类实现接口并重写方法，方法参数传递接口类型，现实传递的是实现类对象	接口不能直接实例化，需传递实现类对象
接口作为方法返回值	方法返回值类型为接口类型，现实返回的是接口的实现类对象	返回值类型与现实返回对象类型的区别
抽象类作为方法参数传递	抽象类不能实例化，方法参数传递抽象类类型，现实传递的是其子类对象	抽象类与子类对象的传递关系
抽象类作为方法返回值	方法返回值类型为抽象类类型，现实返回的是其子类对象	抽象类作为返回值类型的明白
平凡类作为方法参数和返回值	平凡类作为方法参数传递的是对象，作为方法返回值返回的也是对象	平凡类对象的传递与返回

接口作为方法参数传递，现实传递的是实现类对象 ；
接口作为方法返回值，现实返回的是接口的实现类对象：

1. public interface USB {
2.     public abstract void open();
3. }
8. public class Mouse implements USB{
9.     @Override
10.     public void open() {
11.         System.out.println("鼠标打开");
12.     }
13. }
18. public class Test01 {
19.     public static void main(String[] args) {
20.         Mouse mouse = new Mouse();
21.         method(mouse);
22.         System.out.println("================");
24.         USB usb = method01();//USB usb = new Mouse();
25.         usb.open();
26.     }
28.     /*
29.        接口作为方法参数,传递实参时,传递的是实现类对象
30.      */
31.     public static void method(USB usb){//USB usb = mouse -> 多态
32.         usb.open();
33.     }
35.     /*
36.       接口作为返回值类型返回,实际返回的是实现类对象
37.     */
38.     public static USB method01(){
39.         //Mouse mouse = new Mouse();
40.         //return mouse;
41.         return new Mouse();
42.     }
43. }

复制代码

抽象类作为方法参数传递，现实传递的是其子类对象；
抽象类作为方法返回值，现实返回的是其子类对象：

1. public abstract class Animal {
2.     public abstract void eat();
3. }
8. public class Dog extends Animal{
9.     @Override
10.     public void eat() {
11.         System.out.println("狗啃骨头");
12.     }
13. }
18. public class Test02 {
19.     public static void main(String[] args) {
20.         Dog dog = new Dog();
21.         method01(dog);
22.         System.out.println("=================");
23.         Animal animal = method02();//Animal animal = new Dog()
24.         animal.eat();
25.     }
27.     public static void method01(Animal animal){//Animal animal = dog
28.         animal.eat();
29.     }
31.     public static Animal method02(){
32.         return new Dog();
33.     }
34. }

复制代码

平凡类作为方法参数传递的是对象，作为方法返回值返回的也是对象

1. public class Person {
2.     public void eat(){
3.         System.out.println("人要干饭");
4.     }
5. }
11. public class Test03 {
12.     public static void main(String[] args) {
13.         Person person = new Person();
14.         method01(person);
15.         System.out.println("==================");
16.         Person person1 = method02();//Person person1 = new Person()
17.         person1.eat();
18.     }
19.     public static void method01(Person person){
20.         person.eat();
21.     }
23.     public static Person method02(){
24.         return new Person();
25.     }
26. }

复制代码

9.匿名内部类

知识点	焦点内容	重点
匿名内部类定义	没有显示声明类名的内部类，编译时会隐式天生对应class文件	与局部内部类的命名区别
使用场景	单次调用接口方法时替换传统四步实现方式（创建实现类→重写方法→实例化→调用）	与传统实现方式的步调对比
语法格式	new 接口/抽象类 ( ) { 重写方法 }.重写的方法();    代表实现类/子类对象	匿名对象与闻名对象的调用区别
编译机制	每个new操作会在编译时天生独立class文件（示例中天生2个匿名类文件）	类文件命名规则与天生逻辑
典范应用	USB接口案例：通过匿名内部类同时完成实现和实例化	open()/close()方法的多重调用限定
优劣对比	上风：简化单次调用代码；劣势：复杂逻辑可读性差	与Lambda表达式的适用场景差别

10.匿名内部类在开发中的使用

知识点	焦点内容	重点
匿名内部类作为参数传递	通过method01(USB usb)方法演示，直接传入new USB(){...}匿名内部类对象，替换传统实现类实例化	匿名内部类语法格式（new 接口/抽象类(){...}）与通例实现类的区别
匿名内部类作为返回值	在method01()中直接返回new USB(){...}对象，调用时通过USB usb = method01(); usb.open();实验	返回值类型需匹配接口，匿名内部类对象需完备实现抽象方法
实验流程分析	1. 调用方法 → 2. 传递/返回匿名内部类对象（本质为实现类实例） → 3. 调用重写方法（如open()）	对象生命周期：匿名内部类对象仅在调用时创建，无显式类定义

匿名内部类作为参数传递

匿名内部类作为返回值

11.API文档

知识点	焦点内容	重点
API定义	Application Programming Interface（应用编程接口），包含预定义的类、接口及其成员方法	需区分API与API文档的概念差别
API文档作用	程序员离线查询工具，支持按类/包检索方法阐明 （如Scanner类的方法参数与返回值）	必须掌握类名/包名才气有用查询，否则需依靠网络搜索
API文档结构	包含： 1. 类继承体系（如Scanner→Object）;             2. 实现接口（如Iterator）;   3. 方法详情（返回值类型/参数/功能阐明）	重点检察方法签名（如void close()）和功能形貌字段
文档使用技巧	1. 通过索引搜索类名（不区分大小写）; 2. 使命栏快捷访问设置（右键→工具栏→新建工具栏）	高频易错：直接搜索方法名无效，需通过类名定位
离线查询上风	无网络情况下仍可快速检索已知类的方法细节（如Scanner.nextInt()的异常处理）	对比百度搜索，精准性更高但前提条件严格

12.异常

知识点	焦点内容	重点
异常概念	代码运行中出现的不正常现象，分为错误(Error)和异常(Exception)	异常≠语法错误，异常是运行时题目而非语法题目
异常体系结构	Throwable(可抛的)为顶级父类，包含Error和Exception两个子类	Error代表巨大错误(如内存溢出)，Exception代表可处理题目
异常分类	编译时期异常(查抄型异常) vs 运行时期异常(非查抄型异常)	编译异常：代码编译时报错；运行异常：运行时才报错
编译时期异常	Exception类及其子类(除RuntimeException分支)	典范特性：调用方法时底层抛出，如SimpleDateFormat的parse()
运行时期异常	RuntimeException及其子类(如数组越界异常)	典范特性：编译不报错但运行时报错
异常处理机制	异常未被处理时会主动向上抛出，终极由JVM默认处理	处理流程：打印异常堆栈 → 停止程序实验
典范错误示例	递归调用导致栈溢出(StackOverflowError)	Error不可恢复，必须重构代码
典范异常示例	数组越界(ArrayIndexOutOfBoundsException) vs 日期分析异常(ParseException)	运行异常不逼迫处理，编译异常必须处理

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

继续阅读请点击广告