JAVA复习总结——期末复习知识点总结大全

第一章 一、Java 概述

（一）Java 语言的发展历程

1. 起源与诞生
   • Java 语言由詹姆士・高斯林等人于 1990 年初开发，最初名为 Oak。1995 年 5 月，SUN 公司正式发布 Java，并将其更名为 Java。Java 的名字源于一种咖啡的品种名称，其 Logo 是一杯热气腾腾的咖啡。
2. 版本演进
   • 1995 年 5 月 23 日，Java 语言诞生。1998 年 12 月 8 日，JAVA2 企业平台 J2EE 发布。1999 年 6 月，SUN 公司发布 Java 的三个版本：标准版（J2SE）、企业版（J2EE）和微型版（J2ME）。此后，Java 不断更新，2004 年 9 月 30 日，J2SE 1.5 发布，后更名为 Java SE 5.0。2005 年 6 月，JavaOne 大会召开，SUN 公司对 Java 的各种版本进行更名，J2EE 更名为 Java EE，J2SE 更名为 Java SE，J2ME 更名为 Java ME。2009 年 12 月，SUN 公司发布 Java EE 6。2011 年 7 月 28 日，Oracle 公司发布 Java SE 7。2014 年 3 月 18 日，Oracle 公司发布 Java SE 8（市场主流版本）。之后，Java SE 继续更新，陆续发布了 Java SE 9（2017 年 9 月 21 日）、Java SE 10（2018 年 3 月）、Java SE 11（2018 年 9 月）、Java SE 12（2019 年 3 月）、Java SE 13（2019 年 9 月）等版本。

（二）Java 语言的特点

1. 平台无关性
   • Java 引进虚拟机原理，运行于虚拟机之上，其数据类型与机器无关。Java 程序编译后生成字节码文件（.class 文件），由虚拟机负责解释运行，而非直接依赖操作系统。不同操作系统上的 Java 虚拟机不同，但 Java 程序只需编写一次，即可在安装了相应虚拟机的不同平台上运行，实现了 “一次编写，到处运行”。
2. 安全性
   • Java 舍弃了 C/C++ 中对存储器地址的直接操作，程序运行时内存由操作系统实时分配，避免了病毒通过指针侵入系统。字节代码验证器对字节代码进行检验，可防止网络病毒及其他非法代码侵入。此外，Java 采用异常处理机制，能有效处理内存空间不足、程序异常中止等异常事件。
3. 面向对象性
   • Java 吸取了 C++ 面向对象的概念，将数据封装于类中，通过类的继承、封装、多态等特性实现程序的简洁性和易维护性。Java 中类的继承关系单一，一个子类只有一个父类，Object 类是所有类的根类，功能强大，常被使用。
4. 跨平台性
   • Java 程序通过 JVM（虚拟机）以及字节码实现跨平台。编写的 Java 代码先由 javac 编译器编译成字节码文件，然后 JVM 中的 Java 解释器将字节码文件翻译成所在平台的机器码文件并执行。这使得 Java 程序可以在不同操作系统上运行，只需安装相应版本的虚拟机即可。
5. 支持多线程
   • Java 语言支持多线程，即程序中多个任务可以并发执行。多线程能够充分利用系统资源，提高程序的执行效率，适用于处理多个任务并行的场景，如网络编程中的服务器同时处理多个客户端请求。
6. 分布性
   • Java 是分布式语言，既支持各种层次的网络连接，又可通过 Socket 类支持可靠的流（stream）网络连接。用户可借此开发分布式的客户机和服务器应用程序，使网络成为软件应用的分布式运载工具，方便实现不同主机间的数据交互和资源共享。

（三）Java 技术平台

1. Java SE（Java Platform Standard Edition）标准版
   • 是开发普通桌面和商务应用程序的解决方案，是 Java 三个平台中最核心的部分。Java SE 包含 Java 最核心的类库，如集合、IO、数据库连接以及网络编程等，为 Java 程序开发提供了基础支持。
2. Java EE（Java Platform Enterprise Edition）企业版
   • 用于开发企业级应用程序，是一个技术平台，涵盖了 Servlet、JSP、JavaBean、JDBC、EJB、Web Service 等技术，可帮助开发者构建大规模、

（四）概述

1. Java 概述
   • 语言定义与分类：计算机语言是人与计算机通信的指令集合，包括机器语言（二进制 0 和 1 组成）、汇编语言（英文缩写标识符）和高级语言（接近自然语言），Java 是一种高级计算机语言。
   • Java 的特点
     • 平台无关性：通过虚拟机原理，运行于虚拟机之上，数据类型与机器无关，实现 “一次编写，到处运行”。
     • 安全性：舍弃指针对存储器地址的直接操作，通过字节代码验证器和异常处理机制防止病毒及非法代码侵入。
     • 面向对象性：吸取 C++ 面向对象概念，将数据封装于类中，类继承关系单一，提供众多类库，支持代码复用。
     • 跨平台性：依靠 JVM 和字节码实现，Java 程序编译为字节码文件，由 JVM 解释执行，不同操作系统需安装相应版本 JVM。
     • 支持多线程：允许程序中多个任务并发执行，提高执行效率。
     • 分布性：支持各种层次网络连接，可通过 Socket 类实现可靠流网络连接，适用于分布式应用开发。
   • Java 技术平台
     • Java SE 标准版：核心部分，用于开发普通桌面和商务应用程序，包含核心类库如集合、IO、数据库连接和网络编程等。
     • Java EE 企业版：开发企业级应用程序的平台，涵盖 Servlet、JSP、JavaBean、JDBC、EJB、Web Service 等技术。
     • Java ME 小型版：针对电子消费产品和嵌入式设备，提供智能化控制和联网功能开发，支持 HTTP 等高级协议。
   • Java 语言发展史：由詹姆士・高斯林发明，1995 年诞生，经历多次版本更新，目前 Java SE 8 是市场主流版本，Oracle 公司持续发布新版本。
2. Java 语言开发环境搭建
   • Java 虚拟机（JVM）：是 Java 程序运行环境，可解释执行 Java 字节码文件，实现跨平台特性，但不同操作系统的 JVM 不同。
   • Java 运行环境（JRE）：包含 JVM 和 Java 程序所需核心类库，运行 Java 程序需安装 JRE。
   • Java 开发工具包（JDK）：是 Java 核心，包括 JRE、开发工具（如 javac、java 等）和基础类库，版本不断升级，当前企业开发主流为 JDK 8.0。
   • JDK 安装步骤
     1. 从 Oracle 官网下载安装文件 “jdk - 8u201 - windows - x64.exe”，双击进入安装界面。
     2. 自定义安装功能和路径，选择 “开发工具” 模块，可更改安装目录。
     3. 完成安装后，会生成 JDK 安装目录，包含 bin、include、jre、lib 等目录和 src.zip 文件。
   • JDK 目录介绍
     • bin 目录：存放可执行程序，如 javac.exe（编译器）、java.exe（运行工具）、jar.exe（打包工具）和 javadoc.exe（文档生成工具）等。
     • include 目录：存放用于本地访问的文件，主要是 C 语言代码库。
     • jre 目录：Java 程序运行环境的根目录，包含 JVM、运行时类包、应用启动器和 bin 目录。
     • lib 目录：存放 Java 类库或库文件，是开发工具使用的归档包文件。
     • src.zip 文件：包含 JDK 核心类的源代码。
3. 程序开发步骤
   • 编写：在 JDK 安装目录的 bin 目录下新建 HelloWorld.java 文件，编写代码定义类、类名、main 方法及输出语句，注意符号格式。
   • 编译：打开命令行窗口，进入 JDK 的 bin 目录，输入 “javac HelloWorld.java” 命令，将 Java 源文件编译成字节码文件。
   • 运行：在命令行窗口输入 “java HelloWorld” 命令（无需添加.class 扩展名），解释运行字节码文件，输出结果。
4. 环境变量配置
   • 为什么要配置环境变量：程序编译和执行需使用 javac.exe 和 java.exe 命令，默认只能在 JDK 的 bin 目录下访问，配置环境变量可使其在任意目录下可用。
   • path 环境变量：用于保存一系列路径，操作系统在执行命令时会在当前目录和 path 环境变量中查找。若未找到 javac 命令，需配置 path 环境变量。
   • 配置步骤
     1. 右键单击桌面 “计算机”，选择 “属性”，在弹出窗口左边选择 “高级系统设置”，点击 “环境变量” 按钮。
     2. 在 “系统变量” 区域点击 “新建”，创建名为 “JAVA_HOME” 的变量，值为 JDK 安装目录。
     3. 找到 Path 变量，点击 “编辑”，在最前面添加 “% JAVA_HOME%\bin;”（注意大小写和分号），依次点击确定完成设置。
     4. 验证配置是否成功，在命令行输入 “javac”，若能正常显示帮助信息则配置成功。
5. IntelliJ IDEA 集成开发工具
   • 简介：JetBrains 公司产品，是 Java 语言的集成开发环境，具有智能代码助手、自动提示、重构等强大功能，支持多种语言和技术框架，在企业、移动和 Web 应用开发中表现出色，相比 Eclipse 优势明显。
   • 安装前准备
     • 硬件要求：内存最低 2GB（建议 4GB 或更高），硬盘 1.5GB + 至少 1GB 缓存空间，屏幕最低分辨率 1024×768，个人建议使用 8GB 内存、i5 以上 CPU 及固态硬盘提升流畅度。
     • 软件要求：支持 Microsoft Windows 10/8/7/Vista/2003/XP（32 或 64 位）操作系统，需先安装 JDK（如 JDK 1.8）。
   • 安装步骤
     1. 从官网下载 IntelliJ IDEA，根据需求选择旗舰版（收费，功能更多）或社区版（免费，功能相对较少），以 64 位 Windows 10 系统为例演示社区版安装。
     2. 双击安装文件 “ideaIC - 2021.2.1.exe”，进入安装界面，点击 “Next”。
     3. 自定义安装路径，如 “d:\develop\IntelliJ IDEA Community Edition 2021.2.1”，点击 “Next”。
     4. 在安装选择界面勾选相关选项，点击 “Next”，选择开始菜单文件夹后点击 “Install” 开始安装，安装完成后重启计算机。
   • 安装目录结构
     • bin 目录：包含启动文件、配置信息和基本属性信息。
     • jbr 目录：IDEA 自带的 Java 运行环境。
     • lib 目录：存放 idea 依赖的相关类库。
     • license 目录：相关插件许可信息。
     • plugins 目录：存放插件。
     • redist 目录：一些杂项。
   • 启动与设置选择
     1. 双击桌面快捷方式启动，首次启动需勾选协议并点击 “Continue”，在 “Data Sharing” 窗口选择 “Don’t Send”。
     2. 进入欢迎界面，在 “Projects” 选项卡可选择 “New Project”（创建新项目）、“Open”（打开已有项目）或 “Get from VCS”（从版本控制系统获取项目）。
     3. 在 “Customize” 选项卡可进行个性化设置，如选择 “IntelliJ Light” 可将背景界面设为白色。
   • 程序开发步骤
     1. 创建 Java 项目：点击 “New Project”，选择 Java 版本，不勾选 “Create project from template”，命名项目并选择存放位置后点击 “Finish”，关闭提示对话框，打开工具栏。
     2. 新建模块：在 Project 视图右键单击项目，选择 “New” - “Module”，选择 Java 及对应的 SDK，命名模块后点击 “Finish”。
     3. 创建包：右键单击模块下的 src 文件夹，选择 “New” - “Package”，命名包名后回车。
     4. 创建 Java 类：右键单击包名，选择 “New” - “Java Class”，命名类名后回车，在生成的文件中编写代码。
     5. 运行程序：右键单击代码区空白处，选择 “Run ‘HelloWorld.main ()’” 运行程序。
   • 模块（Module）的使用
     • 模块概念：在 IntelliJ IDEA 中，项目（Project）是顶级级别，模块（Module）是次级别，一个 Project 可包含多个 Module，大型项目常采用多 Module 结构，不同模块可由不同人员开发，小型项目可无需创建多个模块。
     • 删除模块：先创建一个名为 “Module01” 的模块用于演示，选择模块后右键单击选择 “Open Module Settings”，在弹出的 “Project Structure” 界面选中模块并点击 “ - ” 按钮，确认删除后点击 “OK”，此时模块虽仍存在但显示为灰色，再次右键单击可选择 “Delete” 从硬盘彻底删除。
   • 常用设置
     • 设置主题：默认提供多套主题，可根据喜好选择，如 Intellij Light、Windows 10 Light、Darcula、High contrast 等。
     • 设置显示行号和方法间分隔符：建议勾选 “Show line numbers” 显示行号。
     • 忽略大小写提示：默认区分大小写，建议取消勾选 “Match Case” 以不区分大小写，方便代码提示和补充。
     • 设置默认的字体、字体大小、字体行间距：可在相应设置项中选择字体、调整大小和行间距，如设置字体为 Consolas，大小为 18，行间距为 1.2 等。
     • Live Templates（实时代码模板）功能介绍：通过配置常用代码字母缩写，输入简写时可生成预定义代码模式，如输入 “main” + 回车可生成 main 方法，输入 “sout” + 回车可生成 System.out.println () 语句，输入 “fori” + 回车可生成 for 循环等，可提高开发效率并增加个性化

第二章–Java 编程基础核心知识点详细总结

一、Java 基本语法

（一）Java 程序的基本格式

1. 类的定义
   • Java 程序代码必须放在类中，类使用class关键字定义，格式为：修饰符 class 类名{ 程序代码 }。例如：public class HelloWorld{ public static void main(String[] args) { System.out.println("你好，java"); } }。
   • 类名应遵循大驼峰命名法，即每个单词首字母大写。
2. 语句结束与格式编排
   • 功能执行语句必须以分号（;）结束，如System.out.println("你好，java");。
   • Java 严格区分大小写，class和Class是不同的。
   • 为提高可读性，常用编排方式是一行一条语句，“{” 与语句同行，“}” 独占一行，但 Java 对格式要求不严格。
3. 字符串换行
   • 一个连续的字符串不能分成两行书写，如System.out.println("你好，java！");不能写成System.out.println("你好，java！");。若需换行，可将字符串分成两部分并用加号（+）连接，如System.out.println("你好，" + "java");。

（二）Java 中的注释

1. 单行注释
   • 用于对一行代码进行解释，以 “//” 开头，其后内容为注释，如int c = 10; // 定义一个整型变量。
2. 多行注释
   • 注释内容可为多行，以 “/” 开头，以 “/” 结尾，如/* int c = 10; int x = 5; */。
3. 文档注释
   • 以 “/**” 开头，“*/” 结尾，用于生成帮助文档，如/** name = "黑马程序员"; */。

（三）Java 中的标识符

1. 定义规则
   • 由字母、数字、下画线（_）和美元符号（）组成，不能以数字开头，不能是关键字。例如，、、username是合法标识符，而123username、class`（是关键字）是非法的。
2. 命名规范
   • 包名所有字母小写，如cn.itcast.test。
   • 类名和接口名每个单词首字母大写，如ArrayList、Iterator。
   • 常量名所有字母大写，单词间用下划线连接，如DAY_OF_MONTH。
   • 变量名和方法名第一个单词首字母小写，从第二个单词开始每个单词首字母大写，如lineNumber、getLineNumber。
   • 应使用有意义的英文单词定义标识符。

（四）Java 中的关键字

1. 关键字列表
   • 包括用于定义数据类型（如class、interface、byte、short、int、long、float、double、boolean、void）、流程控制（如if、switch、else、default、case、while、do、for、break、continue、return）、访问权限修饰符（如public、private、protected）、类与类之间关系（如extends、implements）、实例相关（如this、instanceof、new、super）、异常处理（如try、catch、finally、throw、throws）、包（如package、import）等的关键字。
2. 关键字使用注意事项
   • 所有关键字都是小写。
   • 不能用关键字命名标识符。
   • const和goto是保留字关键字，虽无意义但不能用作自定义标识符。
   • true、false和null虽不是关键字，但有特殊意义，不能作为标识符。

二、常量、变量的定义与使用

（一）变量的定义和输出

1. 变量定义
   • 变量是程序运行期间存储临时数据的内存单元标识，包含变量类型、变量名和存储的值。定义格式有两种：
     • 先声明后赋值：` 数据类型 变量名；变量名

第三章–Java 面向对象编程（上）核心知识点总结

一、面向对象思想

（一）核心概念

• 面向对象编程思想将现实世界中的事物抽象为对象，通过对象间的交互解决问题。它把构成问题的事务划分为独立对象，使开发者从执行者变为指挥者，符合人类思维习惯，能简化复杂问题。例如，在买电脑的场景中，面向过程需自己完成多个步骤，而面向对象可指挥他人（如班长）代劳。

（二）三大特性

1. 封装

• 将对象的属性和行为封装成一个整体，实现信息隐藏，保护内部数据，防止外部随意访问和修改。就像驾校学员无需知晓汽车内部工作原理，只需操作外部接口。

2. 继承

• 描述类之间的所属关系，子类可继承父类的属性和方法，实现功能扩展，增强代码复用性，便于程序维护和扩展。例如轿车类继承汽车类后可增加特有功能。

3. 多态

• 同一类的属性和方法在不同类中表现出不同行为，使程序更抽象、便捷，利于协同开发。比如 “Cut” 一词对理发师和演员有不同含义。

二、类与对象

（一）类的定义

• 类是相关属性和行为的集合，是事物的抽象描述。用成员变量表示属性，成员方法表示行为，格式为class类名{成员变量; 成员方法;}。例如，以下是一个学生类的定义：

java

class Student {
    // 成员变量，用于描述学生的属性
    String name; 
    int age;
    String sex;

    // 成员方法，用于描述学生的行为
    public void study() {
        System.out.println(name + "在学习");
    }

    public void run() {
        System.out.println(name + "在跑步");
    }
}

（二）对象的创建与使用

1. 创建对象

• 使用new关键字创建对象，有两种格式：
  • 分步创建：

java

class Student {
    String name;
    public void study() {
        System.out.println(name + "在学习");
    }
}

public class Example01 {
    public static void main(String[] args) {
        Student stu = null; // 先声明一个Student类型的变量stu，此时stu为null
        stu = new Student(); // 使用new关键字创建Student类的实例对象，并将其赋值给stu
    }
}

• 一步创建：

java

Student stu = new Student();

• 对象创建后，对象名称存于栈内存，对象的属性信息存于堆内存，栈内存中的对象名称指向堆内存中的对象空间。

2. 访问属性和方法

• 通过对象名称.属性名和对象名称.方法名访问对象的属性和方法。例如：

java

class Student {
    String name;
    public void study() {
        System.out.println(name + "在学习");
    }
}

public class Example01 {
    public static void main(String[] args) {
        Student stu1 = new Student();
        Student stu2 = new Student();
        stu1.name = "小明"; // 为stu1对象的name属性赋值
        stu1.study(); // 调用stu1对象的study方法
        stu2.name = "小华";
        stu2.study();
    }
}

（三）对象的引用传递

• 类是引用数据类型，一个堆内存空间可被多个栈内存引用。例如：

java

class Student {
    String name;
    int age;
    public void introduce() {
        System.out.println("大家好,我是" + name + ",年龄" + age);
    }
}

public class Example02 {
    public static void main(String[] args) {
        Student stu1 = new Student();
        Student stu2 = null;
        stu2 = stu1; // stu2指向stu1所指向的堆内存空间
        stu1.name = "小明";
        stu1.age = 20;
        stu2.age = 50; 
        stu1.introduce();
        stu2.introduce(); 
    }
}

• 运行结果显示两个对象输出相同内容，因为stu2获得了stu1的堆内存空间使用权，修改stu2的 `age

第四章–Java 面向对象编程（下）核心知识点总结

一、类的继承

（一）继承的概念与实现

1. 概念
   • 在 Java 中，类的继承通过extends关键字实现。子类可以继承父类的属性和方法，从而实现代码的复用和功能的扩展。例如，定义Animal类作为父类，Dog类作为子类继承Animal类：

java

class Animal {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

class Dog extends Animal {
    // 此处不写任何代码，也能继承Animal类的属性和方法
}

• 在上述代码中，Dog类继承了Animal类，虽然Dog类中没有定义任何属性和方法，但它可以访问Animal类中的getName()、setName()、getAge()和setAge()方法。

2. 规则与限制
   • Java 只支持单继承，即一个类只能有一个直接父类。例如，下面这种情况是不合法的：

java

class A {}
class B {}
class C extends A, B {} // C类不可以同时继承A类和B类

• 允许多个类继承一个父类，例如：

java

class A {}
class B extends A {}
class C extends A {} // 类B和类C都可以继承类A

• 多层继承也是可以的，例如：

java

class A {}
class B extends A {} // 类B继承类A，类B是类A的子类
class C extends B {} // 类C继承类B，类C是类B的子类，同时也是类A的子类

• 子类不能直接访问父类中的私有成员，但可以调用父类的非私有方法来间接访问私有成员。

（二）方法的重写

1. 重写规则
   • 子类重写父类的方法时，方法名、参数列表和返回值类型必须相同。例如，在Animal类和Dog类中重写shout()方法：

java

class Animal {
    public void shout() {
        System.out.println("动物发出叫声");
    }
}

class Dog extends Animal {
    @Override
    public void shout() {
        System.out.println("汪汪汪......");
    }
}

• 子类重写的方法不能拥有比父类方法更严格的访问权限。例如，如果父类中的方法是public权限，子类的方法就不能是private权限。

2. 重写示例
   • 在上述代码中，Dog类重写了Animal类的shout()方法。在main方法中创建Dog类对象并调用shout()方法时，执行的是子类重写后的方法：

java

public class Example03 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.shout(); 
    }
}

• 输出结果为：汪汪汪......

（三）super关键字

1. 访问父类成员
   • super关键字可以在子类中访问父类的成员变量和成员方法。例如：

java

class Animal {
    String name = "动物";

    void shout() {
        System.out.println("动物发出叫声");
    }
}

class Dog extends Animal {
    String name = "犬类";

    public void shout() {
        super.shout(); 
        System.out.println("汪汪汪....");
    }

    public void printName() {
        System.out.println("名字: " + super.name); 
    }
}

• 在Dog类的shout()方法中，使用super.shout()调用了父类的shout()方法；在printName()方法中，使用super.name访问了父类的name属性。

2. 调用父类构造方法
   • 使用super(参数1, 参数2…)可以在子类构造方法中调用父类的构造方法，且该语句必须位于子类构造方法的第一行，且只能出现一次。例如：

java

class Animal {
    public Animal(String name) {
        System.out.println("我是一只" + name);
    }
}

class Dog extends Animal {
    public Dog() {
        super("沙皮狗"); 
    }
}

• 在实例化Dog对象时，会先调用父类Animal的有参构造方法。

二、final关键字

（一）修饰类

• 被final修饰的类不能被继承。例如：

java

final class Animal {
    // 方法体为空
}

class Dog extends Animal {
    // 方法体为空
}

• 当Dog类试图继承Animal类时，编译器会报错，提示 “无法从最终cn.itcast07.Animal进行继承”。

（二）修饰方法

• 被final修饰的方法不能被子类重写。例如：

java

class Animal {
    public final void shout() {
    }
}

class Dog extends Animal {
    public void shout() {
    }
}

• 在上述代码中，Dog类重写Animal类中被final修饰的shout()方法时，编译器会报错。

（三）修饰变量

• 被final修饰的变量为常量，只能在声明时赋值一次，后续不能再修改。例如：

java

public class Example09 {
    public static void main(String[] args) {
        final int AGE = 18;
        AGE = 20; // 再次赋值会报错
    }
}

• 对AGE进行第二次赋值时，编译器会报错，提示 “无法为最终变量AGE分配值”。常量命名通常采用大写字母，若使用public static final声明变量，则成为全局变量，如public static final String NAME = "哈士奇";。

三、抽象类与接口

（一）抽象类

1. 定义与规则
   • 抽象类使用abstract关键字修饰，包含抽象方法（使用abstract关键字修饰，无方法体）的类必须是抽象类。例如：

java

abstract class Animal {
    public void eat() {
        System.out.println("吃东西");
    }

    public abstract void shout();
}

• 一个类继承抽象类后，必须实现抽象类中的全部抽象方法，否则该子类也需被定义为抽象类。

2. 使用示例
   • Dog类继承抽象类Animal并实现shout()方法：

java

class Dog extends Animal {
    @Override
    public void shout() {
        System.out.println("汪汪...");
    }
}

public class Example10 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.shout(); 
        dog.eat(); 
    }
}

• 在上述代码中，Dog类实现了Animal类中的抽象方法shout()，可以正常实例化并调用方法。

（二）接口

1. 定义与特点
   • 接口使用interface关键字声明，由全局常量（默认使用public static final修饰）和公共抽象方法（默认使用public abstract修饰）组成。例如：

java

interface Animal {
    int ID = 1;
    String NAME = "牧羊犬";

    void shout();

    static int getID() {
        return ID;
    }

    default void info() {
        System.out.println("名称: " + NAME);
    }
}

• 在上述代码中，ID和NAME是全局常量，shout()是抽象方法，getID()是静态方法，info()是默认方法。一个接口可以继承多个父接口，一个类可以通过implements关键字实现多个接口，实现类必须实现接口中的所有抽象方法。

2. 示例与应用
   • Dog类实现Animal接口并实现其抽象方法：

java

class Dog implements Animal {
    @Override
    public void shout() {
        System.out.println("汪汪.);
    }

    @Override
    public void eat() {
        System.out.println("喜欢吃骨头");
    }
}

public class Example11 {
    public static void main(String[] args) {
        System.out.println("编号" + Animal.getID());
        Dog dog = new Dog();
        dog.info();
        dog.shout();
        dog.eat();
    }
}

• 在上述代码中，Dog类实现了Animal接口中的抽象方法shout()和eat()，可以通过Dog类对象访问接口中的常量、方法，也可以通过接口名调用静态方法。

四、多态

（一）对象类型转换

1. 向上转型
   • 子类对象自动转换为父类对象，格式为父类类型 父类对象 = 子类实例。例如：

java

interface Animal {
    void shout();
}

class Dog implements Animal {
    @Override
    public void shout() {
        System.out.println("汪汪....");
    }

    void eat() {
        System.out.println("吃骨头....");
    }
}

public class Example13 {
    public static void main(String[] args) {
        Animal an = new Dog(); 
        an.shout();
        // an.eat(); // 出错，不能调用子类的特有方法
    }
}

• 在上述代码中，Dog类对象向上转型为Animal类对象an，通过an调用shout()方法时，执行的是Dog类中重写的shout()方法，但不能调用Dog类的特有方法eat()。

2. 向下转型
   • 必须指明要转型的子类类型，格式为父类类型 父类对象 = 子类实例; 子类类型 子类对象 = (子类)父类对象。例如：

java

abstract class Animal {
    public abstract void shout();
}

class Dog extends Animal {
    @Override
    public void shout() {
        System.out.println("汪汪.....");
    }

    public void eat() {
        System.out.println("吃骨头......");
    }
}

public class Example14 {
    public static void main(String[] args) {
        Animal an = new Dog(); 
        Dog dog = (Dog)an; 
        dog.shout();
        dog.eat();
    }
}

• 在上述代码中，先将Dog类对象向上转型为Animal类对象an，然后再向下转型为Dog类对象dog，此时dog可以调用Dog类的特有方法eat()。向下转型前必须先发生向上转型，否则会出现对象转换异常。

（二）多态概述与形式

1. 概念
   • 多态指在同一个方法中，由于参数类型不同导致执行效果各异的现象，继承是其实现基础。Java 中多态主要有方法重载和对象多态性（方法重写）两种形式。
2. 示例
   • 定义Animal接口，Dog类和Cat类实现该接口并实现shout()方法：

java

interface Animal {
    void shout();
}

class Dog implements Animal {
    @Override
    public void shout() {
        System.out.println("汪汪.....");
    }
}

class Cat implements Animal {
    @Override
    public void shout() {
        System.out.println("喵喵......");
    }
}

public class Example15 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        Cat cat = new Cat();
        animalShout(dog);
        animalShout(cat);
    }

    public static void animalShout(Animal animal) {
        animal.shout();
    }
}

• 在上述代码中，animalShout()方法接收Animal类型参数，通过传入不同的子类对象dog和cat，实现了多态，分别输出了不同的结果。

（三）instanceof关键字

• instanceof关键字用于判断一个对象是否是某个类（或接口）的实例，格式为对象 instanceof类（或接口）。例如：

java

class Animal {
    public void shout() {
        System.out.println("动物叫......");
    }
}

class Dog extends Animal {
    @Override
    public void shout() {
        System.out.println("汪汪.....");
    }

    public void eat() {
        System.out.println("吃骨头......");
    }
}

public class Example16 {
    public static void main(String[] args) {
        Animal a1 = new Dog();
        System.out.println("Animal a1 = new Dog(): " + (a1 instanceof Animal));
        System.out.println("Animal a1 = new Dog(): " + (a1 instanceof Dog));
        Animal a2 = new Animal();
        System.out.println("Animal a2 = new Animal(): " + (a2 instanceof Animal));
        System.out.println("Animal a2 = new Animal(): " + (a2 instanceof Dog));
    }
}

• 在上述代码中，通过instanceof关键字判断a1和a2是否是Animal类和Dog类的实例，输出结果分别为true、true、true、false。

五、内部类

（一）成员内部类

• 成员内部类定义在类中方法外，可以访问外部类的所有成员。例如：

java

class Outer {
    private int num = 4;

    public void test() {
        Inner inner = new Inner();
        inner.show();
    }

    class Inner {
        public void show() {
            System.out.println("成员内部类show方法执行了。。");
            System.out.println("访问Outer类的num=" + num);
        }
    }
}

public class Example19 {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.test();
    }
}

• 在上述代码中，Inner类是Outer类的成员内部类，在Inner类的show()方法中可以访问Outer类的num成员变量。通过外部类的test()方法创建内部类Inner的实例对象并调用其show()方法。也可以通过外部类创建内部类对象，格式为外部类名.内部类名 变量名 = new外部类名().new内部类名();，如Outer.Inner inner = new Outer().new Inner();。若内部类被声明为私有，则外界无法访问。

（二）局部内部类

• 局部内部类定义在方法内，只能在所属方法中创建内部类对象。例如：

java

class Outer {
    int num = 10;

    public void method() {
        class Inner {
            public void show() {
                System.out.println("局部内部类的show方法执行了。。");
                System.out.println("外部内部类的num: " + num);
            }
        }
        Inner inner = new Inner();
        inner.show();
    }
}

public class Example21 {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.method();
    }
}

• 在上述代码中，Inner类是Outer类的局部内部类，在Inner类的show()方法中可以访问Outer类的num成员变量。在Outer类的method()方法中创建Inner类对象并调用其show()方法。

（三）静态内部类

• 静态内部类在成员内部类基础上加static关键字，只能访问外部类的静态成员。例如：

java

class Outer {
    static int num = 10;

    static class StaticInner {
        public void show() {
            System.out.println("静态内部类的show方法执行了。。");
            System.out.println("外部静态变量num=" + num);
        }
    }
}

public class Example22 {
    public static void main(String[] args) {
        Outer.StaticInner inner = new Outer.StaticInner();
        inner.show();
    }
}

• 在上述代码中，StaticInner类是Outer类的静态内部类，在StaticInner类的show()方法中可以访问Outer类的静态成员变量num。创建静态内部类对象的格式为外部类名.静态内部类名 变量名 = new外部类名().静态内部类名();，如Outer.StaticInner inner = new Outer.StaticInner();。若访问外部类非静态成员会导致编译错误。

（四）匿名内部类

• 匿名内部类没有名称，用于在调用方法时，若方法参数为接口

第五章–Java API 核心知识点总结

一、API 概述

（一）API 概念

• API（Application Programming Interface）即应用程序编程接口，是 Java 提供的各种功能类的集合。例如，机器人厂商提供的用于控制机器人的 Java 类，就是一种 API，开发者可利用这些类中定义好的方法控制机器人动作，无需了解底层实现细节。

（二）API 使用步骤

1. 打开帮助文档（如 “jdk api 1.8_google.CHM”）。
2. 在索引搜索框中输入要学习的类名（如 “Random”）并回车。
3. 查看类所在包，若不在java.lang包下则需导包（如import java.util.Random）。
4. 阅读类的描述，了解其功能（如 Random 类用于生成伪随机数）。
5. 查看构造方法，确定创建对象的方式（如 Random 有无参和带参构造）。
6. 根据需求选择合适的构造方法创建对象（如Random r = new Random();）。
7. 查看成员方法，注意方法的功能、返回值类型、参数等，以调用方法实现特定功能（如r.nextInt(100)生成 [0, 100) 之间的随机数）。

二、字符串类

（一）String 类

1. 初始化
   • 可通过字符串常量直接初始化（如String str1 = "abc";），也可使用构造方法（如String s2 = new String("abc");、String s3 = new String(charArray);）。
2. 常见操作
   • 判断操作
     • 常用方法包括equals（比较内容是否相同）、equalsIgnoreCase（忽略大小写比较内容）、startsWith（判断是否以指定字符串开头）、endsWith（判断是否以指定字符串结尾）、contains（判断是否包含指定字符序列）、isEmpty（判断是否为空）。例如：

java

String s1 = "hello";
String s2 = "Hello";
System.out.println("比较字符串s1和s2的内容是否相同: " + s1.equals(s2));
System.out.println("比较字符串s1和s2的内容是否相同,忽略大小写: " + s1.equalsIgnoreCase(s2));
System.out.println("判断字符串s1是否以he开头: " + s1.startsWith("he"));
System.out.println("判断字符串s1是否以ll结尾: " + s1.endsWith("ll"));
System.out.println("判断字符串s1是否包含tri: " + s1.contains("tri"));
System.out.println("判断字符串是否为空: " + s1.isEmpty());

• 注意==和equals的区别，==比较对象地址，equals比较字符内容。例如：

java

String str1 = new String("abc");
String str2 = new String("abc");
System.out.println(str1 == str2);  
System.out.println(str1.equals(str2)); 

• 获取功能
  • 方法有length（获取字符串长度）、charAt（获取指定索引处字符）、indexOf（获取指定字符串首次出现索引）、substring（截取字符串）。例如：

java

String str = "hello world";
System.out.println("字符串的长度: " + str.length());
System.out.println("索引为0的字符: " + str.charAt(0));
System.out.println("索引为1的字符: " + str.charAt(1));
System.out.println("获取1在字符串对象中第一次出现的索引: " + str.indexOf("1"));
System.out.println("获取ak在字符串对象中第一次出现的索引: " + str.indexOf("ak"));
System.out.println("从下标5开始截取到末尾的结果: " + str.substring(5));
System.out.println("从下标5 - 6截取到字符的结果: " + str.substring(5, 7));

• 转换操作
  • 包含toCharArray（转换为字符数组）、valueOf（将基本类型转换为字符串）、toLowerCase（转换为小写字符串）、toUpperCase（转换为大写字符串）等方法。例如：

java

char[] charArray = {'H', 'e', 'l', 'l', 'o'};
System.out.println(new String(charArray));
System.out.println("将int值转换为String类型之后的结果: " + String

第六章–Java 集合框架核心知识点总结

一、集合概述

（一）集合概念

• 集合用于存储数目不确定的对象，位于java.util包中，可存储任意类型对象且长度可变。

（二）集合分类

1. 单列集合（Collection）
   • 根接口为 Collection，用于存储符合规则元素，有 List 和 Set 两个重要子接口。
     • List 特点：元素有序、可重复，主要实现类有 ArrayList 和 LinkedList。
     • Set 特点：元素无序、不可重复，主要实现类有 HashSet 和 TreeSet。
2. 双列集合（Map）
   • 根接口为 Map，用于存储键值映射关系元素，每个键最多映射一个值，主要实现类有 HashMap 和 TreeMap。

二、Collection 接口

（一）接口方法

1. 基本操作方法
   • boolean add(Object o)：向集合添加元素，添加成功返回true，否则返回false。例如：

Collection<String> collection = new ArrayList<>();
boolean result = collection.add("张三"); // 添加元素"张三"，返回true

• boolean addAll(Collection c)：将指定集合中的所有元素添加到当前集合，操作成功返回true，否则返回false。例如：

收起

Collection<String> collection1 = new ArrayList<>();
collection1.add("张三");
Collection<String> collection2 = new ArrayList<>();
collection2.add("李四");
collection2.add("王五");
boolean result = collection1.addAll(collection2); // 将collection2中的元素添加到collection1，返回true

• void clear()：删除集合中的所有元素，使集合变为空集合。例如：

收起

java

Collection<String> collection = new ArrayList<>();
collection.add("张三");
collection.add("李四");
collection.clear(); // 清空集合

• boolean remove(Object o)：从集合中删除指定元素，若元素存在且删除成功返回true，否则返回false。例如：

收起

java

Collection<String> collection = new ArrayList<>();
collection.add("张三");
collection.add("李四");
boolean result = collection.remove("张三"); // 删除元素"张三"，返回true

• boolean removeAll(Collection c)：删除当前集合中与指定集合相同的所有元素，若至少删除一个元素返回true，否则返回false。例如：

收起

java

Collection<String> collection1 = new ArrayList<>();
collection1.add("张三");
collection1.add("李四");
Collection<String> collection2 = new ArrayList<>();
collection2.add("李四");
boolean result = collection1.removeAll(collection2); // 从collection1中删除与collection2相同的元素"李四"，返回true

• boolean isEmpty()：判断集合是否为空，若集合中无元素返回true，否则返回false。例如：

收起

java

Collection<String> collection = new ArrayList<>();
boolean result = collection.isEmpty(); // 集合为空，返回true
collection.add("张三");
result = collection.isEmpty(); // 集合不为空，返回false

• boolean contains(Object o)：判断集合是否包含指定元素，若包含返回true，否则返回false。例如：

收起

java

Collection<String> collection = new ArrayList<>();
collection.add("张三");
boolean result = collection.contains("张三"); // 集合包含"张三"，返回true

• boolean containsAll(Collection c)：判断当前集合是否包含指定集合中的所有元素，若包含返回true，否则返回false。例如：

收起

java

Collection<String> collection1 = new ArrayList<>();
collection1.add("张三");
collection1.add("李四");
Collection<String> collection2 = new ArrayList<>();
collection2.add("李四");
boolean result = collection1.contains

三、List 接口

（一）接口简介

• 继承自 Collection 接口，元素有序且可重复，可通过索引访问元素，还增加了根据索引操作集合的特有方法，如下表：

  方法声明	功能描述
  void add(int index, Object element)	在指定索引处插入元素
  boolean addAll(int index, Collection c)	在指定索引处插入指定集合元素
  Object get(int index)	返回指定索引处元素
  Object remove(int index)	删除指定索引处元素
  Object set(int index, Object element)	替换指定索引处元素并返回被替换元素
  int indexOf(Object o)	返回元素首次出现位置索引
  int lastIndexOf(Object o)	返回元素最后一次出现位置索引
  List subList(int fromIndex, int toIndex)	返回指定范围子集合

（二）ArrayList 集合

1. 实现原理与特点
   • ArrayList 内部使用数组来存储元素，当创建 ArrayList 对象时，会初始化一个默认容量的数组（默认容量为 10）。当添加元素时，如果元素数量超过了数组的容量，ArrayList 会自动创建一个更大的数组，并将原有元素复制到新数组中。这种机制使得 ArrayList 可以动态地扩展容量，但在频繁进行增删操作时，由于需要复制数组元素，效率相对较低。而对于查找操作，由于可以通过索引直接访问数组元素，速度较快。例如，在一个存储大量学生信息的 ArrayList 中，如果需要频繁根据学号查找学生信息，ArrayList 的查找效率较高；但如果需要频繁插入或删除学生信息，可能会导致性能下降。
2. 常用方法
   • 构造方法：ArrayList list = new ArrayList(); 创建一个空的 ArrayList 对象，其初始容量为 10。也可以使用ArrayList(int initialCapacity)构造方法指定初始容量，例如ArrayList<String> list = new ArrayList<>(20); 创建一个初始容量为 20 的 ArrayList 来存储字符串元素。
   • 添加元素方法
     • boolean add(E e)：将指定元素添加到列表的末尾。例如：

收起

java

ArrayList<String> list = new ArrayList<>();
boolean added = list.add("apple"); // 将"apple"添加到列表末尾，返回true

• void add(int index, E element)：在指定索引处插入元素。例如：

收起

java

ArrayList<String> list = new ArrayList<>();
list.add("apple");
list.add("banana");
list.add(1, "orange"); // 在索引1处插入"orange"，列表变为["apple", "orange", "banana"]

• 获取元素方法
  • E get(int index)：返回指定索引处的元素。例如：

收起

java

ArrayList<String> list = new ArrayList<>();
list.add("apple");
list.add("banana");
String element = list.get(1); // 获取索引1处的元素，即"banana"

• 获取集合大小方法
  • int size()：返回列表中元素的个数。例如：

收起

java

ArrayList<String> list = new ArrayList<>();
list.add("apple");
list.add("banana");
int size = list.size(); // 返回列表中元素个数，即2

• 删除元素方法
  • boolean remove(Object o)：删除列表中第一个出现的指定元素。例如：

收起

java

ArrayList<String> list = new ArrayList<>();
list.add("apple");
list.add("banana");
boolean removed = list.remove("banana"); // 删除"banana"，返回true

• E remove(int index)：删除指定索引处的元素，并返回被删除的元素。例如：

收起

java

ArrayList<String> list = new ArrayList<>();
list.add("apple");
list.add("banana");
String removedElement = list.remove(0); // 删除索引0处的元素"apple"，并返回"apple"

• 修改元素方法
  • E set(int index, E element)：用指定元素替换指定索引处的元素，并返回被替换的元素。例如：

收起

java

ArrayList<String> list = new ArrayList<>();
list.add("apple");
list.add("banana");
String oldElement = list.set(1, "grape"); // 将索引1处的元素"banana"替换为"grape"，并返回"banana"

3. 示例代码分析
   • 在addArray方法中：
     • 首先创建了一个ArrayList<String>对象array。
     • 然后使用add方法依次添加了 “张三”、“李四”、“王五” 三个元素到列表末尾。
     • 接着使用add(int index, E element)方法在索引 1 处插入了 “hello” 元素。
     • 最后打印array列表，此时列表中的元素为 [“张三”, “hello”, “李四”, “王五”]。
   • 在deleteArray方法中：
     • 创建了一个新的ArrayList<String>对象array，并添加了 “张三”、“李四”、“王五” 三个元素。
     • 使用remove(Object o)方法删除元素 “李四”，这里传入的参数是字符串 “删除元素李四：李四”，实际删除的是列表中的 “李四” 元素。
     • 接着使用remove(int index)方法删除索引 2 处的元素