Java作为全球使用最广泛的编程语言之一,其核心语法构成了所有上层技术的根基。本模块覆盖Java SE核心内容,以“可运行、可调试、可复用”为原则,强调语义理解而非死记硬背。
核心内容包括:数据类型与变量、运算符与表达式、程序控制结构(if/switch/循环)、数组与字符串处理、方法定义与重载、类与对象初识、封装与访问控制等。
语法不是孤立的规则集合,而是表达逻辑的工具。例如:
int[] arr = new int[]{3, 1, 4, 1, 5};
for (int i = 0; i < arr.length; i++) {
if (arr[i] % 2 == 0) {
System.out.println("偶数:" + arr[i]);
}
}
上述代码看似简单,却隐含了:
① 数组创建的两种方式(静态/动态);
② for循环中下标访问的边界控制;
③ 条件判断中取模运算 `%` 的语义(判断奇偶性);
④ 字符串拼接中 `+` 的重载行为;
⑤ 控制台输出的字符编码与换行机制。
真正的工程师会在写这段代码前思考:数据来源是否可信?是否需校验空数组?是否考虑大数组性能?——这正是从语法走向工程的第一步。
完成 12 个典型练习:如“学生成绩等级划分”(多分支 if-else vs switch)、“九九乘法表”(嵌套循环+格式控制)、“数字加密器”(字符串处理+位运算)
掌握断点调试三步法:① 设置断点;② 单步执行(Step Over/Into);③ 观察变量变化。避免“print大法”,提升定位效率
遵循 Google Java Style Guide:缩进4空格、大括号独占行、类名大驼峰、方法/变量小驼峰、常量全大写下划线分隔
面向对象(OOP)是Java的魂。它不是语法糖,而是**建模世界的方式**。掌握封装、继承、多态三大特性,才能设计出高内聚、低耦合、可扩展的系统。
封装的核心是“数据 + 操作”的捆绑 + 访问控制。以用户类为例:
public class User {
private String name;
private int age;
public String getName() { return name; }
public void setName(String name) {
if (name == null || name.trim().isEmpty()) {
throw new IllegalArgumentException("姓名不能为空");
}
this.name = name.trim();
}
public int getAge() { return age; }
public void setAge(int age) {
if (age < 0 || age > 150) {
throw new IllegalArgumentException("年龄范围非法");
}
this.age = age;
}
}
此设计体现:
✓ 属性私有化 → 防止外部直接破坏数据完整性
✓ getter/setter 内校验 → 实现“输入即安全”
✓ 异常抛出 → 提示调用者错误原因,而非静默失败
继承解决代码复用问题,但滥用会导致脆弱基类(Fragile Base Class)问题。Java仅支持单继承,通过接口弥补局限。
✅ 正确用法:is-a 关系(如 Dog is-an Animal)
❌ 错误用法:仅为复用代码而继承(应优先用组合)
// 组合优于继承示例
public class Car {
private Engine engine; // 组合关系
public Car(Engine engine) {
this.engine = engine;
}
public void start() {
engine ignite(); // 委托执行
}
}
多态允许父类引用指向子类对象,运行时动态调用实际方法。关键在“编译看左边,运行看右边”。
Animal a = new Dog(); // 父类引用指向子类对象
a.sound(); // 实际调用 Dog.sound(),而非 Animal.sound()
典型应用场景:策略模式、工厂模式、Spring依赖注入——所有“可替换性”都依赖多态。
需求:设计一个动物叫声系统,支持猫、狗、鸟等不同叫声,未来可新增动物类型而不修改调用方。
实现:
abstract class Animal {
abstract void sound();
}
class Cat extends Animal {
void sound() {
System.out.println("喵~");
}
}
class Dog extends Animal {
void sound() {
System.out.println("汪汪!");
}
}
public class Main {
public static void main(String[] args) {
Animal[] animals = {new Cat(), new Dog(), new Cat()};
for (Animal a : animals) {
a.sound(); // 动态绑定,依次输出:喵~、汪汪!、喵~
}
}
}
优势:新增 `Bird` 类只需继承 `Animal` 并实现 `sound()`,调用方无需修改。
需求:实现多支付方式(微信/支付宝/银联),统一支付接口,支持后续扩展。
实现:
interface Payment {
void pay(double amount);
}
class WeChatPay implements Payment {
public void pay(double amount) {
System.out.println("微信支付:" + amount + "元");
}
}
class Alipay implements Payment {
public void pay(double amount) {
System.out.println("支付宝支付:" + amount + "元");
}
}
public class Checkout {
public static void checkout(Payment p, double amount) {
p.pay(amount); // 依赖抽象,不关心具体实现
}
}
此即策略模式雏形,为Spring事务管理、AOP切面编程埋下伏笔。
需求:计算圆形/矩形/三角形面积,未来支持正方形、椭圆等。
实现:
abstract class Shape {
abstract double area();
}
class Circle extends Shape {
double r;
Circle(double r) { this.r = r; }
double area() { return Math.PI * r * r; }
}
class Rectangle extends Shape {
double w, h;
Rectangle(double w, double h) { this.w = w; this.h = h; }
double area() { return w * h; }
}
// 使用时:Shape s = new Circle(3); double a = s.area();
注意:此处不可用 `instanceof` 判断类型后分支计算,那违背多态原则!
集合(Collections)是Java中使用最频繁的API之一。从 `ArrayList` 到 `HashMap`,从 `TreeSet` 到 `ConcurrentHashMap`,掌握其结构、性能与适用场景,是写出高效代码的前提。
二者区别本质是“数组 vs 链表”的性能权衡:
| 操作 | ArrayList | LinkedList |
|---|---|---|
| 随机访问(get(i)) | O(1) 快 | O(n) 慢 |
| 插入/删除(中间) | O(n) 需移动 | O(1) 仅改指针 |
| 内存开销 | 低(紧凑存储) | 高(每个节点含prev/next) |
✅ 选 ArrayList:数据量大 + 频繁读取 + 少修改
✅ 选 LinkedList:频繁头尾插入/删除(如队列/栈)
HashMap = 数组 + 链表/红黑树 + 哈希算法
【典型错误】用 `String` 以外的类型做 key 时未重写 `equals()` 和 `hashCode()` → 导致重复键无法识别!
1. List 增删改查
List list = new ArrayList<>();
list.add("Java"); // 添加
list.add(0, "Hello"); // 指定位置插入
list.set(1, "World"); // 替换
String s = list.get(0); // 获取
list.remove("Hello"); // 按值删除
2. Set 去重
Set set = new HashSet<>();
set.add(1); set.add(2); set.add(2); // 实际只有 {1,2}
3. Map 键值操作
Map map = new HashMap<>();
map.put("张三", 95);
Integer score = map.get("张三");
boolean exists = map.containsKey("李四");
三种遍历方式对比(以 List 为例):
// 方式1:传统 for(适合需索引)
for (int i = 0; i < list.size(); i++) { ... }
// 方式2:增强 for(简洁,但无法获取索引)
for (String s : list) { ... }
// 方式3:Iterator(支持遍历时安全删除)
Iterator it = list.iterator();
while (it.hasNext()) {
String s = it.next();
if (s.equals("Java")) it.remove();
}
⚠️ 注意:增强 for 本质是 Iterator 的语法糖,遍历中直接 `list.remove()` 会抛异常!
需求:对学生成绩去重并按分数降序排列
Set scores = new HashSet<>();
scores.add(85); scores.add(92); scores.add(85); // 去重后 {85,92}
List list = new ArrayList<>(scores);
list.sort(Collections.reverseOrder()); // 降序
// 或使用 Stream(JDK8+):
List sorted = scores.stream()
.sorted(Comparator.reverseOrder())
.collect(Collectors.toList());
多线程是Java的高阶内容,也是企业级应用的性能关键。理解线程生命周期、同步机制、线程池,才能写出高吞吐、低延迟的服务。
【最佳实践】优先用 `Runnable` 或 `Callable`,再交由 `Thread` 或线程池执行:
Runnable task = () -> {
System.out.println("任务执行中:" + Thread.currentThread().getName());
};
new Thread(task, "worker-1").start();
多线程竞争共享资源时,若未同步,会出现“脏读”“丢失更新”等。解决路径:
【反例】未同步的计数器:
int count = 0;
// 10个线程各执行1000次 count++,结果可能远小于10000!
【正解】加锁或使用原子类:
AtomicInteger count = new AtomicInteger();
count.incrementAndGet(); // 线程安全自增
线程池复用线程,降低资源消耗。常用类型:
【推荐】使用 `ThreadPoolExecutor` 自定义参数:
ExecutorService pool = new ThreadPoolExecutor(
4, 8, 60L, TimeUnit.SECONDS,
new LinkedBlockingQueue<>(100),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.CallerRunsPolicy()
);
IO(Input/Output)是程序与外部世界交互的通道。Java IO体系庞大,核心是“字节流 vs 字符流”“节点流 vs 处理流”的区分。
【注意】文本文件也可能是二进制格式(如UTF-8 BOM),优先用字符流读文本。
直接读写文件慢,因频繁系统调用。缓冲流(`BufferedInputStream`/`BufferedWriter`)通过内存缓冲区减少IO次数:
try (BufferedReader br = new BufferedReader(new FileReader("data.txt"))) {
String line;
while ((line = br.readLine()) != null) {
System.out.println(line);
}
} catch (IOException e) { e.printStackTrace(); }
`try-with-resources` 确保资源自动关闭(JDK7+),避免 `finally` 中手动关闭。
对象流(`ObjectInputStream`/`ObjectOutputStream`)可直接读写对象,要求类实现 `Serializable` 接口:
// 写入
try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("user.dat"))) {
User u = new User("张三", 25);
oos.writeObject(u);
}
// 读取
try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("user.dat"))) {
User u = (User) ois.readObject();
}
⚠️ 注意:`serialVersionUID` 建议显式声明,避免类结构变更导致反序列化失败。
需求:用缓冲流实现高效文件复制(支持任意类型)
public static void copyFile(String src, String dest) throws IOException {
try (InputStream in = new BufferedInputStream(new FileInputStream(src));
OutputStream out = new BufferedOutputStream(new FileOutputStream(dest))) {
byte[] buffer = new byte[8192];
int len;
while ((len = in.read(buffer)) != -1) {
out.write(buffer, 0, len);
}
}
}
缓冲区大小建议 8KB~64KB,平衡内存与效率。
需求:从URL读取网页内容(字节转字符处理编码)
URL url = new URL("https://www.xservx.com");
try (InputStream in = url.openStream();
BufferedReader br = new BufferedReader(
new InputStreamReader(in, StandardCharsets.UTF_8))) {
String line;
while ((line = br.readLine()) != null) {
System.out.println(line);
}
}
注意:网络IO需处理超时与异常,生产环境建议用 `HttpURLConnection` 或 `HttpClient`。
需求:日志文件追加写入(避免覆盖)
try (BufferedWriter bw = new BufferedWriter(
new FileWriter("app.log", true))) { // true=追加模式
bw.write(LocalDateTime.now() + " - 用户登录成功");
bw.newLine();
}
JDBC(Java Database Connectivity)是Java操作关系型数据库的标准API。掌握其核心流程:连接→执行→处理→关闭,是学习MyBatis/Spring Data JPA的前提。
【关键】使用 `PreparedStatement` 防SQL注入,避免字符串拼接:
String sql = "SELECT * FROM users WHERE name = ?";
PreparedStatement ps = conn.prepareStatement(sql);
ps.setString(1, "张三");
默认自动提交,需手动控制事务:
conn.setAutoCommit(false); // 关闭自动提交
try {
// 执行多个SQL
ps1.executeUpdate();
ps2.executeUpdate();
conn.commit(); // 全部成功才提交
} catch (SQLException e) {
conn.rollback(); // 失败回滚
throw e;
}
频繁创建/关闭连接开销大。连接池(如HikariCP、Druid)复用连接,提升性能:
【Druid配置示例】:
Properties props = new Properties();
props.setProperty("driverClassName", "com.mysql.cj.jdbc.Driver");
props.setProperty("url", "jdbc:mysql://localhost:3306/test");
props.setProperty("username", "root");
props.setProperty("password", "123456");
DataSource ds = DruidDataSourceFactory.createDataSource(props);
需求:根据用户名模糊查询用户列表
String sql = "SELECT id, name, email FROM users WHERE name LIKE ?";
try (Connection conn = ds.getConnection();
PreparedStatement ps = conn.prepareStatement(sql)) {
ps.setString(1, "%" + keyword + "%");
try (ResultSet rs = ps.executeQuery()) {
List list = new ArrayList<>();
while (rs.next()) {
User u = new User();
u.setId(rs.getInt("id"));
u.setName(rs.getString("name"));
u.setEmail(rs.getString("email"));
list.add(u);
}
return list;
}
}
需求:批量插入1000条用户数据
String sql = "INSERT INTO users(name, email) VALUES(?, ?)";
try (Connection conn = ds.getConnection();
PreparedStatement ps = conn.prepareStatement(sql)) {
conn.setAutoCommit(false);
for (int i = 0; i < 1000; i++) {
ps.setString(1, "用户" + i);
ps.setString(2, "user" + i + "@test.com");
ps.addBatch();
}
ps.executeBatch();
conn.commit();
}
需求:获取表结构信息(列名、类型、长度)
DatabaseMetaData meta = conn.getMetaData();
try (ResultSet rs = meta.getColumns(null, null, "users", null)) {
while (rs.next()) {
String colName = rs.getString("COLUMN_NAME");
String typeName = rs.getString("TYPE_NAME");
int size = rs.getInt("COLUMN_SIZE");
System.out.println(colName + " (" + typeName + ", " + size + ")");
}
}
MySQL是Java生态最主流的关系型数据库。掌握其设计、SQL优化、索引原理,才能构建高性能系统。
【反例】订单表含“客户姓名”,违反3NF(客户姓名依赖客户ID,而非订单ID)
MySQL默认索引为B+树(非哈希),特点:
【最佳实践】:
【反例】`SELECT * FROM orders WHERE create_time > '2023-01-01'`
【正例】`SELECT id, amount FROM orders WHERE create_time > '2023-01-01' ORDER BY create_time LIMIT 20`
Q:MyISAM和InnoDB区别?
A:MyISAM不支持事务/行锁/外键,适合读多写少;InnoDB支持ACID,行级锁,主推。
Q:如何解决慢查询?
A:① 用 `slow_query_log` 捕获;② `EXPLAIN` 分析;③ 加索引/改SQL/分表
Q:事务隔离级别?
A:READ UNCOMMITTED → READ COMMITTED(避免脏读)→ REPEATABLE READ(避免幻读,MySQL默认)→ SERIALIZABLE
Spring是Java生态的事实标准框架。理解IoC(控制反转)、DI(依赖注入)、AOP(面向切面),是进入Spring生态的入口。
传统方式:`new UserService()` → 耦合高、难测试
Spring方式:通过XML或注解声明,由容器创建并注入依赖:
// 定义Bean
@Service
public class UserService {
@Autowired
private UserRepository repo;
}
// 获取Bean(Spring Boot自动扫描)
@Autowired
private UserService userService;
AOP将横切逻辑(如日志、权限、事务)与业务逻辑分离:
@Aspect
@Component
public class LogAspect {
@Before("execution(* com.example.service.*.*(..))")
public void logBefore(JoinPoint jp) {
System.out.println("调用方法:" + jp.getSignature().getName());
}
}
运行时自动织入,无需修改业务代码。
【典型项目结构】:
src/main/java/
└─ com.example.demo/
├─ DemoApplication.java ← 启动类
├─ controller/
│ └─ UserController.java
├─ service/
│ └─ UserService.java
└─ repository/
└─ UserRepository.java
需求:提供用户查询的REST API
@RestController
@RequestMapping("/api/users")
public class UserController {
@Autowired
private UserService userService;
@GetMapping("/{id}")
public ResponseEntity getUser(@PathVariable Long id) {
User user = userService.findById(id);
return ResponseEntity.ok(user);
}
}
自动将对象转为JSON(Jackson),支持 `@RequestBody` / `@ResponseBody`。
需求:转账服务需保证原子性(扣款+加款)
@Service
public class TransferService {
@Autowired
private AccountDao dao;
@Transactional // Spring事务管理
public void transfer(String from, String to, double amount) {
dao.decrease(from, amount);
dao.increase(to, amount);
}
}
若异常抛出,自动回滚;默认 `rollbackFor=RuntimeException`。
自定义Starter三步:
其他项目只需引入 `your-starter`,即可自动启用功能。
理论需通过项目沉淀为能力。以下项目覆盖全栈流程:需求分析→设计→编码→测试→部署。
技术栈:JavaSE + MySQL + JDBC
功能:增删改查、导出Excel、登录校验
训练点:JDBC事务、MVC分层、异常处理
技术栈:Spring Boot + MyBatis + Thymeleaf
功能:用户注册/登录、图书管理、借阅记录、逾期提醒
训练点:Spring MVC、拦截器、文件上传
技术栈:Spring Boot + JPA + Vue
功能:文章CRUD、评论、标签分类、搜索
训练点:RESTful API设计、前后端分离、JWT认证
1. 打包:`mvn clean package` → 生成 `jar`
2. 运行:`java -jar app.jar`
3. 守护进程:`nohup java -jar app.jar > app.log 2>&1 &`
4. 容器化:Dockerfile 示例:
FROM openjdk:8-jre-alpine
COPY target/app.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "/app.jar"]
① 先掌握语法基础 → ② 做小项目(如控制台版通讯录)→ ③ 学框架(Spring)→ ④ 参与开源/实习
关键:每天写代码,拒绝“看懂=会做”
企业级后端主力语言,Android开发首选。Spring生态完善,微服务(Spring Cloud)、云原生(K8s)需求旺盛。据Stack Overflow 2023,Java连续10年Top 5语言。
能!建议路径:
第1月:变量、循环、方法
第2月:数组、集合、IO
第3月:OOP、JDBC
第4月:Spring Boot项目
每天2小时,坚持3个月可入门
书籍:《Java编程思想》《Effective Java》《Spring Boot实战》
网站:Oracle官方文档、Baeldung、Spring官方教程
视频:B站“Java零基础教程”(尚硅谷)