Java由James Gosling于1991年在Sun Microsystems(后被Oracle收购)主导开发,1995年正式发布。其设计初衷是“一次编写,到处运行”(Write Once, Run Anywhere),核心在于JVM(Java虚拟机)实现平台无关性。经过三十余年发展,Java已从桌面应用、企业级Web开发扩展至Android移动开发、大数据(Hadoop/Spark)、微服务(Spring Cloud)、云原生(Kubernetes)等主流技术领域。
根据TIOBE 2025年3月数据,Java长期稳居编程语言前三,企业级应用覆盖率超60%。其稳定性、安全性、生态成熟度使其成为金融、电信、政府系统首选语言。2024年Stack Overflow开发者调查中,Java仍位列第五,企业招聘需求持续旺盛。
Java技术体系分为三大核心模块:
本教程聚焦Java SE核心内容,为后续企业级开发打下坚实基础。掌握SE后,学习Spring Boot、MyBatis等框架将事半功倍。
配置Java开发环境需完成三个关键步骤:
JAVA_HOME环境变量,并将%JAVA_HOME%\bin加入PATH。java -version与javac -version,输出版本号即成功。常见问题:若提示'java'不是内部或外部命令,请检查环境变量配置是否正确,尤其注意路径中不能含中文或空格。
一个标准Java源文件包含以下组成部分:
package com.example;import java.util.Scanner;public static void main(String[] args)示例:HelloWorld.java
package com.example;
import java.util.Scanner;
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello, Java!");
Scanner scanner = new Scanner(System.in);
System.out.print("请输入姓名:");
String name = scanner.nextLine();
System.out.println("欢迎你," + name + "!");
}
}
Java数据类型分为两大类:
| 类型 | 关键字 | 字节数 | 取值范围 | 默认值 |
|---|---|---|---|---|
| 整数型 | byte、short、int、long | 1、2、4、8 | -128~127等 | 0 |
| 浮点型 | float、double | 4、8 | ±3.4E+38等 | 0.0 |
| 字符型 | char | 2 | 0~65535 | \u0000 |
| 布尔型 | boolean | 1位 | true/false | false |
| 引用类型 | 类、接口、数组 | 依赖JVM | 对象地址 | null |
注意:char类型使用单引号(如'A'),String是引用类型,使用双引号(如"Hello")。
常见运算符优先级(从高到低):
()++、--、!、~*、/、%、+、-<、>、<=、>===、!=&&、||=典型陷阱:整数除法自动截断小数部分,如7 / 2 = 3。需用7.0 / 2或强制类型转换(double)7 / 2。
以Student类为例:
public class Student {
// 私有属性(封装)
private String name;
private int age;
// 构造方法
public Student() {}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
// Getter/Setter(封装体现)
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 {
System.out.println("年龄非法!");
}
}
// 重写toString方法
@Override
public String toString() {
return "Student{name='" + name + "', age=" + age + "}";
}
}
使用示例:
Student s = new Student("张三", 20);
System.out.println(s); // 输出:Student{name='张三', age=20}
子类GraduateStudent继承Student:
public class GraduateStudent extends Student {
private String advisor; // 导师
public GraduateStudent(String name, int age, String advisor) {
super(name, age); // 调用父类构造器
this.advisor = advisor;
}
// 方法重写(多态基础)
@Override
public String toString() {
return "GraduateStudent{name='" + getName() + "', age=" + getAge() +
", advisor='" + advisor + "'}";
}
// 新增方法
public void doResearch() {
System.out.println(getName() + "正在做科研项目!");
}
}
注意:final类不能被继承,final方法不能被重写。
多态是面向对象的核心特性,体现为:
示例:接口多态
interface Animal {
void speak();
}
class Dog implements Animal {
public void speak() {
System.out.println("汪汪!");
}
}
class Cat implements Animal {
public void speak() {
System.out.println("喵喵!");
}
}
public class Demo {
public static void main(String[] args) {
Animal[] animals = {new Dog(), new Cat()};
for (Animal a : animals) {
a.speak(); // 动态绑定,输出不同内容
}
}
}
Java集合框架核心接口:
Collection
├── List(有序、可重复)
│ ├── ArrayList(数组结构,查询快)
│ ├── LinkedList(链表结构,增删快)
│ └── Vector(线程安全,已过时)
└── Set(无序、不可重复)
├── HashSet(哈希表)
├── LinkedHashSet(链表+哈希)
└── TreeSet(红黑树,排序)
Map(键值对)
├── HashMap(线程不安全)
├── LinkedHashMap(有序)
├── Hashtable(线程安全,已过时)
└── TreeMap(排序)
常见操作时间复杂度:
| 操作 | ArrayList | LinkedList |
|---|---|---|
| 访问元素(get) | O(1) | O(n) |
| 末尾添加(add) | 均摊O(1) | O(1) |
| 中间插入/删除 | O(n) | O(1) |
| 内存占用 | 连续内存,空间利用率高 | 每个节点额外存储指针 |
选择建议:
ArrayListLinkedListDeque(如ArrayDeque)HashMap基于哈希表实现,核心机制包括:
hashCode()计算键的哈希值示例:使用HashMap统计单词频率
MapwordCount = new HashMap<>(); String[] words = {"java", "java", "oop", "java", "oop"}; for (String w : words) { wordCount.put(w, wordCount.getOrDefault(w, 0) + 1); } System.out.println(wordCount); // {java=3, oop=2}
Java异常继承树:
Throwable
├── Error(严重错误,不可处理)
└── Exception
├── RuntimeException(运行时异常)
│ ├── NullPointerException
│ ├── ArrayIndexOutOfBoundsException
│ └── IllegalArgumentException
└── Checked Exception(受检异常)
├── IOException
├── SQLException
└── ClassNotFoundException
注意:RuntimeException及其子类无需显式捕获或声明,其他异常必须处理。
执行顺序:try → catch(异常发生时)→ finally(始终执行)
示例:文件读取异常处理
try {
BufferedReader br = new BufferedReader(new FileReader("data.txt"));
String line = br.readLine();
System.out.println(line);
} catch (FileNotFoundException e) {
System.err.println("文件未找到:" + e.getMessage());
} catch (IOException e) {
System.err.println("读取失败:" + e.getMessage());
} finally {
System.out.println("资源清理完成");
}
注意:finally块中避免使用return,会覆盖try中的返回值。
自定义异常示例:
public class AgeOutOfBoundsException extends Exception {
public AgeOutOfBoundsException(String message) {
super(message);
}
}
// 使用
if (age < 0 || age > 150) {
throw new AgeOutOfBoundsException("年龄超出有效范围");
}
异常处理最佳实践:
catch (Exception e)泛化捕获logger.error("错误详情", e)记录堆栈try-with-resources自动关闭资源按方向分:输入流(InputStream/Reader)、输出流(OutputStream/Writer)
按单位分:字节流(处理二进制)、字符流(处理文本)
常用流:
FileInputStream/FileOutputStream:文件字节流FileReader/FileWriter:文件字符流BufferedReader/BufferedWriter:缓冲字符流,支持按行读写ObjectInputStream/ObjectOutputStream:对象序列化import java.io.*;
public class FileCopy {
public static void copyFile(String src, String dest) {
try (BufferedReader br = new BufferedReader(new FileReader(src));
BufferedWriter bw = new BufferedWriter(new FileWriter(dest))) {
String line;
while ((line = br.readLine()) != null) {
bw.write(line);
bw.newLine();
}
System.out.println("文件复制成功!");
} catch (IOException e) {
System.err.println("复制失败:" + e.getMessage());
}
}
public static void main(String[] args) {
copyFile("input.txt", "output.txt");
}
}
注意:使用try-with-resources确保资源自动关闭,避免内存泄漏。
序列化用于对象持久化或网络传输:
import java.io.*;
class User implements Serializable {
private static final long serialVersionUID = 1L;
private String name;
private int age;
// 构造器、Getter/Setter略
}
// 序列化
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("user.ser"));
oos.writeObject(new User("李四", 25));
oos.close();
// 反序列化
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("user.ser"));
User user = (User) ois.readObject();
ois.close();
注意:serialVersionUID需显式声明,避免类结构变更导致反序列化失败。
1. 继承Thread类:
class MyThread extends Thread {
public void run() {
System.out.println("线程执行中:" + Thread.currentThread().getName());
}
}
new MyThread().start();
2. 实现Runnable接口:
class MyTask implements Runnable {
public void run() {
System.out.println("任务执行中:" + Thread.currentThread().getName());
}
}
new Thread(new MyTask()).start();
3. 使用Callable与Future(有返回值):
Callabletask = () -> { return 123; }; FutureTask future = new FutureTask<>(task); new Thread(future).start(); System.out.println("结果:" + future.get());
线程安全问题源于共享数据竞争,解决方案:
synchronized(obj) { ... }public synchronized void method() { ... }ReentrantLock支持可重入锁ReadWriteLock支持读写分离示例:使用synchronized实现计数器
public class Counter {
private int count = 0;
public synchronized void increment() {
count++; // 等价于 count = count + 1(非原子操作)
}
public int getCount() {
return count;
}
}
ExecutorService线程池示例:
ExecutorService pool = Executors.newFixedThreadPool(3);
for (int i = 0; i < 5; i++) {
pool.execute(() -> {
System.out.println("任务执行:" + Thread.currentThread().getName());
});
}
pool.shutdown(); // 关闭线程池
线程池核心参数:
corePoolSize:核心线程数maximumPoolSize:最大线程数keepAliveTime:空闲线程存活时间workQueue:任务队列(如LinkedBlockingQueue)生产环境推荐使用ThreadPoolExecutor自定义配置,避免Executors工厂方法的潜在风险(如无界队列导致OOM)。
使用JDBC访问数据库的标准步骤:
Class.forName("com.mysql.cj.jdbc.Driver");Connection conn = DriverManager.getConnection(url, user, pwd);PreparedStatement ps = conn.prepareStatement(sql);ResultSet rs = ps.executeQuery();ResultSet获取数据统一管理数据库连接与资源释放:
public class JDBCUtils {
private static final String URL = "jdbc:mysql://localhost:3306/test?useSSL=false&serverTimezone=UTC";
private static final String USER = "root";
private static final String PASSWORD = "123456";
static {
try {
Class.forName("com.mysql.cj.jdbc.Driver");
} catch (ClassNotFoundException e) {
throw new RuntimeException("驱动加载失败", e);
}
}
public static Connection getConnection() {
try {
return DriverManager.getConnection(URL, USER, PASSWORD);
} catch (SQLException e) {
throw new RuntimeException("连接数据库失败", e);
}
}
public static void close(Connection conn, PreparedStatement ps, ResultSet rs) {
if (rs != null) try { rs.close(); } catch (SQLException e) {}
if (ps != null) try { ps.close(); } catch (SQLException e) {}
if (conn != null) try { conn.close(); } catch (SQLException e) {}
}
}
错误示例(易受SQL注入攻击):
String sql = "SELECT * FROM users WHERE name='" + name + "' AND pwd='" + pwd + "'";
正确示例(参数化查询):
String sql = "SELECT * FROM users WHERE name=? AND pwd=?"; PreparedStatement ps = conn.prepareStatement(sql); ps.setString(1, name); ps.setString(2, pwd); ResultSet rs = ps.executeQuery();
使用PreparedStatement可自动转义特殊字符,有效防止SQL注入攻击。
UDP是无连接的轻量级协议,适合实时性要求高的场景(如视频直播):
发送端:
DatagramSocket socket = new DatagramSocket();
String msg = "Hello UDP";
byte[] data = msg.getBytes();
InetAddress addr = InetAddress.getByName("localhost");
DatagramPacket packet = new DatagramPacket(data, data.length, addr, 9999);
socket.send(packet);
socket.close();
接收端:
DatagramSocket socket = new DatagramSocket(9999);
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("收到:" + received);
socket.close();
TCP是面向连接的可靠协议,适合文件传输:
服务端:
ServerSocket server = new ServerSocket(8888);
Socket client = server.accept(); // 阻塞等待连接
BufferedReader in = new BufferedReader(new InputStreamReader(client.getInputStream()));
PrintWriter out = new PrintWriter(client.getOutputStream(), true);
String line = in.readLine();
System.out.println("收到:" + line);
out.println("服务器已收到:" + line);
in.close();
out.close();
client.close();
server.close();
客户端:
Socket socket = new Socket("localhost", 8888);
BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
out.println("Hello TCP");
String response = in.readLine();
System.out.println("服务器回复:" + response);
in.close();
out.close();
socket.close();
使用HttpURLConnection发起GET请求:
URL url = new URL("https://www.xservx.com/api/data");
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("GET");
conn.setConnectTimeout(5000);
int code = conn.getResponseCode();
if (code == 200) {
BufferedReader reader = new BufferedReader(new InputStreamReader(conn.getInputStream()));
String line;
StringBuilder result = new StringBuilder();
while ((line = reader.readLine()) != null) {
result.append(line);
}
System.out.println("响应数据:" + result.toString());
}
注意:实际开发中推荐使用HttpClient(Java 11+)或第三方库(如OkHttp)。
基于控制台的图书管理系统,包含以下核心功能:
├── Book(图书实体) │ ├── id(编号) │ ├── title(书名) │ ├── author(作者) │ └── status(状态:0-在库,1-已借出) │ ├── User(用户实体) │ ├── username(用户名) │ ├── password(密码) │ └── role(角色:admin/reader) │ ├── BorrowRecord(借阅记录) │ ├── bookId │ ├── userId │ ├── borrowDate │ └── returnDate │ ├── BookManager(图书管理类) │ ├── addBook() │ ├── searchBook() │ └── updateBook() │ ├── UserManager(用户管理类) │ ├── login() │ └── register() │ └── Main(主程序入口)
图书管理类核心方法:
public void addBook(Book book) {
books.add(book); // books为List
saveToFile(); // 保存到JSON文件
}
public List searchByTitle(String keyword) {
return books.stream()
.filter(b -> b.getTitle().contains(keyword))
.collect(Collectors.toList());
}
借书操作逻辑:
public boolean borrowBook(String bookId, String userId) {
Book book = findBookById(bookId);
if (book == null) {
System.out.println("图书不存在!");
return false;
}
if (book.getStatus() == 1) {
System.out.println("图书已被借出!");
return false;
}
book.setStatus(1);
BorrowRecord record = new BorrowRecord(bookId, userId, new Date(), null);
records.add(record);
saveToFile();
return true;
}
Q1:==与equals的区别?
答:==比较基本类型值或引用地址;equals默认比较地址,但String/Integer等类重写了该方法,比较内容。重写equals需同时重写hashCode。
Q2:HashMap与HashTable的区别?
答:HashMap线程不安全、允许null键值、性能高;Hashtable线程安全、不允许null键值、性能低。现代开发推荐ConcurrentHashMap。
Q3:final、finally、finalize的区别?
答:final修饰类/方法/变量(不可继承/重写/修改);finally是异常处理块;finalize是Object方法,对象被GC前调用(已废弃,不推荐使用)。
Q4:ArrayList扩容机制?
答:默认容量10,扩容为原容量的1.5倍(oldCapacity + (oldCapacity >> 1))。JDK 1.8后首次添加时才初始化数组。
Q5:ConcurrentHashMap如何实现线程安全?
答:JDK 1.8使用CAS+synchronized保证线程安全。将数据分段(Segment),每段独立加锁,减少锁竞争。
Q6:线程池的核心参数有哪些?
答:核心线程数、最大线程数、空闲线程存活时间、任务队列、拒绝策略(AbortPolicy/CallerRunsPolicy等)。
Q7:PreparedStatement与Statement的区别?
答:PreparedStatement预编译SQL,防SQL注入;Statement直接拼接SQL,易受注入攻击。
Q8:NIO与传统IO的区别?
答:传统IO是阻塞式流式处理;NIO(New IO)基于通道(Channel)和缓冲区(Buffer),支持非阻塞模式,适合高并发场景。