本页面为java程序包括源代码综合学习平台,专为Java开发者打造。我们致力于提供从零基础到企业级开发的完整知识体系,内容涵盖JDK安装配置、IDEA/Eclipse使用技巧、面向对象编程、集合框架、IO流、多线程、网络编程、数据库连接(JDBC)、SpringBoot微服务实战等核心领域。
所有示例代码均经过严格校验,确保可直接运行,每段代码均附有详细逻辑说明与运行结果截图(文字描述),便于开发者快速定位问题、理解设计思想。页面内容结构清晰、层次分明,兼顾系统性与实用性,适合不同阶段开发者按需查阅。
页面采用语义化HTML5标签构建,严格遵循W3C标准,确保跨设备兼容性与SEO友好性。所有模块均支持响应式布局,适配手机、平板、桌面端等多终端浏览。
构建稳定可靠的Java开发环境是项目成功的第一步。本节详述JDK安装、IDE配置、Maven/Gradle构建工具集成等关键步骤,帮助开发者快速完成环境部署。
当前主流JDK版本分为LTS(长期支持)与非LTS版本:
推荐选择:JDK 11或JDK 17,兼顾稳定性与现代特性支持。
IDEA是Java开发首选IDE,其智能提示、重构工具、集成调试等功能大幅提升开发效率:
重要提示:首次打开项目时,IDEA会自动索引JDK源码,首次编译可能较慢,属正常现象。
Maven通过POM文件统一管理依赖,避免“jar包地狱”:
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.example</groupId>
<artifactId>java-demo</artifactId>
<version>1.0-SNAPSHOT</version>
<dependencies>
<!-- Spring Boot Starter Web -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<version>3.2.3</version>
</dependency>
<!-- MySQL Connector -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.33</version>
</dependency>
</dependencies>
</project>
依赖传递机制:当引入spring-boot-starter-web时,Maven自动引入Tomcat、Spring MVC、Jackson等17个传递性依赖,无需手动声明。
「Q:IDEA中出现“Cannot resolve symbol 'java.lang.Object'」
原因:JDK未正确配置或索引损坏。解决方案:
① File → Invalidate Caches → Invalidate and Restart
② 检查Project Structure中JDK路径是否指向有效目录(含bin/java.exe)
③ 手动添加JDK源码路径:File → Project Structure → SDKs → Sourcepath → 添加src.zip路径
「Q:Maven项目无法下载依赖」
原因:网络限制或镜像配置错误。解决方案:
① 配置阿里云镜像(settings.xml):
<mirror>
<id>aliyunmaven</id>
<mirrorOf>central</mirrorOf>
<name>阿里云公共仓库</name>
<url>https://maven.aliyun.com/repository/public</url>
</mirror>
② 检查防火墙是否拦截Maven进程
③ 使用命令行测试:mvn dependency:get -Dartifact=org.apache.commons:commons-lang3:3.12.0
Java核心语法是构建高质量程序的基石,本节深入剖析面向对象、异常处理、泛型、反射等关键概念,并通过实战案例强化理解。
① 封装:隐藏实现细节,暴露有限接口
② 继承:代码复用,建立"is-a"关系
③ 多态:同一操作作用于不同对象可产生不同效果
示例代码:多态在支付系统中的应用
abstract class Payment {
protected double amount;
public Payment(double amount) {
this.amount = amount;
}
public abstract void pay();
}
class WeChatPay extends Payment {
public WeChatPay(double amount) {
super(amount);
}
@Override
public void pay() {
System.out.println("微信支付:" + amount + "元,使用扫码支付");
}
}
class Alipay extends Payment {
public Alipay(double amount) {
super(amount);
}
@Override
public void pay() {
System.out.println("支付宝支付:" + amount + "元,使用条码支付");
}
}
public class PaymentDemo {
public static void main(String[] args) {
Payment[] payments = {
new WeChatPay(99.9),
new Alipay(199.5)
};
for (Payment p : payments) {
p.pay(); // 运行时多态
}
}
}
运行结果:
微信支付:99.9元,使用扫码支付
支付宝支付:199.5元,使用条码支付
关键点:父类引用指向子类对象,调用方法时执行实际对象的方法实现。
合理使用异常机制可提升程序健壮性:
反例(不良实践):
try {
// 业务逻辑
} catch (Exception e) {
// 空处理,吞掉异常
}
正例(资源管理):
public String readFile(String path) {
try (BufferedReader reader = new BufferedReader(new FileReader(path))) {
return reader.readLine();
} catch (IOException e) {
System.err.println("文件读取失败:" + path);
return null;
}
}
泛型在编译期提供类型安全检查,运行时执行类型擦除:
public class Box<T> {
private T content;
public void set(T content) {
this.content = content;
}
public T get() {
return content;
}
}
// 使用示例
Box<String> stringBox = new Box<>();
stringBox.set("Hello");
// stringBox.set(123); // 编译错误
类型擦除影响:
反射允许运行时动态获取类信息并操作对象:
import java.lang.reflect.*;
public class ReflectionDemo {
public static void main(String[] args) throws Exception {
Class<?> clazz = Class.forName("java.util.ArrayList");
// 获取所有公共方法
Method[] methods = clazz.getMethods();
for (Method m : methods) {
System.out.println(m.getName() + ":" + java.util.Arrays.toString(m.getParameterTypes()));
}
// 创建实例
Object list = clazz.getDeclaredConstructor().newInstance();
// 调用add方法
Method addMethod = clazz.getMethod("add", Object.class);
addMethod.invoke(list, "Java");
// 调用size方法
Method sizeMethod = clazz.getMethod("size");
Integer size = (Integer) sizeMethod.invoke(list);
System.out.println("列表大小:" + size);
}
}
输出节选:
add:[class java.lang.Object]
get:[int]
size:[]
应用场景:Spring依赖注入、MyBatis动态代理、JSON序列化库(Jackson/Gson)
Spring Boot简化了Spring应用的初始搭建及开发过程,成为Java微服务开发事实标准。
标准Maven项目结构:
主启动类示例:
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
注解说明:
使用@RestController构建RESTful服务:
@RestController
@RequestMapping("/api/users")
public class UserController {
@Autowired
private UserService userService;
// 获取用户列表
@GetMapping
public List<User> getAllUsers() {
return userService.findAll();
}
// 创建用户
@PostMapping
public ResponseEntity<User> createUser(@Valid @RequestBody User user) {
User saved = userService.save(user);
return ResponseEntity.created(URI.create("/api/users/" + saved.getId()))
.body(saved);
}
// 更新用户
@PutMapping("/{id}")
public ResponseEntity<User> updateUser(@PathVariable Long id,
@Valid @RequestBody User user) {
User updated = userService.update(id, user);
return ResponseEntity.ok(updated);
}
// 删除用户
@DeleteMapping("/{id}")
public ResponseEntity<Void> deleteUser(@PathVariable Long id) {
userService.delete(id);
return ResponseEntity.noContent().build();
}
}
关键点:
实现基于JWT的无状态认证:
@Configuration
@EnableWebSecurity
public class SecurityConfig {
@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
http
.csrf().disable()
.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
.and()
.addFilterBefore(jwtFilter(), UsernamePasswordAuthenticationFilter.class)
.authorizeHttpRequests(auth -> auth
.requestMatchers("/api/auth/**").permitAll()
.anyRequest().authenticated()
);
return http.build();
}
@Bean
public JwtFilter jwtFilter() {
return new JwtFilter();
}
}
JWT过滤器实现:
public class JwtFilter extends OncePerRequestFilter {
@Autowired
private JwtUtil jwtUtil;
@Override
protected void doFilterInternal(HttpServletRequest request,
HttpServletResponse response,
FilterChain chain) throws ServletException, IOException {
String authHeader = request.getHeader("Authorization");
if (authHeader != null && authHeader.startsWith("Bearer ")) {
String token = authHeader.substring(7);
if (jwtUtil.validateToken(token)) {
String username = jwtUtil.getUsernameFromToken(token);
UsernamePasswordAuthenticationToken auth =
new UsernamePasswordAuthenticationToken(username, null, Collections.emptyList());
SecurityContextHolder.getContext().setAuthentication(auth);
}
}
chain.doFilter(request, response);
}
}
Java连接数据库主要通过JDBC及ORM框架实现。
主流连接池性能对比:
| 连接池 | 默认大小 | 最大连接数 | 性能 | 特性 |
|---|---|---|---|---|
| HikariCP | 10 | 100 | 极高 | 零依赖、高性能、Spring Boot默认 |
| Druid | 3 | 8 | 高 | 监控功能强大、SQL解析器 |
| C3P0 | 3 | 15 | 中 | 成熟稳定、支持异步创建 |
| DBCP | 8 | 8 | 中低 | Apache Commons项目、简单 |
推荐:Spring Boot项目默认使用HikariCP,因其在高并发场景下延迟最低、吞吐量最高。
MyBatis通过XML或注解实现动态SQL:
<select id="selectUsers" parameterType="map" resultType="User">
SELECT * FROM users
<where>
<if test="name != null">
AND name LIKE CONCAT('%', #{name}, '%')
</if>
<if test="minAge != null">
AND age >= #{minAge}
</if>
<choose>
<when test="orderBy == 'name'">
ORDER BY name
</when>
<otherwise>
ORDER BY create_time DESC
</otherwise>
</choose>
</where>
</select>
动态SQL标签:
JPA通过注解实现对象关系映射:
@Entity
@Table(name = "users")
public class User {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(nullable = false, length = 50)
private String name;
@Email
@Column(unique = true)
private String email;
@OneToMany(mappedBy = "user", cascade = CascadeType.ALL, orphanRemoval = true)
private List<Order> orders = new ArrayList<>();
// getters and setters
}
关键注解说明:
Java提供多层次网络编程支持,从原始Socket到高级框架。
// 服务器端
public class TcpServer {
public static void main(String[] args) throws IOException {
ServerSocket serverSocket = new ServerSocket(8080);
System.out.println("服务器启动,监听端口8080...");
while (true) {
Socket clientSocket = serverSocket.accept();
new Thread(() -> {
try (BufferedReader in = new BufferedReader(
new InputStreamReader(clientSocket.getInputStream()));
PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true)) {
String inputLine;
while ((inputLine = in.readLine()) != null) {
System.out.println("收到:" + inputLine);
out.println("Echo: " + inputLine);
}
} catch (IOException e) {
e.printStackTrace();
}
}).start();
}
}
}
// 客户端
public class TcpClient {
public static void main(String[] args) throws IOException {
try (Socket socket = new Socket("localhost", 8080);
BufferedReader in = new BufferedReader(
new InputStreamReader(socket.getInputStream()));
PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
Scanner scanner = new Scanner(System.in)) {
System.out.print("请输入消息:");
out.println(scanner.nextLine());
System.out.println("服务器响应:" + in.readLine());
}
}
}
运行结果:
服务器启动,监听端口8080...
(客户端)请输入消息:Hello
服务器响应:Echo: Hello
Java HTTP客户端发展路径:
Java 11 HttpClient示例:
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.github.com/users/octocat"))
.GET()
.build();
HttpResponse<String> response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println(response.statusCode());
System.out.println(response.body());
多线程是提升程序并发性能的关键技术。
三种主要方式:
// 方式1:继承Thread类
class MyThread extends Thread {
public void run() {
System.out.println("Thread运行中");
}
}
// 方式2:实现Runnable接口
class MyRunnable implements Runnable {
public void run() {
System.out.println("Runnable运行中");
}
}
// 方式3:Lambda表达式(Java 8+)
new Thread(() -> System.out.println("Lambda运行中")).start();
// 方式4:线程池(推荐)
ExecutorService pool = Executors.newFixedThreadPool(3);
pool.submit(() -> System.out.println("线程池运行中"));
推荐使用线程池,避免频繁创建销毁线程的开销。
解决共享资源竞争问题:
public class Counter {
private int count = 0;
private final Object lock = new Object();
public void increment() {
synchronized(lock) {
count++;
}
}
public int getCount() {
synchronized(lock) {
return count;
}
}
}
其他同步工具:
Java 8引入的异步编程模型:
CompletableFuture<String> future = CompletableFuture
.supplyAsync(() -> {
try { Thread.sleep(1000); } catch (InterruptedException e) {}
return "Hello";
})
.thenApplyAsync(s -> s + " World")
.thenApplyAsync(s -> s + "!");
String result = future.join();
System.out.println(result); // Hello World!
优势:
Java IO流分为字节流与字符流,支持文件、网络、内存等数据传输。
传统IO vs NIO vs Files工具类:
// 传统IO
try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"));
BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"))) {
String line;
while ((line = reader.readLine()) != null) {
writer.write(line);
writer.newLine();
}
}
// NIO
try (FileChannel in = FileChannel.open(Paths.get("input.txt"), StandardOpenOption.READ);
FileChannel out = FileChannel.open(Paths.get("output.txt"),
StandardOpenOption.CREATE, StandardOpenOption.WRITE)) {
ByteBuffer buffer = ByteBuffer.allocate(4096);
while (in.read(buffer) != -1) {
buffer.flip();
out.write(buffer);
buffer.compact();
}
}
// Java 7 Files工具类(推荐)
Files.copy(Paths.get("input.txt"), Paths.get("output.txt"));
Files工具类支持:
实现对象持久化:
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"))) {
User user = new User("张三", 28);
oos.writeObject(user);
}
// 反序列化
try (ObjectInputStream ois = new ObjectInputStream(
new FileInputStream("user.ser"))) {
User user = (User) ois.readObject();
System.out.println(user.getName() + "," + user.getAge() + "岁");
}
注意:
集合是Java开发中最常用的数据结构。
主要实现类特性:
| 实现类 | 底层结构 | 线程安全 | 顺序 | 适用场景 |
|---|---|---|---|---|
| ArrayList | 动态数组 | 否 | 有序 | 查询频繁、尾部插入 |
| LinkedList | 双向链表 | 否 | 有序 | 频繁插入/删除 |
| Vector | 动态数组 | 是 | 有序 | 旧系统、多线程环境 |
| Collections.synchronizedList | 包装器 | 是 | 有序 | 动态包装任意List |
性能测试结果(10万次操作):
常见Map实现:
HashMap扩容机制:
Java 8引入的函数式编程工具:
List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
// 过滤长度>3的名字,转换为大写,排序
List<String> result = names.stream()
.filter(name -> name.length() > 3)
.map(String::toUpperCase)
.sorted()
.collect(Collectors.toList());
System.out.println(result); // [ALICE, CHARLIE, DAVID]
关键操作:
以下问题来自开发者社区高频提问,结合实际案例给出解答:
需要同时重写equals和hashCode方法:
public class Person {
private String name;
private int age;
// 构造器、getter/setter
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return age == person.age &&
Objects.equals(name, person.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
}
错误示例:仅重写equals未重写hashCode,会导致HashSet无法正确去重。
① 静态集合引用:
public class Cache {
private static final List<Object> cache = new ArrayList<>();
public void addToCache(Object obj) {
cache.add(obj); // 长期持有对象引用
}
}
② 未关闭资源:流、Socket、数据库连接未正确关闭
③ 监听器未注销:添加监听器后未在适当时机移除
④ ThreadLocal未清理:在线程池中使用后未调用remove()
性能分析工具:
① Pattern Matching for instanceof:
if (obj instanceof String s) {
System.out.println(s.toUpperCase());
}
② Sealed Classes:
public sealed interface Shape
permits Circle, Rectangle { }
③ Text Blocks:
String json = """
{
"name": "Java",
"version": "17"
}
""";
Java技术生态覆盖全栈开发需求:
Spring Boot 3.x:要求JDK 17+,原生支持Spring Native
Java 21:LTS版本,虚拟线程正式标准化
Quarkus 2.x:云原生Java框架,启动时间<100ms
Micronaut 3.x:AOT编译,降低内存占用
Java 17:LTS版本,ZGC性能提升
Helidon 3.x:Oracle官方微服务框架
Spring Boot 2.4:配置文件重构
GraalVM 21.0:支持Java 11/15
推荐书籍:
高频面试题分类整理: