学习日记-day14-5.23

永日456702025-05-24 10:55

完成目标：

知识点：

1.多态转型

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

2.多态实例

定义笔记本类，具备开机，关机和使用USB设备的功能。具体是什么USB设备，笔记本并不关心，只要符合USB规格的设备都可以。鼠标和键盘要想能在电脑上使用，那么鼠标和键盘也必须遵守USB规范，不然鼠标和键盘的生产出来无法使用;

进行描述笔记本类，实现笔记本使用USB鼠标、USB键盘

  • USB接口，包含开启功能、关闭功能

  • 笔记本类，包含运行功能、关机功能、使用USB设备功能

  • 鼠标类，要符合USB接口

  • 键盘类，要符合USB接口

java 复制代码 
public interface USB {
    public abstract void open();
    public abstract void close();
}





public class Mouse implements USB{
    @Override
    public void open() {
        System.out.println("鼠标开启");
    }

    @Override
    public void close() {
        System.out.println("鼠标关闭");
    }

    //特有方法
    public void click(){
        System.out.println("点我");
    }
}






public class KeyBoard implements USB{
    @Override
    public void open() {
        System.out.println("键盘开启");
    }

    @Override
    public void close() {
        System.out.println("键盘关闭");
    }

    //特有功能
    public void input(){
        System.out.println("敲我");
    }
}




public class NoteBook {
    //开机
    public void start(){
        System.out.println("开机");
    }

    //使用USB
    /*
       USB usb = mouse  多态
       USB usb = keyBoard 多态
     */
    public void useUSB(USB usb){
        if (usb instanceof Mouse){
            Mouse mouse = (Mouse) usb;
            mouse.open();
            mouse.click();
            mouse.close();
        }else{
            KeyBoard keyBoard = (KeyBoard) usb;
            keyBoard.open();
            keyBoard.input();
            keyBoard.close();
        }
        //usb.open();
        //usb.close();
    }

    //关机
    public void stop(){
        System.out.println("关机");
    }
}





public class Test01 {
    public static void main(String[] args) {
        NoteBook noteBook = new NoteBook();
        Mouse mouse = new Mouse();
        noteBook.start();
        noteBook.useUSB(mouse);
        noteBook.stop();

        System.out.println("===========");
        KeyBoard keyBoard = new KeyBoard();
        noteBook.start();
        noteBook.useUSB(keyBoard);
        noteBook.stop();
    }
}

|---------|-------------------------------------------------|---------------------------------|
| 知识点 | 核心内容 | 重点 |
| 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.局部内部类实际操作

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

接口作为方法参数传递，实际传递的是实现类对象 ；

接口作为方法返回值，实际返回的是接口的实现类对象：

java 复制代码 
public interface USB {
    public abstract void open();
}




public class Mouse implements USB{
    @Override
    public void open() {
        System.out.println("鼠标打开");
    }
}




public class Test01 {
    public static void main(String[] args) {
        Mouse mouse = new Mouse();
        method(mouse);
        System.out.println("================");

        USB usb = method01();//USB usb = new Mouse();
        usb.open();
    }

    /*
       接口作为方法参数,传递实参时,传递的是实现类对象
     */
    public static void method(USB usb){//USB usb = mouse -> 多态
        usb.open();
    }

    /*
      接口作为返回值类型返回,实际返回的是实现类对象
    */
    public static USB method01(){
        //Mouse mouse = new Mouse();
        //return mouse;
        return new Mouse();
    }
}

抽象类作为方法参数传递，实际传递的是其子类对象；

抽象类作为方法返回值，实际返回的是其子类对象：

java 复制代码 
public abstract class Animal {
    public abstract void eat();
}




public class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗啃骨头");
    }
}




public class Test02 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        method01(dog);
        System.out.println("=================");
        Animal animal = method02();//Animal animal = new Dog()
        animal.eat();
    }

    public static void method01(Animal animal){//Animal animal = dog
        animal.eat();
    }

    public static Animal method02(){
        return new Dog();
    }
}

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

java 复制代码 
public class Person {
    public void eat(){
        System.out.println("人要干饭");
    }
}





public class Test03 {
    public static void main(String[] args) {
        Person person = new Person();
        method01(person);
        System.out.println("==================");
        Person person1 = method02();//Person person1 = new Person()
        person1.eat();
    }
    public static void method01(Person person){
        person.eat();
    }

    public static Person method02(){
        return new Person();
    }
}
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) | 运行异常不强制处理，编译异常必须处理 |

相关推荐
一年春又来1 小时前
AI-02a5a8.神经网络-与学习相关的技巧-超参数的验证
人工智能·神经网络·学习
MingYue_SSS1 小时前
一些较好的学习方法
经验分享·笔记·嵌入式硬件·学习·学习方法
zhangrelay1 小时前
ROS云课-一键配置-250523无错版
学习
胡耀超1 小时前
从逻辑视角学习信息论：概念框架与实践指南
学习·安全·网络安全·信息与通信·数据科学·信息论
qq_393828222 小时前
Excel多合一文件合并工具
学习·excel·软件需求
茶茶敲代码2 小时前
前端vscode学习
学习
Bonnie_12153 小时前
02-jenkins学习之旅-基础配置
运维·学习·jenkins
xiaoxiaoxiaolll3 小时前
光子计算落地里程碑：实验级OSS芯片实现MNIST高效分类，登顶《Nature》子刊
人工智能·学习·算法
海尔辛3 小时前
学习黑客TTryHackMe — Tcpdump基础 | 网络安全入门（THM）
学习·测试工具·tcpdump
伍贰什丿3 小时前
python学习day2：运算符+优先级
开发语言·python·学习
热门推荐
01KGG转MP3工具|非KGM文件|解密音频02从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑03YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】04【SpeedAI科研小助手】2分钟极速解决知网维普重复率、AIGC率过高，一键全文降！文件格式不变，公式都保留的！05组基轨迹建模 GBTM的介绍与实现（Stata 或 R）06DeepSeek各版本说明与优缺点分析07Android Termux 安装Kali Linux 或 kali Nethunter史诗级详细教程08VMware虚拟机安装Win7专业版保姆级教程（附镜像包）09Coze扣子平台完整体验和实践（附国内和国际版对比）10【解决】Android Gradle Sync 报错 Could not read workspace metadata