Java作为全球最流行的编程语言之一,自1995年Sun公司发布以来,已走过近三十年发展之路。它以“一次编写,到处运行”的跨平台特性,成为企业级应用开发的首选语言。从大型分布式系统到移动应用(Android),从云计算平台到物联网设备,Java无处不在。对于零基础学习者而言,掌握Java不仅意味着获得一项高薪技能,更是打开计算机科学大门的金钥匙。
学习Java的关键在于理解其设计哲学——面向对象、强类型、健壮性、安全性、平台无关性、多线程支持、丰富的标准库。这些特性决定了Java的编程范式:强调结构清晰、模块化、可维护性。与Python的简洁、C++的底层控制不同,Java在开发效率与运行性能之间取得了良好平衡,特别适合构建大型、复杂、高并发的系统。
我们常听到“Java是静态强类型语言”,这意味着变量类型在编译期就已确定,编译器会进行严格的类型检查,避免运行时类型错误。例如,若定义String name = "张三",后续代码中无法将name赋值为整数123,否则编译不通过。这种机制虽在初期显得繁琐,却极大提升了大型项目的稳定性和可维护性。
另一个重要概念是“JVM(Java虚拟机)”。Java源代码(.java)经编译器生成字节码(.class),再由JVM解释或编译为机器码执行。不同操作系统(Windows、macOS、Linux)只需安装对应版本的JVM,即可运行同一份字节码——这正是“Write Once, Run Anywhere”的技术基础。JVM还内置了自动内存管理(垃圾回收GC)、安全沙箱、JIT即时编译等高级特性,让开发者更专注于业务逻辑。
在就业市场方面,Java开发者长期位居需求榜首。据2024年招聘平台数据显示,Java相关岗位占比超28%,远超其他语言。从传统银行核心系统、电信计费平台,到互联网巨头的微服务架构、阿里双11交易系统、京东订单中台,Java是支撑高并发、高可用系统的中坚力量。对于初学者而言,掌握Java意味着进入一个成熟、稳定、生态完善的开发者社区,可获得丰富的学习资源、开源项目与企业实践机会。
学习建议:每日坚持编码实践,勿死记语法;多写小型项目(如学生管理系统、图书借阅系统);善用Stack Overflow、GitHub、官方文档;加入技术社区交流,避免闭门造车。
搭建开发环境是编程学习的第一步,也是最容易因细节疏漏导致卡壳的环节。许多初学者在安装JDK时混淆JDK与JRE,或未正确配置环境变量PATH,造成“javac不是内部或外部命令”等错误。本节将分步详解,确保一次成功。
JDK是Java开发的核心工具包,包含编译器(javac)、解释器(java)、调试工具(jdb)、标准类库源码与API文档。JRE(Java Runtime Environment)仅包含运行时环境(JVM+类库),用于运行已编译的Java程序。开发者必须安装JDK。
推荐使用LTS(长期支持)版本:目前主流为JDK 8(兼容性最好)、JDK 11(现代特性全面)、JDK 17(最新LTS,2021年发布)。企业生产环境多采用JDK 8或11,学习者建议从JDK 11起步,兼顾新旧特性。
安装步骤:
C:\java\jdk-11)java -version javac -version
若显示版本号(如java version "11.0.22"),则安装成功;否则需检查PATH配置。
若命令行报错“'java' 不是内部或外部命令”,需手动配置:
JAVA_HOMEC:\java\jdk-11(替换为实际安装路径)%JAVA_HOME%\binjava -version推荐使用IntelliJ IDEA Community Edition(免费版),它对Java 8~17支持完善,内置代码补全、调试器、Maven集成、Git支持等,极大提升开发效率。Eclipse虽免费,但界面陈旧、启动慢、插件兼容性差,已逐步被IDEA取代。
IDEA配置要点:
public class Main {
public static void main(String[] args) {
System.out.println("欢迎开始从零学习Java!");
}
}
点击右上角绿色▶️运行按钮,控制台应输出欢迎语句。至此,开发环境配置完毕。
| 错误现象 | 可能原因 | 解决方案 |
|---|---|---|
| 'java' 不是内部或外部命令 | PATH未配置或路径错误 | 检查JAVA_HOME与PATH,确保指向bin目录 |
| Exception in thread "main" java.lang.UnsupportedClassVersionError | JDK版本与编译环境不匹配 | 统一JDK版本;在IDEA中:File → Project Structure → Project → Project SDK设为JDK 11 |
| 编译通过但运行报错:找不到或无法加载主类 | 类名与文件名不一致,或包路径错误 | 确保public class名 = 文件名(区分大小写);检查包声明(package com.example) |
语法是编程的“字母与单词”,掌握基础语法是写出可运行程序的前提。Java语法严谨,强调结构化与类型安全。本节将系统梳理核心语法点,结合实用示例,帮助零基础者建立清晰认知框架。
Java程序以类(class)为基本单位,每个源文件可包含多个类,但最多一个public类,且文件名必须与public类名一致。程序入口是main方法:
package com.example; // 包声明(可选)
import java.util.*; // 导入语句(可选)
public class Main { // 公共类定义
public static void main(String[] args) { // 主方法
// 程序执行起点
System.out.println("Hello, Java!");
}
}
注意:所有代码必须写在类内部;main方法签名固定为public static void main(String[] args),参数args用于接收命令行参数。
Java是强类型语言,变量必须先声明类型再使用。数据类型分为两大类:
| 类型 | 占用字节 | 取值范围 | 示例 |
|---|---|---|---|
| byte | 1 | -128 ~ 127 | byte b = 100; |
| short | 2 | -32,768 ~ 32,767 | short s = 30000; |
| int | 4 | -2³¹ ~ 2³¹-1 | int age = 25; |
| long | 8 | -2⁶³ ~ 2⁶³-1 | long population = 1400000000L; |
| float | 4 | 约±3.4×10³⁸(单精度) | float price = 99.9f; |
| double | 8 | 约±1.7×10³⁰⁸(双精度) | double pi = 3.141592653589793; |
| char | 2 | Unicode字符(0 ~ 65,535) | char gender = '男'; |
| boolean | 1位 | true / false | boolean isStudent = true; |
注意:整数字面量默认为int类型,long需加
掌握常见运算符是实现逻辑计算的基础:
+ - * / % ++ --== != > < >= <=(注意:比较字符串内容用equals())& && | || ! ^(短路与&&、短路或||避免冗余计算)= += -= *= /= %=条件 ? 表达式1 : 表达式2int score = 85;
String result = score >= 60 ? "及格" : "不及格";
System.out.println(result); // 输出:及格
通过条件与循环实现逻辑分支与重复操作:
int age = 18;
if (age >= 18) {
System.out.println("成年人");
} else if (age >= 14) {
System.out.println("青少年");
} else {
System.out.println("儿童");
}
String day = "Monday";
switch (day) {
case "Monday":
System.out.println("星期一");
break;
case "Friday":
System.out.println("星期五");
break;
default:
System.out.println("其他日期");
}
// for循环:打印1~10
for (int i = 1; i <= 10; i++) {
System.out.print(i + " ");
}
// while循环:累加1~100
int sum = 0, i = 1;
while (i <= 100) {
sum += i;
i++;
}
System.out.println("\n1~100和:" + sum);
提示:避免死循环(条件恒真);循环体内慎用continue/break;优先使用for-each遍历数组/集合。
数组是存储多个相同类型数据的连续内存空间。Java中数组是对象,长度固定。
// 方式1:声明 + 分配空间
int[] numbers = new int[5]; // 创建长度为5的整型数组
// 方式2:声明 + 直接赋值
String[] fruits = {"苹果", "香蕉", "橙子"};
// 方式3:动态初始化
int[] scores = new int[]{95, 87, 92};
// 访问第3个元素(索引2)
System.out.println(fruits[2]); // 输出:橙子
// 遍历数组
for (int i = 0; i < fruits.length; i++) {
System.out.println((i+1) + "号水果:" + fruits[i]);
}
// for-each遍历(推荐)
for (String fruit : fruits) {
System.out.println("水果:" + fruit);
}
注意:数组索引从0开始;访问越界(如fruits[3])会抛出ArrayIndexOutOfBoundsException。
面向对象(OOP)是Java的精髓,通过类(Class)与对象(Object)模拟现实世界,提升代码复用性、可维护性与扩展性。理解OOP三大特性——封装、继承、多态——是进阶开发的关键。
类是抽象模板,定义属性(字段)与行为(方法);对象是类的具体实例,占用实际内存空间。例如,“人类”是类,“张三”是对象。
public class Person {
// 属性(成员变量)
String name;
int age;
boolean isStudent;
// 行为(方法)
public void sayHello() {
System.out.println("大家好,我是" + name + ",今年" + age + "岁。");
}
public void study() {
if (isStudent) {
System.out.println(name + "正在认真学习Java!");
} else {
System.out.println(name + "准备开始学习Java!");
}
}
}
public class Main {
public static void main(String[] args) {
// 创建对象
Person zhangsan = new Person();
// 设置属性
zhangsan.name = "张三";
zhangsan.age = 20;
zhangsan.isStudent = true;
// 调用方法
zhangsan.sayHello(); // 输出:大家好,我是张三,今年20岁。
zhangsan.study(); // 输出:张三正在认真学习Java!
}
}
封装通过private修饰符限制属性访问,提供public的getter/setter方法控制数据读写,确保数据合法性与安全性。
public class Person {
private String name;
private int age;
// Getter方法(读取)
public String getName() {
return name;
}
// Setter方法(写入)
public void setName(String name) {
if (name == null || name.length() == 0) {
System.out.println("姓名不能为空!");
} else {
this.name = name;
}
}
public void setAge(int age) {
if (age < 0 || age > 150) {
System.out.println("年龄不合法!");
} else {
this.age = age;
}
}
public void showInfo() {
System.out.println("姓名:" + name + ",年龄:" + age);
}
}
建议:属性全设为private;每个属性提供getter/setter;使用this区分局部变量与成员变量。
构造方法(Constructor)在创建对象时自动调用,用于初始化成员变量。特点:方法名与类名相同;无返回类型(连void都不写);可重载。
public class Person {
private String name;
private int age;
// 无参构造方法
public Person() {}
// 有参构造方法
public Person(String name, int age) {
this.name = name;
this.age = age;
}
// 其他方法...
}
Person lisi = new Person("李四", 22); // 自动调用有参构造
通过extends关键字,子类继承父类的属性与方法(private成员不可见),实现“is-a”关系。Java只支持单继承。
public class Student extends Person {
private String school;
// 构造方法
public Student(String name, int age, String school) {
super(name, age); // 调用父类构造方法
this.school = school;
}
// 新增方法
public void doHomework() {
System.out.println(getName() + "在" + school + "写作业...");
}
// 重写父类方法(多态体现)
@Override
public void study() {
System.out.println(getName() + "正在教室专注学习Java!");
}
}
注意:子类构造方法必须调用父类构造方法(通过super());重写方法需保持签名一致;避免滥用继承,优先考虑组合。
多态指父类引用指向子类对象,调用方法时自动执行子类重写版本,实现“一个接口,多种实现”。前提:继承 + 重写 + 父类引用指向子类对象。
public class TestPolymorphism {
public static void main(String[] args) {
Person p1 = new Person("王五", 30); // 父类对象
Person p2 = new Student("赵六", 20, "清华大学"); // 父类引用指向子类对象
p1.study(); // 输出:王五准备开始学习Java!
p2.study(); // 输出:赵六正在教室专注学习Java!(调用重写后的方法)
}
}
核心价值:降低代码耦合度;提升扩展性(新增子类不影响调用方);是Spring等框架依赖注入的基础。
数组长度固定、操作不便,Java集合框架(java.util)提供动态数组、链表、哈希表等结构,极大提升数据处理效率。掌握常用集合是开发必备技能。
Collection
├── List(有序、可重复)
│ ├── ArrayList(动态数组,查询快)
│ ├── LinkedList(链表,增删快)
│ └── Vector(线程安全,已过时)
├── Set(无序、不可重复)
│ ├── HashSet(哈希表)
│ ├── LinkedHashSet(有序哈希)
│ └── TreeSet(有序,红黑树)
Map(键值对)
├── HashMap(常用)
├── LinkedHashMap(有序)
└── TreeMap(有序)
选择原则:频繁查询 → ArrayList;频繁增删 → LinkedList;去重 → HashSet;有序 → LinkedHashSet/TreeSet;键值存储 → HashMap。
ArrayList:基于动态数组实现,支持随机访问,查询快(O(1)),增删慢(需移动元素)。适用于读多写少场景。
import java.util.ArrayList;
import java.util.List;
public class ListDemo {
public static void main(String[] args) {
// 创建列表
List names = new ArrayList<>();
// 添加元素
names.add("张三");
names.add("李四");
names.add("王五");
// 获取大小
System.out.println("人数:" + names.size()); // 输出:3
// 访问元素(索引从0开始)
System.out.println("第一个:" + names.get(0)); // 输出:张三
// 遍历
for (int i = 0; i < names.size(); i++) {
System.out.println((i+1) + ":" + names.get(i));
}
// 删除元素
names.remove("李四");
System.out.println(names); // 输出:[张三, 王五]
}
}
LinkedList:基于双向链表,增删快(O(1)),查询慢(O(n))。适用于频繁插入删除场景(如队列、栈)。
import java.util.LinkedList;
public class StackDemo {
public static void main(String[] args) {
LinkedList stack = new LinkedList<>();
// 入栈(addLast)
stack.addLast("Java");
stack.addLast("Spring");
stack.addLast("MySQL");
// 出栈(removeLast)
System.out.println("出栈:" + stack.removeLast()); // 输出:MySQL
System.out.println("当前栈:" + stack); // 输出:[Java, Spring]
}
}
HashSet:基于HashMap实现,元素不可重复,无序。依赖元素的equals()与hashCode()方法。
import java.util.HashSet;
import java.util.Set;
public class SetDemo {
public static void main(String[] args) {
Set set = new HashSet<>();
set.add("Java");
set.add("Python");
set.add("Java"); // 重复,不会添加
set.add("C++");
System.out.println(set); // 输出:[Java, Python, C++](顺序可能不同)
System.out.println("大小:" + set.size()); // 输出:3
}
}
注意:自定义类放入HashSet前,必须重写equals()与hashCode(),否则无法正确去重!IDEA可右键 → Generate → hashCode() and equals()。
HashMap:存储键值对(Key-Value),键唯一,值可重复。查询效率高。
import java.util.HashMap;
import java.util.Map;
public class MapDemo {
public static void main(String[] args) {
Map scores = new HashMap<>();
// 添加键值对
scores.put("张三", 95);
scores.put("李四", 88);
scores.put("王五", 92);
// 获取值
System.out.println("张三成绩:" + scores.get("张三")); // 输出:95
// 遍历键
for (String name : scores.keySet()) {
System.out.println(name + ":" + scores.get(name));
}
// 遍历键值对(推荐)
for (Map.Entry entry : scores.entrySet()) {
System.out.println("学生:" + entry.getKey() + ",成绩:" + entry.getValue());
}
}
}
泛型(Generic)在编译期检查类型,避免运行时类型转换错误(ClassCastException)。集合类均支持泛型。
ArrayList names = new ArrayList<>(); // 只能存String
names.add("Java");
names.add(123); // 编译错误!不能存整数
建议:始终使用泛型声明集合;自定义类可定义泛型参数(如class Box)。
现代CPU多为多核架构,单线程无法充分利用资源。多线程允许程序并发执行多个任务,提升响应速度与吞吐量。Java内置线程支持,是开发高并发应用的基础。
类比:进程像一家公司,线程是员工;员工共享公司资源(内存),但各自执行任务(代码)。
方式1:继承Thread类
public class MyThread extends Thread {
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println("子线程执行:" + i);
try {
Thread.sleep(500); // 休眠500ms
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public class TestThread {
public static void main(String[] args) {
MyThread t = new MyThread();
t.start(); // 启动线程(调用run方法)
for (int i = 0; i < 5; i++) {
System.out.println("主线程执行:" + i);
try {
Thread.sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
方式2:实现Runnable接口(推荐)
public class MyRunnable implements Runnable {
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println("任务执行:" + i);
}
}
}
public class TestRunnable {
public static void main(String[] args) {
Thread t = new Thread(new MyRunnable());
t.start();
}
}
推荐原因:避免单继承局限;实现解耦;可共享资源(多个线程可传同一Runnable实例)。
多个线程共享数据时,可能因竞争导致数据不一致(如银行取款)。需通过同步机制确保原子性。
synchronized关键字:加锁,保证同一时刻只有一个线程执行临界区代码。
public class BankAccount {
private int balance = 1000; // 初始余额
// 同步方法
public synchronized void withdraw(int amount) {
if (balance >= amount) {
try {
Thread.sleep(100); // 模拟处理延迟
} catch (InterruptedException e) {
e.printStackTrace();
}
balance -= amount;
System.out.println("取款成功,余额:" + balance);
} else {
System.out.println("余额不足!");
}
}
}
public class TestWithdraw {
public static void main(String[] args) {
BankAccount account = new BankAccount();
Thread t1 = new Thread(() -> account.withdraw(800));
Thread t2 = new Thread(() -> account.withdraw(500));
t1.start();
t2.start();
}
}
注意:同步会降低性能,仅对共享数据操作加锁;避免死锁(锁嵌套);可使用Lock接口(如ReentrantLock)替代synchronized。
线程间协作的经典模式:生产者-消费者模型。
import java.util.LinkedList;
public class ProducerConsumer {
private static final int MAX_SIZE = 5;
private static final LinkedList queue = new LinkedList<>();
public static void main(String[] args) {
Thread producer = new Thread(() -> {
for (int i = 0; i < 10; i++) {
synchronized (queue) {
while (queue.size() == MAX_SIZE) {
try {
queue.wait(); // 队列满,等待消费者取走
} catch (InterruptedException e) {
e.printStackTrace();
}
}
queue.add(i);
System.out.println("生产:" + i + ",队列大小:" + queue.size());
queue.notifyAll(); // 唤醒消费者
}
}
});
Thread consumer = new Thread(() -> {
for (int i = 0; i < 10; i++) {
synchronized (queue) {
while (queue.isEmpty()) {
try {
queue.wait(); // 队列空,等待生产者生产
} catch (InterruptedException e) {
e.printStackTrace();
}
}
int item = queue.removeFirst();
System.out.println("消费:" + item + ",队列大小:" + queue.size());
queue.notifyAll(); // 唤醒生产者
}
}
});
producer.start();
consumer.start();
}
}
注意:wait/notify必须在synchronized块中调用;wait释放锁,notify不释放锁。
程序需与外部世界交互——读取配置、保存数据、处理用户输入。Java IO(Input/Output)流提供统一接口操作文件、网络、内存等数据源。
| 分类依据 | 类型 | 说明 |
|---|---|---|
| 方向 | 输入流 / 输出流 | 数据流向:从外到内 / 从内到外 |
| 单位 | 字节流 / 字符流 | 字节流(8位)处理二进制数据;字符流(16位)处理文本 |
| 功能 | 节点流 / 处理流 | 节点流直接连接数据源;处理流包装节点流增强功能 |
FileInputStream / FileOutputStream:读写二进制文件(图片、音频、视频)。
import java.io.*;
public class CopyImage {
public static void main(String[] args) {
try (
FileInputStream fis = new FileInputStream("source.jpg");
FileOutputStream fos = new FileOutputStream("copy.jpg")
) {
byte[] buffer = new byte[1024];
int bytesRead;
while ((bytesRead = fis.read(buffer)) != -1) {
fos.write(buffer, 0, bytesRead);
}
System.out.println("复制成功!");
} catch (IOException e) {
e.printStackTrace();
}
}
}
try-with-resources:自动关闭流,避免资源泄漏;必须实现AutoCloseable接口。
FileReader / FileWriter:处理文本文件(UTF-8编码)。
import java.io.*;
public class TextIO {
public static void main(String[] args) {
// 写入文本
try (FileWriter fw = new FileWriter("message.txt")) {
fw.write("你好,Java IO!\n");
fw.write("学习从零开始!");
} catch (IOException e) {
e.printStackTrace();
}
// 读取文本
try (FileReader fr = new FileReader("message.txt")) {
char[] buffer = new char[100];
int charsRead = fr.read(buffer);
System.out.println(new String(buffer, 0, charsRead));
} catch (IOException e) {
e.printStackTrace();
}
}
}
BufferedReader / BufferedWriter:缓冲流,提高读写效率,支持按行读取。
import java.io.*;
public class LineReader {
public static void main(String[] args) {
try (BufferedReader br = new BufferedReader(new FileReader("message.txt"))) {
String line;
while ((line = br.readLine()) != null) {
System.out.println("读取行:" + line);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
将对象转为字节流存储或传输(如保存游戏进度、网络传输对象)。需实现Serializable接口。
import java.io.*;
public class Person implements Serializable {
private static final long serialVersionUID = 1L;
private String name;
private int age;
// 构造方法、getter/setter...
@Override
public String toString() {
return "Person{name='" + name + "', age=" + age + "}";
}
}
public class SerializationDemo {
public static void main(String[] args) {
Person p = new Person("张三", 25);
// 序列化
try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.ser"))) {
oos.writeObject(p);
System.out.println("序列化完成!");
} catch (IOException e) {
e.printStackTrace();
}
// 反序列化
try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.ser"))) {
Person loaded = (Person) ois.readObject();
System.out.println("反序列化对象:" + loaded);
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}
}
注意:serialVersionUID用于版本校验;transient字段不参与序列化;反序列化时类结构需兼容。
互联网应用依赖网络通信。Java提供java.net包支持TCP/UDP协议,实现客户端-服务器通信模型。
TCP(传输控制协议)提供可靠、有序的数据流传输,适用于文件传输、网页浏览等场景。
import java.io.*;
import java.net.*;
public class TCPServer {
public static void main(String[] args) {
try {
ServerSocket serverSocket = new ServerSocket(8080); // 监听8080端口
System.out.println("服务器启动,等待客户端连接...");
Socket clientSocket = serverSocket.accept(); // 阻塞等待连接
System.out.println("客户端已连接:" + clientSocket.getInetAddress());
// 接收数据
BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
String message = in.readLine();
System.out.println("收到消息:" + message);
// 关闭资源
in.close();
clientSocket.close();
serverSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
import java.io.*;
import java.net.*;
public class TCPClient {
public static void main(String[] args) {
try {
Socket socket = new Socket("localhost", 8080); // 连接本地8080端口
System.out.println("已连接服务器");
// 发送数据
PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
out.println("你好,服务器!");
// 关闭资源
out.close();
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
关键点:服务器先启动监听;客户端主动连接;通信前需约定协议(如文本、JSON);生产环境需处理多客户端(线程池)。
UDP(用户数据报协议)不保证可靠性,但传输开销小、延迟低,适用于实时音视频、DNS查询等。
import java.net.*;
public class UDPClient {
public static void main(String[] args) throws Exception {
DatagramSocket socket = new DatagramSocket();
InetAddress address = InetAddress.getByName("localhost");
String message = "UDP测试数据";
byte[] data = message.getBytes();
DatagramPacket packet = new DatagramPacket(data, data.length, address, 9876);
socket.send(packet);
System.out.println("发送完成!");
socket.close();
}
}
import java.net.*;
public class UDPServer {
public static void main(String[] args) throws Exception {
DatagramSocket socket = new DatagramSocket(9876); // 监听9876端口
byte[] buffer = new byte[1024];
DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
socket.receive(packet); // 阻塞接收
String received = new String(packet.getData(), 0, packet.getLength());
System.out.println("收到UDP数据:" + received);
socket.close();
}
}
Java 11+提供HttpClient,简化HTTP请求处理。
import java.net.http.*;
import java.net.URI;
public class HttpClientDemo {
public static void main(String[] args) throws Exception {
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://jsonplaceholder.typicode.com/posts/1"))
.GET()
.build();
HttpResponse response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println("状态码:" + response.statusCode());
System.out.println("响应体:" + response.body());
}
}
应用场景:调用第三方API(天气、支付、地图);微服务间通信;爬取网页数据。
Web应用需将数据持久化到数据库。JDBC(Java Database Connectivity)是Java连接数据库的标准API,支持MySQL、Oracle、PostgreSQL等主流数据库。
import java.sql.*;
public class JDBCExample {
public static void main(String[] args) {
// 数据库配置
String url = "jdbc:mysql://localhost:3306/java_demo?useSSL=false&serverTimezone=UTC";
String user = "root";
String password = "your_password";
// SQL查询语句
String sql = "SELECT id, name, email FROM users";
try (
// 1. 建立连接(JDBC 4.0+自动加载驱动)
Connection conn = DriverManager.getConnection(url, user, password);
// 2. 创建PreparedStatement(防SQL注入)
PreparedStatement stmt = conn.prepareStatement(sql);
// 3. 执行查询
ResultSet rs = stmt.executeQuery()
) {
// 4. 处理结果
while (rs.next()) {
int id = rs.getInt("id");
String name = rs.getString("name");
String email = rs.getString("email");
System.out.println("用户:" + id + " - " + name + " (" + email + ")");
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}
注意:使用PreparedStatement防止SQL注入;连接URL需包含时区参数;生产环境使用连接池(如HikariCP)。
String insertSql = "INSERT INTO users (name, email) VALUES (?, ?)";
try (Connection conn = DriverManager.getConnection(url, user, password);
PreparedStatement stmt = conn.prepareStatement(insertSql)) {
stmt.setString(1, "赵六");
stmt.setString(2, "zhaoliu@example.com");
int rows = stmt.executeUpdate();
System.out.println("插入成功,影响行数:" + rows);
}
String updateSql = "UPDATE users SET email = ? WHERE id = ?";
try (Connection conn = DriverManager.getConnection(url, user, password);
PreparedStatement stmt = conn.prepareStatement(updateSql)) {
stmt.setString(1, "new_email@example.com");
stmt.setInt(2, 1);
int rows = stmt.executeUpdate();
System.out.println("更新成功,影响行数:" + rows);
}
事务(Transaction)是数据库操作的逻辑单元,满足ACID特性(原子性、一致性、隔离性、持久性)。JDBC通过setAutoCommit控制事务。
String transferSql = "UPDATE accounts SET balance = balance - ? WHERE id = ?";
String creditSql = "UPDATE accounts SET balance = balance + ? WHERE id = ?";
try (Connection conn = DriverManager.getConnection(url, user, password)) {
conn.setAutoCommit(false); // 关闭自动提交,开启事务
try (PreparedStatement debitStmt = conn.prepareStatement(transferSql);
PreparedStatement creditStmt = conn.prepareStatement(creditSql)) {
// 扣款
debitStmt.setDouble(1, 500.0);
debitStmt.setInt(2, 1);
debitStmt.executeUpdate();
// 加款(模拟异常前)
creditStmt.setDouble(1, 500.0);
creditStmt.setInt(2, 2);
creditStmt.executeUpdate();
conn.commit(); // 提交事务
System.out.println("转账成功!");
} catch (SQLException e) {
conn.rollback(); // 回滚事务
System.out.println("转账失败,已回滚:" + e.getMessage());
} finally {
conn.setAutoCommit(true); // 恢复自动提交
}
}
最佳实践:关键业务操作必须用事务;及时提交/回滚;避免长事务(锁表)。
频繁创建/关闭数据库连接开销大,连接池复用连接,提升性能。HikariCP是当前最快连接池。
import com.zaxxer.hikari.*;
public class HikariCPExample {
public static void main(String[] args) {
HikariConfig config = new HikariConfig();
config.setJdbcUrl("jdbc:mysql://localhost:3306/java_demo");
config.setUsername("root");
config.setPassword("your_password");
config.setMaximumPoolSize(10);
HikariDataSource dataSource = new HikariDataSource(config);
try (Connection conn = dataSource.getConnection()) {
// 使用连接执行操作
System.out.println("连接池获取连接成功!");
} catch (SQLException e) {
e.printStackTrace();
} finally {
dataSource.close();
}
}
}
Java Web开发从Servlet起步,逐步过渡到Spring MVC框架。理解底层原理有助于深入掌握现代框架。
Servlet是Java编写的服务器端程序,运行于Web容器(如Tomcat),处理客户端请求并生成响应。
import jakarta.servlet.*;
import jakarta.servlet.http.*;
import jakarta.servlet.annotation.*;
import java.io.*;
@WebServlet("/hello")
public class HelloServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
out.println("");
out.println("从零学习Java Web开发!
");
out.println("当前时间:" + new java.util.Date() + "
");
out.println("");
}
}
关键点:@WebServlet配置URL映射;doGet处理GET请求;request获取客户端数据;response设置响应内容。
import jakarta.servlet.*;
import jakarta.servlet.annotation.*;
import java.io.*;
@WebServlet("/login")
public class LoginServlet extends HttpServlet {
@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// 设置请求编码(防中文乱码)
request.setCharacterEncoding("UTF-8");
String username = request.getParameter("username");
String password = request.getParameter("password");
// 简单验证
if ("admin".equals(username) && "123456".equals(password)) {
// 重定向到成功页面
response.sendRedirect("/success.html");
} else {
// 转发到错误页面
request.setAttribute("errorMsg", "用户名或密码错误!");
request.getRequestDispatcher("/error.jsp").forward(request, response);
}
}
}
注意:doPost前需设置request编码;重定向(redirect)是客户端跳转;转发(forward)是服务器端跳转,URL不变。
HTTP无状态,需通过Session/Cookie维持用户登录状态。
HttpSession session = request.getSession();
session.setAttribute("currentUser", username);
session.setMaxInactiveInterval(1800); // 30分钟过期
HttpSession session = request.getSession(false); // 不创建新session
if (session != null) {
String user = (String) session.getAttribute("currentUser");
if (user == null) {
response.sendRedirect("/login.html");
return;
}
// 已登录,显示用户主页
}
Spring MVC是Spring生态的Web框架,基于MVC模式,简化开发。核心组件:DispatcherServlet(前端控制器)、Controller、Model、View。
@Controller
@RequestMapping("/user")
public class UserController {
@Autowired
private UserService userService;
@GetMapping("/list")
public String listUsers(Model model) {
List users = userService.getAllUsers();
model.addAttribute("users", users);
return "user-list"; // 对应WEB-INF/views/user-list.jsp
}
@PostMapping("/add")
public String addUser(@ModelAttribute User user) {
userService.saveUser(user);
return "redirect:/user/list";
}
}
优势:声明式注解;自动数据绑定;AOP支持;与Spring Boot无缝集成。
Java生态的核心是Spring家族,覆盖从单体应用到微服务的全场景开发。掌握主流框架是企业级开发的必备技能。
Spring Boot简化Spring应用初始化与部署,约定大于配置,内嵌Tomcat/Jetty,支持自动配置。
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
server:
port: 8080
spring:
datasource:
url: jdbc:mysql://localhost:3306/java_demo
username: root
password: your_password
jpa:
hibernate:
ddl-auto: update
show-sql: true
核心特性:Starter依赖简化配置;Actuator监控;Profile多环境支持;自动配置热加载。
JPA(Java Persistence API)是ORM规范,Spring Data JPA进一步简化CRUD操作。
public interface UserRepository extends JpaRepository {
// 自定义查询方法
List findByEmail(String email);
@Query("SELECT u FROM User u WHERE u.name LIKE %?1")
List findByNameContaining(String name);
}
@Service
public class UserService {
@Autowired
private UserRepository userRepository;
public List getAll() {
return userRepository.findAll();
}
public User save(User user) {
return userRepository.save(user);
}
}
提供认证(Authentication)、授权(Authorization)、加密、CSRF防护等安全功能。
@Configuration
@EnableWebSecurity
public class SecurityConfig {
@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
http
.authorizeHttpRequests(authz -> authz
.requestMatchers("/admin/**").hasRole("ADMIN")
.requestMatchers("/user/**").hasAnyRole("USER", "ADMIN")
.anyRequest().permitAll()
)
.formLogin(Customizer.withDefaults())
.csrf(Customizer.withDefaults());
return http.build();
}
@Bean
public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder();
}
}
Spring Cloud提供微服务解决方案,包括服务注册发现(Nacos/Eureka)、配置中心(Config)、API网关(Gateway)、熔断降级(Sentinel)。
@SpringBootApplication
@EnableDiscoveryClient // 注册到Nacos
public class ProviderApplication {
public static void main(String[] args) {
SpringApplication.run(ProviderApplication.class, args);
}
}
@RestController
@RequestMapping("/api")
public class DemoController {
@GetMapping("/hello")
public String hello() {
return "Hello from Provider!";
}
}
@SpringBootApplication
@EnableDiscoveryClient
public class ConsumerApplication {
@Bean
@LoadBalanced // 负载均衡
public RestTemplate restTemplate() {
return new RestTemplate();
}
}
@Service
public class ConsumerService {
@Autowired
private RestTemplate restTemplate;
public String callProvider() {
// 通过服务名调用
return restTemplate.getForObject("http://provider-service/api/hello", String.class);
}
}
| 领域 | 技术 | 用途 |
|---|---|---|
| 缓存 | Redis | 高性能缓存,支持字符串、哈希、列表等数据结构 |
| 消息队列 | RabbitMQ / Kafka | 异步解耦、流量削峰、分布式事务 |
| 搜索 | Elasticsearch | 全文检索、日志分析、实时数据处理 |
| 任务调度 | Quartz / XXL-JOB | 定时任务管理,支持分布式调度 |
| 容器化 | Docker / Kubernetes | 应用打包、部署、编排,实现DevOps自动化 |
掌握Java后,可选择多个技术方向发展。不同方向对技能要求略有差异,需结合兴趣与市场需求规划学习路径。
| 方向 | 核心技能 | 典型岗位 | 平均起薪(2024年) |
|---|---|---|---|
| 后端开发 | Spring Boot/Cloud、MySQL、Redis、消息队列 | Java开发工程师、后端工程师 | ¥12K-18K/月 |
| 微服务架构 | Docker/K8s、Nacos、Sentinel、分布式事务 | 微服务工程师、DevOps工程师 | ¥15K-22K/月 |
| 高并发系统 | JVM调优、多线程、性能压测(JMeter)、限流降级 | 高级Java工程师、系统架构师 | ¥20K-35K/月 |
| 大数据开发 | Hadoop/Spark、Flink、Hive、Kafka | 大数据开发工程师 | ¥16K-25K/月 |
| 云原生开发 | 云服务(AWS/Aliyun)、Serverless、Service Mesh | 云原生工程师、云平台开发 | ¥18K-30K/月 |
趋势观察:云原生与微服务需求增长快;高并发经验成高级岗位门槛;AI工程化(Java调用Python模型)成新方向。
建议:面试前模拟练习;准备项目亮点(技术选型、性能优化、故障处理);关注候选公司技术栈。
| 类型 | 资源名称 | 特点 |
|---|---|---|
| 官方文档 | Oracle Java Docs | 权威、最新、详细 |
| 书籍 | 《Effective Java》 | Java开发最佳实践,必读经典 |
| 书籍 | 《Spring Boot编程思想》 | 深入Spring Boot核心原理 |
| 在线课程 | 慕课网《Java工程师》 | 系统化学习,项目实战 |
| 技术社区 | Stack Overflow、掘金、知乎 | 解决实际问题,交流经验 |
| 开源项目 | Spring Framework、MyBatis | 学习架构设计与编码规范 |
A:初学者推荐JDK 11(兼顾新旧特性),企业生产环境多用JDK 8或11。JDK 17是最新LTS版本,支持更多现代语法(如记录类、模式匹配),适合新项目。若学习目标是就业,优先掌握JDK 8(兼容性最好),再逐步学习新特性。
A:IntelliJ IDEA有Community(免费)和Ultimate(付费)两个版本。Community版支持Java核心开发,足够学习使用;Ultimate版集成Web框架(如Spring)、数据库工具等,适合企业开发。学生可通过JetBrains Student Pack免费获得Ultimate许可证。
A:常见原因包括:①类名与文件名不一致;②包路径错误;③编译路径与运行路径不匹配。检查:①public class名 = 文件名;②package声明与目录结构一致;③在项目根目录执行javac -d . Main.java编译。
A:①接口只能有抽象方法(Java 8+支持default/static方法),抽象类可有具体方法;②接口支持多实现,抽象类只支持单继承;③接口字段默认public static final,抽象类可有普通字段;④接口用于定义行为规范,抽象类用于代码复用。实际开发中,优先使用接口(解耦性高)。
A:①PreparedStatement预编译SQL,防止SQL注入攻击;②减少SQL解析次数,提升性能;③支持动态参数,代码更清晰。例如:SELECT * FROM users WHERE name = ?,参数通过setString(1, "张三")设置。
A:①wait()释放锁,sleep()不释放锁;②wait()需在synchronized块中调用,sleep()可单独使用;③wait()可被notify()唤醒,sleep()时间到自动恢复;④wait()是Object方法,sleep()是Thread静态方法。典型场景:wait/notify用于生产者-消费者;sleep用于定时延迟。
A:默认是单例(singleton),即整个容器中只有一个实例。可通过@Scope("prototype")设置为多例(每次请求新建实例)。注意:单例Bean若包含状态(成员变量),需考虑线程安全问题。
A:分层优化方案:①应用层:缓存(Redis)、连接池;②数据库层:索引优化、读写分离、分库分表;③架构层:异步化(消息队列)、限流降级(Sentinel)。例如:热门数据走Redis缓存,写操作异步写入DB,冷数据归档。
A:①分布式系统复杂性(服务发现、配置管理、链路追踪);②数据一致性挑战(需分布式事务);③运维成本高(监控、日志、部署);④开发测试难度增加。建议:小团队初期用单体架构,业务复杂后再拆分微服务。
A:若每天投入3-4小时:①基础语法2-3个月;②核心框架(Spring Boot)1-2个月;③项目实战与面试准备1个月。总周期约4-6个月。关键在持续编码实践,而非仅看教程。
A:①开发个人项目(GitHub开源);②参加开源贡献;③实习(哪怕远程);④复现经典项目(如慕课网实战课)。面试时重点讲清:技术选型理由、遇到的问题与解决方案、性能优化点。
A:不会。两者定位不同:Python在数据分析、AI、脚本领域占优;Java在企业级后端、高并发系统、Android开发不可替代。实际开发中常混合使用(如Python做AI模型,Java做后端服务)。掌握Java是长期职业发展的坚实基础。