从变量声明到Spring Boot开发,本教学系统讲解Java语言核心语法、面向对象思想、集合框架、异常处理、I/O流、多线程编程、JDBC数据库连接及Web开发基础,结合真实代码示例与学习路径规划,助你高效入门程序员职业道路。
开始学习Java语言的市场地位与学习价值分析
Java作为全球最流行的编程语言之一,长期稳居TIOBE指数前列,其“一次编译,到处运行”的跨平台特性源于Java虚拟机(JVM)的抽象层设计。对于新手而言,Java入门教学不仅教会语法,更培养严谨的工程思维与模块化开发习惯。
Java由Sun Microsystems于1995年正式发布,最初定位为嵌入式设备语言,后因互联网兴起转向Web开发。2006年Sun开源JDK,2009年Oracle收购Sun后持续推动语言演进。截至2024年,Java SE 21已支持虚拟线程(Virtual Threads)、结构化并发(Structured Concurrency)等现代特性。
从Java 8引入Lambda表达式与Stream API,到Java 14的switch表达式与记录类(Record),再到Java 17的密封类(Sealed Classes)与模式匹配增强,Java持续融合函数式编程与现代语言特性,在保持向后兼容的同时提升开发效率。
据Stack Overflow 2023年开发者调查,Java在“最常用编程语言”中排名第4(占比21.2%),在“希望继续使用”榜单中排名第3(71.5%),印证其在企业级开发中的长期生命力。
| 层级 | 技术代表 | 用途说明 |
|---|---|---|
| 基础语法 | 变量、数据类型、运算符 | 构建程序逻辑的原子单元 |
| 面向对象 | 类、继承、多态、接口 | 模拟现实世界的建模能力 |
| 集合框架 | ArrayList、HashMap、TreeSet | 高效组织与操作数据集合 |
| 异常处理 | try-catch-finally、自定义异常 | 保障程序健壮性与可恢复性 |
| 输入输出 | FileInputStream、BufferedReader | 实现文件与网络数据交互 |
| 多线程 | Thread、Runnable、ExecutorService | 提升程序并发性能的关键技术 |
| 数据库连接 | JDBC、MyBatis、Spring Data JPA | 操作关系型数据库的标准接口 |
| Web开发 | Servlet、JSP、Spring MVC | 构建动态网站与RESTful服务 |
掌握上述模块后,可进一步学习微服务架构(Spring Cloud)、分布式中间件(Kafka、ZooKeeper)、容器化部署(Docker、Kubernetes)等进阶内容,形成完整技术能力闭环。
从零配置Java开发所需工具链
JAVA_HOME = C:\Program Files\Java\jdk-17 PATH += %JAVA_HOME%\bin
java -version 与 javac -version,确认输出版本号一致。pom.xml,添加依赖如 <artifactId>spring-boot-starter-web</artifactId>。变量、数据类型与基础控制结构详解
| 类型 | 字节数 | 默认值 | 示例 |
|---|---|---|---|
| byte | 1 | 0 | byte b = 10; |
| short | 2 | 0 | short s = 100; |
| int | 4 | 0 | int age = 25; |
| long | 8 | 0L | long distance = 123456789L; |
| float | 4 | 0.0f | float price = 9.9f; |
| double | 8 | 0.0d | double pi = 3.1415926; |
| char | 2 | '\u0000' | char grade = 'A'; |
| boolean | 1位 | false | boolean isVip = true; |
| String | 对象 | null | String name = "Java"; |
注意:基本类型(如int)与包装类型(如Integer)在自动装箱/拆箱时存在性能差异,高并发场景需谨慎使用。
if-else用于条件判断,支持嵌套与多分支:
int score = 85;
if (score >= 90) {
System.out.println("优秀");
} else if (score >= 80) {
System.out.println("良好");
} else if (score >= 60) {
System.out.println("及格");
} else {
System.out.println("不及格");
}
从Java 14起,switch支持表达式形式:
int day = 3;
String dayName = switch (day) {
case 1 -> "Monday";
case 2 -> "Tuesday";
case 3 -> "Wednesday";
default -> "Unknown";
};
switch语句支持int、char、String及枚举类型,注意避免fall-through(需显式break):
String fruit = "apple";
switch (fruit) {
case "apple":
System.out.println("苹果");
break;
case "banana":
System.out.println("香蕉");
break;
default:
System.out.println("未知水果");
}
for循环适用于已知次数的遍历:
for (int i = 1; i <= 5; i++) {
System.out.println("第" + i + "次循环");
}
while循环适用于未知次数的循环:
int count = 0;
while (count < 3) {
System.out.println("尝试第" + (++count) + "次");
}
增强for循环(for-each)简化集合遍历:
String[] names = {"张三", "李四", "王五"};
for (String name : names) {
System.out.println(name);
}
方法是完成特定功能的代码块,定义格式为:修饰符 返回类型 方法名(参数列表) { ... }
public static int add(int a, int b) {
return a + b;
}
方法重载要求方法名相同、参数列表不同(个数、类型或顺序),与返回类型无关:
public static int add(int a, int b) { ... }
public static double add(double a, double b) { ... }
public static int add(int a, int b, int c) { ... }
重载机制提升了API的灵活性,如System.out.println()支持多种参数类型。
封装、继承、多态的核心思想与实践
封装将数据(属性)与操作(方法)绑定为类,并隐藏内部实现细节,通过访问修饰符控制可见性:
public class Person {
private String name; // 私有属性
private int age;
public String getName() { // 公有方法访问
return name;
}
public void setName(String name) {
this.name = name;
}
}
封装优势:增强数据安全性、提高模块独立性、便于维护与扩展。
继承实现代码复用,子类继承父类的非私有成员,使用extends关键字:
public class Student extends Person {
private String studentId;
public void study() {
System.out.println(name + "正在学习");
}
}
Java仅支持单继承,但可通过接口实现多实现(implements)。
多态指同一操作作用于不同对象时可产生不同效果,需满足:继承关系、方法重写、父类引用指向子类对象。
public class Animal {
public void makeSound() {
System.out.println("动物叫声");
}
}
public class Dog extends Animal {
@Override
public void makeSound() {
System.out.println("汪汪");
}
}
// 多态调用
Animal animal = new Dog();
animal.makeSound(); // 输出:汪汪
多态是实现“开闭原则”(对扩展开放,对修改关闭)的关键机制。
| 对比项 | 抽象类 | 接口 |
|---|---|---|
| 关键字 | abstract class |
interface |
| 构造方法 | 可以有 | 不能有 |
| 成员变量 | 可有各种类型 | 默认public static final |
| 方法实现 | 可有抽象与具体方法 | Java 8前仅抽象;之后支持default/static |
| 继承限制 | 单继承 | 多实现 |
| 使用场景 | 模板方法设计模式 | 行为规范定义 |
示例:定义Runnable接口实现线程任务:
public class MyTask implements Runnable {
@Override
public void run() {
System.out.println("任务执行中...");
}
}
单例模式确保一个类仅有一个实例,提供全局访问点:
public class Singleton {
private static final Singleton INSTANCE = new Singleton();
private Singleton() {}
public static Singleton getInstance() {
return INSTANCE;
}
}
饿汉式实现线程安全,适用于实例创建开销小的场景。
工厂模式将对象创建与使用分离,降低耦合度:
public interface Fruit {
void eat();
}
public class Apple implements Fruit {
public void eat() { System.out.println("吃苹果"); }
}
public class Banana implements Fruit {
public void eat() { System.out.println("吃香蕉"); }
}
public class FruitFactory {
public static Fruit getFruit(String type) {
if ("apple".equals(type)) return new Apple();
if ("banana".equals(type)) return new Banana();
return null;
}
}
客户端仅需调用FruitFactory.getFruit("apple"),无需关心具体实现类。
List、Set、Map体系结构与使用场景
| 顶层接口 | 常用实现类 | 特性 | 适用场景 |
|---|---|---|---|
| Collection | ArrayList, LinkedList, HashSet | 单列集合 | 存储单一对象序列 |
| Map | HashMap, TreeMap, LinkedHashMap | 键值对映射 | 通过键快速查找值 |
| List | ArrayList(数组), LinkedList(链表) | 有序可重复 | 频繁随机访问用ArrayList;频繁插入删除用LinkedList |
| Set | HashSet(哈希), TreeSet(红黑树) | 无序不可重复 | 去重操作;TreeSet支持排序 |
ArrayList底层为动态数组,查询快(O(1))、增删慢(O(n)):
Listnames = new ArrayList<>(); names.add("张三"); names.add("李四"); System.out.println(names.get(0)); // 输出:张三 names.remove(1); // 删除李四
初始容量为10,扩容为1.5倍;线程不安全,高并发需用Collections.synchronizedList()或CopyOnWriteArrayList。
LinkedList底层为双向链表,增删快(O(1))、查询慢(O(n)):
Listqueue = new LinkedList<>(); queue.addFirst("任务1"); queue.addLast("任务2"); System.out.println(queue.removeFirst()); // 输出:任务1
可作为栈(push/pop)、队列(offer/poll)使用,适合频繁插入删除的场景。
HashMap基于哈希表,键值对无序,允许null键(仅一个)与null值:
Mapscores = new HashMap<>(); scores.put("语文", 95); scores.put("数学", 92); System.out.println(scores.get("语文")); // 输出:95
默认负载因子0.75,容量为2的幂;Java 8后链表长度≥8且容量≥64时转为红黑树。
TreeMap基于红黑树,键有序(自然排序或自定义比较器):
Mapmap = new TreeMap<>(); map.put("banana", "香蕉"); map.put("apple", "苹果"); for (String key : map.keySet()) { System.out.println(key + " → " + map.get(key)); } // 输出顺序:apple → 苹果, banana → 香蕉
适用于需要排序遍历的场景,如字典、排行榜。
LinkedHashMap在HashMap基础上维护插入顺序或访问顺序:
Mapcache = new LinkedHashMap<>(16, 0.75f, true) { protected boolean removeEldestEntry(Map.Entry eldest) { return size() > 3; // LRU缓存:仅保留最近3项 } };
常用于实现LRU缓存,通过构造参数控制顺序模式。
传统遍历方式:
Listlist = Arrays.asList("A", "B", "C"); for (String s : list) { System.out.println(s); }
Java 8引入Stream API实现函数式操作:
Listfiltered = list.stream() .filter(s -> s.startsWith("A")) .map(String::toUpperCase) .collect(Collectors.toList());
支持并行流(.parallelStream())提升大数据集处理效率,但需注意线程安全问题。
try-catch-finally与自定义异常设计
| 层级 | 说明 | 示例 |
|---|---|---|
| Throwable | 所有异常的父类 | |
| ├─ Error | JVM内部错误(不可处理) | StackOverflowError, OutOfMemoryError |
| └─ Exception | 程序可处理异常 | |
| ├─ RuntimeException | 运行时异常(非受检) | NullPointerException, IllegalArgumentException |
| └─ 其他Exception | 受检异常(编译器强制处理) | IOException, SQLException |
public static int divide(int a, int b) {
try {
return a / b; // 可能抛出ArithmeticException
} catch (ArithmeticException e) {
System.out.println("除数为0");
return 0;
} finally {
System.out.println("finally块总是执行");
}
}
System.out.println(divide(10, 0));
// 输出:
// 除数为0
// finally块总是执行
// 0
注意:finally中若含return语句会覆盖try/catch的返回值,应避免此类写法。
public class InvalidAgeException extends Exception {
public InvalidAgeException(String message) {
super(message);
}
}
public class PersonValidator {
public static void validateAge(int age) throws InvalidAgeException {
if (age < 0 || age > 150) {
throw new InvalidAgeException("年龄无效:" + age);
}
}
}
使用场景:业务规则校验、数据校验等需明确错误类型的场景。
logger.error("错误", e))。try (BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {
String line = br.readLine();
} catch (IOException e) {
e.printStackTrace();
} // 自动关闭资源
try-with-resources要求资源实现AutoCloseable接口,Java 7+支持。
字节流、字符流与NIO文件操作
| 分类维度 | 类型 | 代表类 |
|---|---|---|
| 方向 | 输入流 | InputStream, Reader |
| 输出流 | OutputStream, Writer | |
| 处理单元 | 字节流 | FileInputStream, BufferedOutputStream |
| 字符流 | FileReader, BufferedWriter |
字节流处理二进制数据(如图片、视频),字符流处理文本数据(自动处理编码转换)。
try (FileInputStream fis = new FileInputStream("input.bin");
FileOutputStream fos = new FileOutputStream("output.bin")) {
byte[] buffer = new byte[1024];
int len;
while ((len = fis.read(buffer)) != -1) {
fos.write(buffer, 0, len);
}
} catch (IOException e) {
e.printStackTrace();
}
try (BufferedReader br = new BufferedReader(new FileReader("input.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"))) {
String line;
while ((line = br.readLine()) != null) {
bw.write(line);
bw.newLine();
}
} catch (IOException e) {
e.printStackTrace();
}
注意:字符流需指定编码(如new InputStreamReader(fis, StandardCharsets.UTF_8))避免中文乱码。
Path source = Paths.get("input.txt");
Path target = Paths.get("output.txt");
// 复制文件
Files.copy(source, target, StandardCopyOption.REPLACE_EXISTING);
// 读取全部文本
List lines = Files.readAllLines(source, StandardCharsets.UTF_8);
// 写入文本
Files.write(target, "Hello Java NIO".getBytes(StandardCharsets.UTF_8));
NIO.2提供更简洁的API,支持异步文件通道(AsynchronousFileChannel)。
public class User implements Serializable {
private static final long serialVersionUID = 1L;
private String name;
private int age;
// 构造器、getter/setter省略
}
// 序列化
try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("user.ser"))) {
oos.writeObject(new User("张三", 25));
}
// 反序列化
try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("user.ser"))) {
User user = (User) ois.readObject();
System.out.println(user.getName()); // 输出:张三
}
注意:静态字段不参与序列化;transient修饰的字段跳过序列化。
线程创建、同步机制与并发工具类
public class MyThread extends Thread {
public void run() {
System.out.println("线程执行中:" + Thread.currentThread().getName());
}
}
// 启动线程
new MyThread().start();
缺点:单继承限制;无法返回结果。
public class MyTask implements Runnable {
public void run() {
System.out.println("任务执行:" + Thread.currentThread().getName());
}
}
// 启动线程
new Thread(new MyTask()).start();
推荐方式:避免单继承限制,支持多线程共享资源。
public class MyCallable implements Callable{ public String call() throws Exception { return "任务完成"; } } // 启动线程 FutureTask future = new FutureTask<>(new MyCallable()); new Thread(future).start(); System.out.println(future.get()); // 阻塞等待结果
支持返回值与异常抛出,配合Future使用。
public class Counter {
private int count = 0;
public synchronized void increment() { // 同步方法
count++;
}
public void safeIncrement() {
synchronized (this) { // 同步代码块
count++;
}
}
}
隐式锁:自动获取与释放;适用于简单同步场景。
public class Counter {
private int count = 0;
private final Lock lock = new ReentrantLock();
public void increment() {
lock.lock();
try {
count++;
} finally {
lock.unlock(); // 必须在finally中释放
}
}
}
显式锁:支持公平锁、可中断锁、超时锁;性能更优但需手动管理。
ExecutorService pool = Executors.newFixedThreadPool(3);
for (int i = 0; i < 5; i++) {
pool.execute(() -> System.out.println("任务:" + Thread.currentThread().getName()));
}
pool.shutdown(); // 关闭线程池
线程池避免频繁创建销毁线程开销,推荐使用ThreadPoolExecutor自定义参数。
public class AtomicCounter {
private final AtomicInteger count = new AtomicInteger(0);
public void increment() {
count.incrementAndGet(); // 原子操作
}
public int getCount() {
return count.get();
}
}
基于CAS(Compare-And-Swap)实现,无锁竞争,适用于高并发计数场景。
public class ProducerConsumer {
private final Queue queue = new LinkedList<>();
private final Object lock = new Object();
public void produce() throws InterruptedException {
synchronized (lock) {
while (queue.size() == 10) { // 队列满时等待
lock.wait();
}
queue.offer(1);
lock.notifyAll(); // 通知消费者
}
}
public void consume() throws InterruptedException {
synchronized (lock) {
while (queue.isEmpty()) { // 队列空时等待
lock.wait();
}
queue.poll();
lock.notifyAll(); // 通知生产者
}
}
}
注意:wait/notify必须在同步块中调用;推荐使用BlockingQueue简化生产者-消费者模式。
JDBC核心API与连接池配置
Class.forName("com.mysql.cj.jdbc.Driver");Connection conn = DriverManager.getConnection(url, user, pwd);PreparedStatement pstmt = conn.prepareStatement(sql);ResultSet rs = pstmt.executeQuery();while (rs.next()) { ... }public class JdbcDemo {
private static final String URL = "jdbc:mysql://localhost:3306/test";
private static final String USER = "root";
private static final String PASSWORD = "123456";
public static void main(String[] args) {
String sql = "SELECT * FROM users WHERE age > ?";
try (Connection conn = DriverManager.getConnection(URL, USER, PASSWORD);
PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setInt(1, 18);
try (ResultSet rs = pstmt.executeQuery()) {
while (rs.next()) {
System.out.println(rs.getInt("id") + " " + rs.getString("name"));
}
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}
使用try-with-resources自动关闭资源;PreparedStatement防止SQL注入。
// Maven依赖
<dependency>
<groupId>com.mchange</groupId>
<artifactId>c3p0</artifactId>
<version>0.9.5.5</version>
</dependency>
// 配置示例
ComboPooledDataSource ds = new ComboPooledDataSource();
ds.setJdbcUrl("jdbc:mysql://localhost:3306/test");
ds.setUser("root");
ds.setPassword("123456");
ds.setMinPoolSize(5);
ds.setMaxPoolSize(20);
// Maven依赖
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.2.21</version>
</dependency>
// 配置示例
DruidDataSource ds = new DruidDataSource();
ds.setUrl("jdbc:mysql://localhost:3306/test");
ds.setUsername("root");
ds.setPassword("123456");
ds.setInitialSize(5);
ds.setMaxActive(20);
ds.setMinIdle(5);
Druid提供监控页面(/druid),支持SQL防火墙、慢SQL统计等企业级功能。
Servlet、JSP与MVC模式实践
public class HelloServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
resp.setContentType("text/html;charset=UTF-8");
PrintWriter out = resp.getWriter();
out.println("Hello Java Web!
");
}
}
web.xml配置:<servlet> <servlet-name>hello</servlet-name> <servlet-class>HelloServlet</servlet-class> </servlet>
| 对象名 | 类型 | 作用域 |
|---|---|---|
| request | HttpServletRequest | request |
| response | HttpServletResponse | page |
| session | HttpSession | session |
| application | ServletContext | application |
| out | JspWriter | page |
JSP中可直接使用:<%= request.getParameter("name") %>
Model:数据与业务逻辑,如User实体类、UserService业务类。
View:展示层,JSP页面负责渲染HTML,使用JSTL/EL表达式显示数据。
Controller:请求分发,如UserServlet处理用户相关请求:
public class UserServlet extends HttpServlet {
private UserService userService = new UserService();
protected void doGet(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
String action = req.getParameter("action");
if ("list".equals(action)) {
List users = userService.getAllUsers();
req.setAttribute("users", users);
req.getRequestDispatcher("/WEB-INF/userList.jsp").forward(req, resp);
}
}
}
从零基础到企业级开发的进阶路线图
掌握变量、数据类型、控制结构、数组、方法、面向对象基础、常用API(String、Math、Date)。
配套练习:控制台版学生管理系统、简易计算器。
深入集合框架、异常处理、I/O流、多线程、泛型、反射、注解。
配套练习:文件加密工具、多线程下载器、注解模拟Spring IOC。
学习JDBC、MySQL、JSP/Servlet、HTML/CSS/JavaScript基础。
配套练习:图书管理系统(JDBC版)、简易论坛(Servlet版)。
掌握Spring Core/AOP/Transaction、MyBatis、Spring MVC、Maven、Git。
配套练习:基于MVC模式的电商后台系统。
学习Spring Boot、Spring Cloud、Redis、RabbitMQ、Docker、K8s。
配套练习:基于Spring Boot的RESTful API服务。
新手最常问的10个问题
A:两者无实质关系!Java是静态强类型语言,由Sun Microsystems开发;JavaScript是动态弱类型脚本语言,由Netscape开发。名称相似是因1995年JavaScript发布时借用了Java的热度,但两者语法、用途、运行环境均不同。
A:核心语法完全一致,差异仅在于路径分隔符(Windows用\,Unix用/)、环境变量配置。建议使用跨平台IDE(如IntelliJ IDEA),避免环境问题。
A:非必需!Java设计初衷就是降低编程门槛,无需前置C语言基础。但C语言有助于理解内存与指针概念,对深入理解Java的底层机制有帮助。
A:检查以下三点:
public static void main(String[] args)。A:在类中按Alt+Insert(Windows/Linux)或Cmd+N(Mac),选择“Getter and Setter”即可自动生成。推荐安装Lombok插件,用注解省略样板代码。
A:JVM(Java Virtual Machine)是Java程序运行的虚拟机;JRE(Java Runtime Environment)包含JVM和核心类库,用于运行Java程序;JDK(Java Development Kit)包含JRE及编译器、调试器等开发工具。
A:面向过程关注执行步骤(如:1.买菜 2.洗菜 3.炒菜);面向对象关注对象与行为(如:厨师对象有“炒菜”方法)。面向对象更易维护、复用,适合大型项目。
A:ArrayList:随机访问快(O(1)),适合查询频繁的场景;LinkedList:插入删除快(O(1)),适合频繁修改的场景。默认优先选ArrayList。
A:单例模式确保一个类仅有一个实例。常见实现:
A:三遍学习法:
坚持“学-练-复盘”循环,加入技术社区(如CSDN、GitHub)参与开源项目。