1 Java语言概述

1.1 历史与诞生

1. Java 前身：Oak
2. Java 之父：James Gosling
3. Java 正式推出：1995 年
4. 名字来源：爪哇咖啡，不是缩写
5. 1998 推出：Java 2
6. Java 2 三大平台：J2SE（标准版）J2EE（企业版）J2ME（微型版）

1.2 Java 核心特性

最重要特性：平台无关性（跨平台）：一次编写，到处运行

• 平台无关性
• 面向对象：支持封装、继承、多态；用接口 interface替代多重继承
• 简单性：取消指针、goto、运算符重载、多重继承、头文件
• 健壮性：自动垃圾回收 GC、数组下标检查、异常处理 try-catch-finally
• 安全性：4 大安全机制（字节码校验器、类装载器、运行时内存布局、文件访问机制）
• 分布式
• 解释型
• 可移植性
• 高性能
• 多线程：用 synchronized 实现同步
• 动态性

1.3 运行机制

• Java 是：半编译、半解释型语言
• 编译：.java 源文件 → javac → .class 字节码
• 运行：字节码 → JVM 解释执行
• 跨平台依靠：Java 虚拟机 JVM
• JVM 作用：解释执行字节码，实现平台无关

1.4 开发环境与工具

• 开发工具包：JDK
• 核心命令：
  • javac：编译
  • java：运行
  • appletviewer：运行 Applet
  • javadoc：生成 API 文档
  • jdb：调试
• 运行环境：JRE

1.5 程序开发步骤

• 编辑：.java 源文件
• 编译：javac 文件名.java
• 运行：java 类名（不加 .class）

1.6 Java 程序两大类型

 Java Application（应用程序）

• 独立运行

• 程序入口：main () 方法

• 运行命令：java

 Java Applet（小应用程序）

• 浏览器 /appletviewer 运行

• 无 main () 方法

• 必须继承 Applet

• 需要配合 HTML 文件

1.7 源文件语法规则

• 文件名必须 与 public 类名完全一致（大小写敏感）
• 一个 .java 最多 1 个 public 类
• Java 严格区分大小写
• 程序入口 main 方法固定格式：

public static void main(String[] args) { }

1.8 注释

• 单行：//
• 多行：/* */
• 文档注释：/** */（可生成 API 文档）

1.9 细节知识点

• Java 基本解释器大小：40KB
• Java 是基于网络设计的语言
• 字节码是中间代码，不是机器码
• 垃圾回收：自动回收无用内存，程序员无需手动释放

2 Java语言基础

2.1 编码规范

• 包名：全小写
• 类名 / 接口名：首字母大写，每个单词首字母大写（大驼峰）
• 方法名 / 变量名：小写开头，每个单词首字母大写（小驼峰）
• 常量名：全大写，下划线分隔

2.2 数据类型

1、两大类

• 基本数据类型（8 种）
• 引用数据类型：类、接口、数组

2、8 种基本类型（必须背）

• 整型 4 种：byte、short、int、long
• 浮点型 2 种：float、double
• 字符型：char
• 布尔型：boolean

3、整型细节

• 十进制：正常写
• 八进制：以 0 开头
• 十六进制：以 0x / 0X 开头
• long 常量：必须加 L/l

4、浮点细节

• 默认类型：double
• float 常量：必须加 F/f
• 禁止用==直接比较浮点数

5、字符型 char

• 占16 位，Unicode 编码
• 单引号' '，只能存一个字符
• 范围：0 ~ 65535
• 常用转义字符：\n换行、\t制表、\\、\"、\'、\r回车

6、布尔型 boolean

• 只有true / false
• 不能和数字互相转换（和 C 语言不同）

7、基本类型对应的包装类

byte→Byte

short→Short

int→Integer

long→Long

float→Float

double→Double

char→Character

boolean→Boolean

2.3 标识符、关键字、变量

1、标识符命名规则

• 开头：字母、_、$
• 后面：字母、_、$、数字
• 区分大小写，不能用关键字
• 支持 Unicode（可用中文，但考试不考）

2、变量三要素

类型、名字、作用域先声明，后使用

3、默认初始值（填空必考）

• byte/short/int/long：0
• float/double：0.0
• char：\u0000
• boolean：false
• 引用类型：null

4、final 常量

• final int a = 10;
• 一旦赋值不能修改

2.4 类型转换

1、自动类型转换（隐式）

• 小 → 大
• 顺序：byte,short,char → int → long → float → double

2、强制类型转换（显式）

• 大 → 小
• 格式：(目标类型)变量
• 例：int a = 100; byte b = (byte)a;
• 注意：可能丢失精度、溢出

2.5 运算符

1. 算术运算符

+ - * / % ++ --

• %：结果符号与被除数一致
• ++：前 ++ 先加再用；后 ++ 先用再加

2. 关系运算符

> < >= <= == !=

• 结果一定是boolean

3. 逻辑运算符（只对 boolean）

&& || !

• && 逻辑与：一假则假
• || 逻辑或：一真则真
• 短路特性：左边能确定结果，右边不执行

4. 位运算符（了解）

~ & | ^ >> << >>>

• >>：有符号右移
• >>>：无符号右移（补 0）

5. 赋值运算符

= += -= *= /= %= ...

6. 三元运算符（条件运算符）

条件 ? 表达式1 : 表达式2

• 结果类型必须一致

7. 字符串连接 +

• 任意类型 + 字符串 → 字符串
• 例：3+4+"a" → "7a"

8. 运算符优先级（记住）

() → 一元 → 算术 → 移位 → 关系 → 位 → 逻辑 → 三元 → 赋值

2.6 流程控制

1、条件语句 if

if(条件){}
else if(条件){}
else{}

• 条件必须是 boolean，不能用数字

2、多分支 switch

switch(表达式){
    case 常量: 语句; break;
    default: 语句;
}

• 表达式类型：byte、short、char、int
• case 不能重复
• 无 break 会穿透 case
• default 可选

3、循环语句

• while：先判断，后执行
• do-while：先执行一次，再判断
• for：最常用，三部分可选

4. 跳转语句

• break：跳出当前循环 /switch；带标号可跳出外层
• continue：跳过本次，进入下一次循环
• return：退出方法，可带返回值

5. Java 没有 goto

• goto 是保留字，但不能用

2.7 细节考点

• Java 基本类型共8 种。
• char 占16 位，是 Unicode。
• boolean只能是 true/false，不转数字。
• 自动转换：小→大；强制转换：大→小。
• 整数默认int，小数默认double。
• long 加L，float 加F。
• if/while 条件必须是 boolean。
• switch 表达式只能是整型 / 字符型。
• break 跳出循环；continue继续下一次。
• 3+4+"abc"结果是 **"7abc"**。

3 字符串

3.1 String 类（不可变字符串）

1. 本质

• String 是字符串常量，创建后内容不可修改
• 任何修改操作都会生成新的 String 对象，原串不变

1. 两种创建方式

• 直接赋值：String s = "Hello";（存入字符串常量池）
• new 创建：String s = new String("Hello");（在堆内存）

1. String 构造方法

• String()：创建空字符串
• String(String value)：用字符串创建
• String(char value[])：用字符数组创建
• String(char value[], int offset, int count)：从数组指定位置取 count 个字符创建
• String(byte ascii[], int offset, int count)：用字节数组创建

1. String 常用方法（必须全部背）

• length()：返回字符串长度
• toLowerCase()：转小写
• toUpperCase()：转大写
• charAt(int index)：返回指定索引位置的字符
• substring(int begin)：从 begin 截取到末尾
• substring(int begin, int end)：截取 [begin, end) 左闭右开
• indexOf(int ch)：返回字符第一次出现的索引，没找到返回 -1
• lastIndexOf(int ch)：返回字符最后一次出现的索引
• startsWith(String prefix)：判断是否以指定字符串开头
• endsWith(String suffix)：判断是否以指定字符串结尾
• regionMatches(...)：比较指定区域字符串是否相等
• replace(oldChar, newChar)：替换字符，返回新串
• String.valueOf(任意类型)：将基本类型 / 对象转为字符串

3.2 StringBuffer 类（可变字符串）

1. 本质

• 可修改、可追加、可插入，不产生新对象
• 适合频繁拼接、修改字符串

1. StringBuffer 构造方法

• StringBuffer()：空串，默认容量 16
• StringBuffer(int length)：指定容量
• StringBuffer(String s)：初始内容为 s，容量 = s.length () + 16

1. StringBuffer 常用方法

• length()：实际字符长度
• capacity()：返回当前总容量
• setLength(int newLength)：设置字符串长度
• charAt(int index)：取指定位置字符
• setCharAt(int index, char ch)：修改指定位置字符
• append(任意类型)：追加内容到末尾（最常用）
• insert(int offset, 任意类型)：在指定位置插入内容
• delete(int start, int end)：删除 [start,end) 字符
• reverse()：字符串反转
• toString()：转为 String 类型

3.3 字符串修改（核心区别）

1. String 修改（不可变）

• 不能直接改原串，只能通过方法返回新串
• 常用修改方法：
  • concat()：拼接
  • replace()：替换
  • substring()：截取
  • toLowerCase() / toUpperCase()：大小写转换

2. StringBuffer 修改（可变）

• 直接修改原对象，不生成新串
• 常用修改方法：
  • append()
  • insert()
  • delete()
  • setCharAt()
  • reverse()

3.4 字符串比较（必考）

1. ==

• 比较两个对象的内存地址是否相同
• 不比较内容

1. equals()

• 比较字符串内容是否相同（区分大小写）
• 标准的字符串内容比较

1. equalsIgnoreCase()

• 比较内容，忽略大小写

1. compareTo(String anotherString)

• 按 ** 字典序（Unicode）** 比较大小
• 返回 0：相等
• 返回 负数：当前串 < 参数字符串
• 返回 正数：当前串 > 参数字符串

3.5 字符串类型转换（高频填空）

1. 基本类型 → 字符串

• String.valueOf(int/double/boolean/char...)

1. 字符串 → 基本类型

• Integer.parseInt(String s) → int
• Double.parseDouble(String s) → double

1. 字符串 ↔ 字符数组

• 字符串 → 字符数组：toCharArray()
• 字符数组 → 字符串：new String(char[])

1. 大小写转换

• toUpperCase()：全大写
• toLowerCase()：全小写

3.6 字符串 + 操作（连接）

1. + 用于字符串拼接
2. 任意类型 + 字符串 → 自动转为字符串
3. 底层原理：

• 编译器自动转为 StringBuffer.append() 拼接
• 最后调用 toString() 转回 String

3.7 String 与 StringBuffer 对比

• String：不可变；常量池；修改产生新对象；适合少量操作
• StringBuffer：可变；缓冲区；直接修改原对象；适合频繁拼接

3.8 细节总结

• String 不可变，StringBuffer 可变
• String 两种创建：直接赋值、new
• substring 左闭右开
• indexOf 找不到返回 -1
• 比较内容用 equals()，比较地址用 ==
• String 拼接底层用 StringBuffer.append()
• StringBuffer 扩容自动，支持 append/insert/delete/reverse
• 类型转换用 valueOf()、parseInt()、parseDouble()
• compareTo() 按字典序比较
• 所有 String 修改方法都返回新串

4 面向对象程序设计基础

4.1 面向对象基础

1. 核心概念

• 面向对象 OOP：以对象为基本单位，封装数据与方法，支持继承、多态。
• 面向过程 POP：以功能 / 函数为单位，数据与操作分离。
• 对象 = 状态（属性） + 行为（方法）
• 类：具有相同属性和行为的对象抽象。
• 对象：类的实例（instance）。

2. 四大核心特征（必考简答）

1. 封装：把属性和方法打包，隐藏实现，暴露接口。
2. 继承：子类复用父类代码，扩展功能。
3. 多态：同一方法，不同对象表现不同行为。
4. 抽象：提取共性，忽略细节。

3. 消息（对象交互）

• 消息三要素：接收对象、方法名、参数。

4. 继承

• 单继承：Java 只支持单继承，一个子类只有一个父类。
• 根类：所有类默认继承 java.lang.Object。

5. 接口

• 只有常量 + 抽象方法，无实现。
• 一个类可以实现多个接口，弥补单继承不足。

4.2 类与对象

1. 类的结构

[修饰符] class 类名 {
    成员变量（属性）
    成员方法（行为）
    构造方法
}

2. 成员变量

• 实例变量：属于对象，每个对象独立。
• 类变量（static）：属于类，所有对象共享。
• 默认初始值：
  • 整型：0；浮点：0.0；char：\u0000；boolean：false；引用：null。

3. 成员方法

• 实例方法：可访问实例变量 + 类变量。
• 类方法（static）：只能访问类变量，不能用 this/super。

4. 方法参数传递

• 基本类型：值传递，方法内修改不影响原值。
• 引用类型：地址传递，方法内修改会影响原对象。

5. this 关键字（必考）

• 代表当前对象。
• 用途：
  1. 区分成员变量与局部变量重名。
  2. this(...) 调用本类其他构造方法（必须第一行）。

6. 构造方法（Constructor）

• 名字与类名完全相同，无返回值。
• 创建对象时自动调用，用于初始化。
• 支持重载。
• 若没写构造，系统默认提供无参构造。

7. 对象创建与生命周期

• 创建：类名 对象名 = new 构造方法();
• new：分配堆内存，调用构造，返回引用。
• 垃圾回收：无引用时由 GC 自动回收，可调用 System.gc()。
• finalize()：回收前自动调用。

8. 对象比较

• ==：比较地址。
• equals()：比较内容（Object 默认比较地址，常重写）。

9. 匿名对象

• new 类名().方法(); 只使用一次，无引用名。

10. 方法重载（Overload）

• 同名不同参：参数个数 / 类型 / 顺序不同。
• 返回值不能区分重载。

4.3 继承与多态

1. 继承语法

class 子类 extends 父类 { }

2. 访问权限（必考表格）

修饰符	本类	同包	子类	任意
private	✔	✘	✘	✘
default	✔	✔	✘	✘
protected	✔	✔	✔	✘
public	✔	✔	✔	✔

3. 方法重写（Override）

• 子类重写父类方法：同名、同参、同返回值。
• 规则：
  1. 权限不能更严格。
  2. 不能抛出更多异常。

4. super 关键字（必考）

• 代表父类对象。
• 用途：
  1. 访问父类被隐藏的变量：super.变量
  2. 调用父类被重写的方法：super.方法()
  3. 调用父类构造：super(...)（必须第一行）

5. 多态

• 静态多态：编译期确定 → 方法重载。
• 动态多态：运行期确定 → 方法重写。
• 表现：父类引用指向子类对象。

6. final 关键字（三大作用）

1. final 变量：常量，赋值后不可改。
2. final 方法：不能被重写。
3. final 类：不能被继承。

7. 抽象类（abstract）

• abstract class 类名
• 包含抽象方法：只有声明，无方法体。
• 不能实例化，必须被继承。
• 子类必须重写所有抽象方法。

8. 内部类（Inner Class）

• 类中定义的类。
• 可直接访问外部类成员，常用于事件监听。

4.4 接口

1. 接口定义

[public] interface 接口名 {
    常量（public static final）
    抽象方法（public abstract）
}

2. 接口特点

• 所有方法默认 public abstract。
• 所有常量默认 public static final。
• 支持多继承：interface D extends A,B,C。
• 类实现接口：class 类 implements 接口1,接口2。
• 必须实现所有抽象方法。

3. 接口 vs 抽象类（必考）

• 接口：多实现，无构造，全抽象。
• 抽象类：单继承，有构造，可含实现方法。

4.5 包（package）

1. 包作用

• 管理类文件，避免类名冲突。
• 控制访问权限。

2. 定义包

package 包名; // 必须第一行

3. 导入包

import 包名.*;
import 包名.类名;

4. 常用包（必考）

• java.lang：核心类（String、Object、System），自动导入。
• java.util：工具类（集合、日期）。
• java.io：输入输出。
• java.net：网络。
• java.awt / javax.swing：图形界面。
• java.applet：小程序。

4.6 知识点总结

• 面向对象三大特征：封装、继承、多态。
• Java 只支持单继承，用接口实现多实现。
• 所有类默认继承 Object。
• 成员变量：对象独有；static：类共享。
• 构造方法：同名、无返回值、创建时自动调用。
• this：当前对象；super：父类对象。
• 重载：同名不同参；重写：同名同参同返回。
• 多态：父类引用指向子类对象，运行时调用子类方法。
• private 最小权限，public 最大权限。
• final：常量、不能重写、不能继承。
• 抽象类不能实例化，必须被继承。
• 接口只有常量和抽象方法，支持多继承。
• 类实现接口必须重写所有方法。
• == 比地址；equals() 比内容。
• 包用于分类管理类，java.lang 自动导入