java基础知识讲座
本页面为java基础知识讲座的首页,旨在为所有希望系统掌握Java编程语言的开发者提供一份权威、全面、结构清晰的学习指南。无论您是初学者,还是已有一定经验但希望夯实基础的开发者,本页面都将为您提供扎实的知识体系与丰富的实战示例。
在当今软件开发领域,Java语言凭借其跨平台性、健壮性、丰富的生态系统以及强大的社区支持,长期稳居主流编程语言前列。从企业级后端应用、Android移动开发,到大数据处理、微服务架构,Java的身影无处不在。掌握Java基础知识,不仅是进入大型企业开发团队的敲门砖,更是构建高可用、可维护系统架构的基石。
本页面内容严格遵循知识递进逻辑,从最基础的语法结构出发,逐步深入到面向对象核心思想、集合与泛型机制、并发编程模型、JVM运行机制及主流设计模式,每个模块均辅以真实代码示例、常见误区解析与最佳实践建议。我们特别注重java基础知识讲座的系统性与实用性,避免碎片化学习带来的知识断层。
此外,页面还设置了「网友们还关心」板块,精选开发者高频搜索问题,如“Java与Python在企业级开发中的对比”、“JVM垃圾回收机制如何影响应用性能”、“Spring框架与原生Java开发的关系”等,帮助您拓展技术视野,理解Java在真实技术栈中的定位与价值。
通过本页面的学习,您将能够:
- 掌握Java语言核心语法与编程范式
- 深入理解面向对象三大特性(封装、继承、多态)的底层实现逻辑
- 熟练使用集合框架与泛型机制处理复杂数据结构
- 编写安全、高效的多线程程序,避免常见并发陷阱
- 理解JVM内存模型与执行机制,具备基础调优能力
- 识别并应用23种经典设计模式,提升代码可维护性
我们坚信,扎实的java基础知识讲座是成为高级工程师的必经之路。本页面所有内容均经过多次教学实践验证,确保知识准确、示例可运行、讲解透彻。请随时通过导航栏跳转至各核心模块,开启您的Java进阶之旅。
语法基础:构建程序的砖石
Java语法是所有Java程序的基石,其设计强调清晰性、安全性与可读性。掌握语法不仅是记住关键字与规则,更要理解其背后的设计哲学。以下从数据类型、运算符、控制流、数组与字符串五大核心维度展开讲解。
1. 数据类型与变量
Java为强类型语言,所有变量必须先声明后使用。数据类型分为基本类型(primitive types)与引用类型(reference types):
| 类型 | 字节数 | 默认值 | 示例 |
|---|---|---|---|
| byte | 1 | 0 | byte b = 127; |
| short | 2 | 0 | short s = 32767; |
| int | 4 | 0 | int i = 2_147_483_647; |
| long | 8 | 0L | long l = 9_223_372_036_854_775_807L; |
| float | 4 | 0.0f | float f = 3.14159f; |
| double | 8 | 0.0d | double d = 3.141592653589793; |
| char | 2 | '\u0000' | char c = '中'; // Unicode字符 |
| boolean | 1 bit | false | boolean flag = true; |
⚠️ 注意:整数字面量默认为int类型,浮点字面量默认为double类型。声明long或float变量时必须加后缀L或f,否则编译报错。
从Java 7起支持数字分隔符(下划线),提升可读性,如:int billion = 1_000_000_000;。但分隔符不能出现在首尾、小数点附近或类型前缀后(如0x_123非法)。
2. 运算符与表达式
Java支持算术、关系、逻辑、位、三元、赋值等运算符。特别注意:
- 位运算符
<<(左移)等价于乘以2的幂,>>(右移)等价于除以2的幂(带符号),>>>为无符号右移。 - 逻辑运算符
&&与||支持短路求值,可避免空指针异常:
if (obj != null && obj.isValid()) { ... } - 自增自减运算符
i++与++i在表达式中行为不同:
int a = 5; int b = a++; // b=5, a=6
int c = 5; int d = ++c; // d=6, c=6
3. 控制流语句
包括if-else、switch、for、while、do-while及跳转语句break/continue。Java 7起switch支持字符串,Java 12起支持表达式形式(yield关键字):
String fruit = "apple";
String result = switch (fruit) {
case "apple" -> "red";
case "banana" -> "yellow";
default -> "unknown";
};
⚠️ 注意:传统switch需显式使用break防止fall-through;表达式形式自动断开,无需break。
4. 数组与字符串
数组是固定长度的同类型元素序列,声明方式:int[] arr = new int[5];或int[] arr = {1,2,3};。字符串是String类的实例,具有不可变性(immutable),每次修改均生成新对象:
String s = "Hello";
s += " World"; // 实际创建两个String对象
高频陷阱:循环中拼接字符串应使用StringBuilder,避免性能劣化。正确做法:StringBuilder sb = new StringBuilder(); sb.append("Hello").append(" World");
5. 方法与重载
方法定义格式:访问修饰符 静态/实例 修饰符 返回类型 方法名(参数列表) { ... }。方法重载要求:方法名相同、参数列表不同(类型/个数/顺序)、返回类型可同可异。注意:仅返回类型不同不构成重载!
int add(int a, int b) { return a + b; }
double add(double a, double b) { return a + b; }
int add(int a, int b, int c) { return a + b + c; }
调用时根据实参类型与个数自动匹配,若存在模糊匹配(如add(1, 2L)可能匹配add(int,int)或add(double,double)),编译报错。
面向对象编程:Java的灵魂
Java是纯面向对象语言(除基本类型外),其核心思想——封装、继承、多态——构成了软件工程中高内聚、低耦合设计的基础。本节深入解析三大特性及抽象类与接口的区别,破除常见误解。
1. 封装:隐藏实现,保护数据
通过private字段与public方法(getter/setter)实现数据隐藏。示例:Person类:
public class Person {
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) {
if (age >= 0 && age <= 150) this.age = age;
else throw new IllegalArgumentException("年龄无效");
}
}
封装的价值在于:① 防止非法状态;② 允许内部实现变更而不影响外部调用;③ 控制访问粒度(如只读字段可不提供setter)。
2. 继承:复用与扩展
使用extends关键字实现单继承,子类继承父类非private成员。注意:final类不可被继承(如String),private方法不可被重写(仅可见性提升可被子类定义同名方法,但非重写)。
构造器调用链:子类构造器首行隐式或显式调用super(),确保父类初始化。若父类无无参构造器,子类必须显式调用super(...),否则编译失败。
3. 多态:运行时绑定
多态的三个前提:① 继承/实现;② 方法重写;③ 父类引用指向子类对象。示例:
class Animal { void sound() { System.out.println("Animal sound"); } }
class Dog extends Animal { @Override void sound() { System.out.println("Woof"); } }
Animal a = new Dog(); // 向上转型
a.sound(); // 输出"Woof"——动态绑定
⚠️ 重要:多态仅作用于实例方法!字段、静态方法、构造器均不体现多态,编译时已确定绑定对象。
4. 抽象类 vs 接口
| 特性 | 抽象类 | 接口(Java 8+) |
|---|---|---|
| 关键字 | abstract class | interface |
| 构造器 | 可有(供子类调用) | 不可有 |
| 成员变量 | 可有任意修饰符 | 默认public static final |
| 方法实现 | 可有抽象/具体方法 | 可有默认方法(default)、静态方法 |
| 继承/实现 | 单继承 | 多实现 |
| 设计定位 | is-a关系,模板式复用 | 行为契约,能力声明 |
Java 8起接口支持默认方法与静态方法,极大增强了其表达能力,但抽象类仍不可替代——它能持有状态(实例字段),而接口仅能定义行为规范。
5. 关键字辨析
final:类不可继承;方法不可重写;变量不可变(基本类型值不变,引用类型地址不变)static:属于类而非对象,静态方法内不可使用this或supersuper:指向父类实例,用于调用父类构造器或覆盖方法this:指向当前实例,用于区分字段与局部变量、调用本类其他构造器
常见误区:认为static方法可被重写(实际为隐藏),或认为final方法不能被子类定义同名方法(实际可定义,但非重写)。
集合框架:高效处理数据的核心
Java集合框架(Java Collections Framework)是开发中使用最频繁的API之一,提供统一的接口与高效实现。掌握其体系结构与关键实现类,是编写高性能Java程序的必备技能。
1. 集合体系概览
所有集合的根接口,提供迭代器支持
单值集合:List(有序可重复)、Set(无序不重复)
键值对集合:HashMap、TreeMap、LinkedHashMap
2. List详解
| 实现类 | 底层结构 | 线程安全 | 适用场景 |
|---|---|---|---|
| ArrayList | 动态数组 | 否 | 频繁查询、尾部插入 |
| LinkedList | 双向链表 | 否 | 频繁插入/删除(非随机访问) |
| Vector | 动态数组 | 是(方法同步) | 旧版线程安全需求 |
⚠️ 注意:ArrayList扩容策略为1.5倍(原容量+原容量>>1),LinkedList插入时需更新前后节点引用。
3. Set详解
Set通过equals()与hashCode()保证元素唯一性:
HashSet:基于HashMap实现,无序,O(1)增删查LinkedHashSet:维护插入顺序,性能略低于HashSetTreeSet:基于TreeMap,元素排序(自然顺序或比较器),O(log n)
重写hashCode()时必须同时重写equals(),否则Set无法正确去重!示例:
class Person {
String name; int age;
@Override public int hashCode() {
return Objects.hash(name, age);
}
@Override public boolean equals(Object o) {
return o instanceof Person p && name.equals(p.name) && age == p.age;
}
}
4. Map核心技巧
Map的常用操作包括:put/get/containsKey/containsValue/remove。Java 8新增实用方法:
getOrDefault(key, defaultValue):若不存在则返回默认值putIfAbsent(key, value):仅当key不存在时插入computeIfAbsent(key, mappingFunction):懒加载计算值computeIfPresent(key, remappingFunction):仅当key存在时更新
示例:统计词频
Map freq = new HashMap<>();
for (String word : words) {
freq.merge(word, 1, Integer::sum); // 等价于computeIfAbsent+put
}
5. 泛型:类型安全的基石
泛型仅存在于编译期(类型擦除),运行时无泛型信息。关键规则:
- 不能实例化泛型数组:
new T[10]非法(但new Object[10]可转为T[]) - 泛型类型参数不能为基本类型(需用包装类)
- 通配符
?表示未知类型:?、? extends Number(上界)、? super Integer(下界) - PECS原则(Producer Extends, Consumer Super):频繁读取用
extends,频繁写入用super
示例:安全合并集合
void copyAll(Collection extends Number> src, Collection dest) {
for (Number n : src) dest.add(n); // 安全添加
多线程编程:并发的挑战与艺术
Java的多线程支持是其企业级应用的核心优势之一。从早期的Thread与synchronized,到现代的java.util.concurrent(JUC)包,并发编程工具日益成熟。本节聚焦实战中的关键概念与避坑指南。
1. 线程状态与创建
线程六种状态:NEW→RUNNABLE→BLOCKED→WAITING/TIMED_WAITING→TERMINATED。创建方式:
- 继承
Thread类(不推荐,单继承限制) - 实现
Runnable接口(推荐,解耦任务与线程) - 实现
Callable接口(支持返回值与异常) - 使用线程池(最佳实践,避免频繁创建销毁)
线程池创建示例(Java 19+推荐方式):
ExecutorService pool = Executors.newFixedThreadPool(4);
Future future = pool.submit(() -> {
return calculate();
});
Integer result = future.get(); // 阻塞等待结果
2. synchronized机制
synchronized可修饰方法或代码块,确保同一时刻仅一个线程执行临界区。三种锁粒度:
- 实例方法锁:锁当前对象实例(
this) - 静态方法锁:锁Class对象(
MyClass.class) - 代码块锁:显式指定锁对象(推荐,减少锁竞争)
⚠️ 注意:锁对象必须是共享的!若每个线程用不同对象锁,同步失效:
// 错误示例:每个线程创建新锁对象
synchronized(new Object()) { ... }
// 正确示例:共享锁对象
private final Object lock = new Object();
3. JUC核心工具
| 工具 | 用途 | 关键方法 |
|---|---|---|
| CountDownLatch | 等待多个线程完成 | await(), countDown() |
| CyclicBarrier | 线程间同步点 | await(), reset() |
| Semaphore | 控制并发访问数 | acquire(), release() |
| ConcurrentHashMap | 线程安全Map | putIfAbsent(), compute() |
| AtomicInteger | 原子整数 | getAndIncrement(), compareAndSet() |
示例:用Semaphore实现连接池
Semaphore sem = new Semaphore(3); // 3个连接
sem.acquire(); // 获取连接
try {
useConnection();
} finally {
sem.release(); // 归还连接
}
4. 死锁排查与避免
死锁四条件:互斥、占有且等待、不可抢占、循环等待。避免策略:
- 锁排序:按固定顺序获取锁(如先锁A再锁B)
- 超时等待:
lock.tryLock(1, TimeUnit.SECONDS) - 使用
java.util.concurrent的高层抽象(如ExecutorService)
排查工具:jstack可输出线程栈,定位死锁线程(显示"Found one Java-level deadlock")。
5. volatile关键字
volatile保证可见性与有序性(禁止指令重排),但不保证原子性。适用场景:
- 状态标志(如
volatile boolean running = true;) - 双重检查锁中的单例初始化
⚠️ 注意:volatile不能替代synchronized处理复合操作(如i++仍需同步)!
JVM原理:理解程序的运行环境
深入理解JVM是Java工程师进阶的必经之路。掌握内存模型、类加载机制与垃圾回收策略,能显著提升问题排查与性能调优能力。
1. 内存区域划分
| 区域 | 作用 | 溢出异常 |
|---|---|---|
| 程序计数器 | 当前线程执行字节码行号指示器 | 无 |
| Java虚拟机栈 | 方法调用栈帧(局部变量表、操作数栈) | StackOverflowError |
| 本地方法栈 | Native方法调用 | StackOverflowError |
| Java堆 | 对象实例存储区(GC主战场) | OutOfMemoryError |
| 方法区/元空间 | 类信息、常量、静态变量(JDK8后移至Metaspace) | OutOfMemoryError |
关键点:堆是线程共享区,栈是线程私有区;元空间使用本地内存,不再受JVM内存限制。
2. 类加载机制
类加载过程五阶段:
- 加载:通过类名获取二进制字节流,转为方法区运行时数据结构
- 验证:确保字节流符合JVM规范(文件格式、元数据、字节码、符号引用)
- 准备:分配内存并设置默认初始值(static字段→0/null)
- 解析:将常量池符号引用转为直接引用
- 初始化:执行类构造器
<clinit>()(静态变量赋值+静态代码块)
双亲委派模型:类加载器优先委托父加载器,避免重复加载。自定义类加载器需重写loadClass(),但应保持委派逻辑。
3. 垃圾回收机制
判断对象存活:可达性分析(从GC Roots出发的引用链)。GC Roots包括:
- 虚拟机栈中引用的对象
- 静态属性引用的对象
- 常量引用的对象
- 本地方法栈中引用的对象
常见GC算法:
| 算法 | 原理 | 优缺点 |
|---|---|---|
| 标记-清除 | 标记存活对象,清除未标记 | 效率低,产生碎片 |
| 复制算法 | 内存分两区,存活对象拷贝至另一区 | 高效,内存浪费 |
| 标记-整理 | 标记后移动存活对象,清除边界外 | 无碎片,移动成本高 |
现代JVM(如HotSpot)采用分代收集:新生代(复制算法)+老年代(标记-整理/标记-清除)。
4. 常见调优参数
-Xms2g -Xmx2g # 堆初始/最大值2GB
-Xss1m # 线程栈大小1MB
-XX:MetaspaceSize=256m
-XX:+UseG1GC # 使用G1垃圾回收器(推荐)
G1回收器将堆划分为Region,实现停顿时间可控(-XX:MaxGCPauseMillis=200),适合大内存应用。
设计模式:可复用的解决方案
设计模式是前人经验的结晶,帮助开发者解决常见问题。本节精选3种高频模式,结合java基础知识讲座场景说明其应用。
1. 单例模式(Singleton)
确保一个类仅有一个实例,并提供全局访问点。线程安全实现:
public class Singleton {
private Singleton() {}
private static class Holder {
private static final Singleton INSTANCE = new Singleton();
}
public static Singleton getInstance() {
return Holder.INSTANCE;
}
}
利用类加载机制保证线程安全,无同步开销,推荐用于配置管理、日志器等。
2. 工厂模式(Factory)
定义创建对象的接口,但由子类决定实例化哪个类。示例:数据库连接工厂
interface DBConnection { void connect(); }
class MySQLConnection implements DBConnection { ... }
class OracleConnection implements DBConnection { ... }
class ConnectionFactory {
public static DBConnection createConnection(String type) {
return switch (type) {
case "mysql" -> new MySQLConnection();
case "oracle" -> new OracleConnection();
default -> throw new IllegalArgumentException("未知DB类型");
};
}
}
解耦对象创建与使用,便于扩展新类型(新增类即可)。Spring的BeanFactory即基于此模式。
3. 代理模式(Proxy)
为其他对象提供代理以控制访问。JDK动态代理实现:
interface Service { void execute(); }
class RealService implements Service { ... }
class LoggingProxy implements InvocationHandler {
private final Service target;
LoggingProxy(Service target) { this.target = target; }
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("调用" + method.getName());
return method.invoke(target, args);
}
}
Service proxy = (Service) Proxy.newProxyInstance(
Service.class.getClassLoader(),
new Class[]{Service.class},
new LoggingProxy(new RealService())
);
Spring AOP底层即基于动态代理,实现日志、事务、权限校验等横切关注点。
4. 设计原则速查
- 单一职责:一个类只负责一个功能领域
- 开闭原则:对扩展开放,对修改关闭
- 里氏替换:子类可替换父类而不影响程序正确性
- 依赖倒置:高层模块不依赖低层模块,均依赖抽象
- 接口隔离:客户端不应依赖不需要的接口