怎么写java程序

从零基础到项目实战的完整指南|系统掌握Java编程核心技能

入门基础

什么是Java语言?

Java是一种面向对象的跨平台编程语言,由Sun Microsystems于1995年发布,现为Oracle公司旗下产品。其核心理念是“一次编写,到处运行(Write Once, Run Anywhere)”,通过Java虚拟机(JVM)实现字节码的跨平台执行。

Java语言具有以下显著特点:

  • 语法简洁清晰,易于学习和使用
  • 自动内存管理机制(垃圾回收GC)
  • 丰富的标准类库(Java SE API)
  • 强大的多线程支持
  • 健壮的安全机制与异常处理体系
  • 活跃的开源社区与生态系统

自2004年Java 5引入泛型、注解、枚举等特性后,Java语言持续演进,当前主流版本为Java 17(长期支持版LTS),广泛应用于企业级应用开发、Android移动开发、大数据处理、微服务架构等领域。

Java开发流程全景图

编写一个Java程序通常包括以下步骤:

  1. 需求分析:明确程序要解决的问题及功能边界
  2. 设计架构:绘制类图、流程图、时序图等设计文档
  3. 编写代码:使用文本编辑器或IDE(如IntelliJ IDEA、Eclipse)创建.java源文件
  4. 编译源码:通过javac命令将.java文件编译为.class字节码文件
  5. 运行测试:使用java命令执行程序,观察输出结果与预期是否一致
  6. 调试优化:利用断点调试、日志输出等方式排查问题并优化性能
  7. 打包部署:使用Maven/Gradle构建工具打包为JAR/WAR,部署到服务器

示例:一个最简Java程序的完整生命周期

// Hello.java
public class Hello {
    public static void main(String[] args) {
        System.out.println("欢迎学习Java编程!");
    }
}

在终端中执行以下命令:

javac Hello.java   # 编译生成Hello.class
java Hello         # 运行程序,输出:欢迎学习Java编程!

注意:类名需与文件名完全一致(区分大小写),main方法是程序入口点,必须声明为public static void类型,接收String数组参数。

Java语言发展简史

1991年:Oak项目启动

Sun Microsystems团队为消费类电子设备开发Oak语言,后因市场变化转向互联网应用。

1995年:Java正式发布

在SunWorld大会上宣布Java 1.0,提出“Internet的Java”战略,引发全球开发热潮。

2004年:Java 5重大升级

引入泛型、注解、枚举、增强for循环、自动装箱/拆箱等现代特性,大幅提升开发效率。

2014年:Java 8里程碑版本

首次引入Lambda表达式与Stream API,支持函数式编程风格,彻底改变开发范式。

2017年:模块化系统JPMS

Java 9发布模块化特性(Module System),提升大型系统可维护性与安全性。

2021年:Java 17 LTS

当前主流长期支持版本,新增密封类、模式匹配、文本块增强等实用特性。

环境配置

开发环境搭建指南

搭建Java开发环境需完成以下三步:

  1. 安装JDK:下载并安装对应操作系统的JDK(Java Development Kit)
  2. 配置环境变量:设置JAVA_HOME、PATH、CLASSPATH(现代JDK可省略CLASSPATH)
  3. 验证安装:在终端执行java -version与javac -version确认版本信息

Windows系统配置示例:

  • 下载JDK安装包(如jdk-17_windows-x64_bin.exe)
  • 安装至目录如:C:\Program Files\Java\jdk-17
  • 系统环境变量添加:
    • JAVA_HOME = C:\Program Files\Java\jdk-17
    • PATH追加:;%JAVA_HOME%\bin
  • 重启终端,执行:
    java -version
    javac -version

macOS/Linux配置示例:

  • 使用Homebrew(macOS)或包管理器(Linux)安装:
    brew install openjdk@17   # macOS
    sudo apt install openjdk-17-jdk   # Ubuntu/Debian
  • 配置bash/zsh配置文件(~/.bashrc或~/.zshrc):
    export JAVA_HOME=$(/usr/libexec/java_home -v 17)   # macOS
    export JAVA_HOME=/usr/lib/jvm/java-17-openjdk-amd64   # Linux
    export PATH=$JAVA_HOME/bin:$PATH
  • 执行source命令使配置生效:
    source ~/.bashrc   # 或 source ~/.zshrc

主流IDE推荐

虽然可用文本编辑器编写Java程序,但专业IDE能大幅提升开发效率:

IDE名称 特点 适用场景
IntelliJ IDEA Ultimate 功能最全,支持Spring全栈、数据库工具、Docker集成 企业级Java开发首选
IntelliJ IDEA Community 免费基础版,支持核心Java开发 学习与轻量项目开发
Eclipse 老牌IDE,插件生态丰富,内存占用较高 历史项目维护与定制开发
VS Code + Java Extension Pack 轻量级编辑器+Java支持,启动快速 快速编辑与远程开发
NetBeans Oracle官方IDE,对JavaFX支持良好 桌面应用与教学实验

推荐组合:初学者可选用IntelliJ IDEA Community(免费)+ OpenJDK 17,后续进阶可升级至Ultimate版本。

命令行开发流程详解

即使使用IDE,掌握命令行开发仍至关重要:

  1. 创建项目目录:
    mkdir -p ~/java-projects/hello/src
    cd ~/java-projects/hello
  2. 编写源代码(src/com/example/Hello.java):
    package com.example;
    public class Hello {
        public static void main(String[] args) {
            System.out.println("Hello, Java!");
        }
    }
  3. 编译源码:
    javac -d out src/com/example/Hello.java
  4. 运行程序:
    java -cp out com.example.Hello

项目结构规范:

  • 源代码存放于src目录
  • 包名与目录结构严格对应(com.example对应src/com/example)
  • 编译输出至out目录(避免污染源码)
  • 运行时指定类路径(-cp)与完整类名(含包名)

基础语法

核心语法要素

Java程序由以下基本元素构成:

  • 关键字:如class、public、static、void、if、for等,共50个(含保留字)
  • 标识符:变量、方法、类名等命名规则:
    • 首字符必须为字母、下划线或美元符号
    • 后续字符可包含数字
    • 区分大小写
    • 避免使用Java关键字
  • 数据类型:
    • 基本类型:byte(1字节)、short(2)、int(4)、long(8)、float(4)、double(8)、char(2)、boolean(1位)
    • 引用类型:类、接口、数组
  • 运算符:算术、关系、逻辑、位、赋值、条件等10余类
  • 控制流:if-else、switch-case、for、while、do-while、break/continue

示例:变量声明与基本运算

public class VariableDemo {
    public static void main(String[] args) {
        // 整数类型
        byte b = 127;
        int count = 1000;
        long large = 10000000000L;
        // 浮点类型
        float price = 19.99f;
        double pi = 3.141592653589793;
        // 字符与字符串
        char grade = 'A';
        String name = "Java";
        // 布尔类型
        boolean isPass = true;
        // 运算示例
        int sum = count + 500;
        boolean check = (price > 10) && (grade == 'A');
        System.out.println("总和:" + sum);
        System.out.println("检查结果:" + check);
    }
}

数组与字符串操作

一维数组声明与初始化:

int[] numbers = new int[5];        // 声明长度为5的整型数组
int[] primes = {2, 3, 5, 7, 11};   // 直接初始化
int[] squares = new int[]{1, 4, 9, 16}; // 匿名数组

二维数组示例:

int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};
System.out.println(matrix[1][2]); // 输出:6

字符串常用操作:

  • length():获取字符串长度
  • charAt(int index):获取指定位置字符
  • substring(int start, int end):截取子串
  • equals(Object obj):比较字符串内容
  • toUpperCase()/toLowerCase():大小写转换
  • trim():去除首尾空白
  • split(String regex):按分隔符拆分

示例:字符串处理

String text = "  Java编程入门  ";
String trimmed = text.trim();                    // "Java编程入门"
String[] parts = trimmed.split("编程");          // ["Java", "入门"]
System.out.println(parts[0].toUpperCase());      // "JAVA"

方法定义与重载机制

Java方法是执行特定任务的代码块,定义格式为:

访问修饰符 返回类型 方法名(参数列表) {
    方法体
    return 返回值;
}

方法重载规则:

  • 方法名相同
  • 参数列表不同(类型、数量或顺序)
  • 与返回类型无关
  • 可改变访问修饰符

示例:重载方法

public class MathUtil {
    // 计算两数之和
    public static int sum(int a, int b) {
        return a + b;
    }
    // 计算三数之和
    public static int sum(int a, int b, int c) {
        return a + b + c;
    }
    // 计算双精度浮点数之和
    public static double sum(double a, double b) {
        return a + b;
    }
}

面向对象编程

三大核心特性

Java是纯面向对象语言,其核心特性包括:

封装
继承
多态

封装(Encapsulation)

将数据(属性)与操作数据的方法绑定为整体,并隐藏内部实现细节。通过private修饰符限制访问,提供public getter/setter方法控制数据读写。

示例:

public class Person {
    private String name;
    private int age;
    // 公共访问方法
    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("年龄无效!");
        }
    }
}

继承(Inheritance)

子类继承父类的属性和方法,实现代码复用。Java仅支持单继承,通过implements关键字实现接口多实现。

示例:

public class Animal {
    protected String name;
    public void eat() {
        System.out.println(name + "正在进食");
    }
}
public class Dog extends Animal {
    public Dog(String name) {
        this.name = name;
    }
    // 重写父类方法
    @Override
    public void eat() {
        System.out.println(name + "狼吞虎咽地吃骨头");
    }
    // 新增特有方法
    public void bark() {
        System.out.println(name + "汪汪叫");
    }
}

多态(Polymorphism)

同一操作作用于不同对象时,可产生不同执行结果。通过方法重写与向上转型实现。

示例:

Animal dog = new Dog("旺财"); // 向上转型
dog.eat(); // 输出:旺财狼吞虎咽地吃骨头

运行时动态绑定机制使程序具备良好扩展性,是设计模式实现的基础。

构造器与this关键字

构造器特点:

  • 方法名与类名完全相同
  • 无返回类型声明(不写void)
  • 创建对象时自动调用
  • 可重载多个构造器

示例:带参数构造器

public class Student {
    private String id;
    private String name;
    private int score;
    // 无参构造器
    public Student() {}
    // 全参构造器
    public Student(String id, String name, int score) {
        this.id = id;
        this.name = name;
        this.score = score;
    }
    // 构造器链式调用
    public Student(String id, String name) {
        this(id, name, 0); // 调用三参数构造器
    }
}

this关键字用途:

  • 区分成员变量与局部变量(如this.name = name)
  • 调用其他构造器(必须在首行)
  • 作为方法返回值(链式调用)
  • 传递当前对象引用

抽象类与接口对比

特性 抽象类 接口
定义关键字 abstract class interface
构造器 可有(但不可实例化) 不可有
成员变量 可有各种修饰符 默认public static final
方法实现 可有抽象/具体方法 JDK8+支持default/static方法
继承/实现 单继承 多实现
设计目的 代码复用与模板定义 行为规范与解耦

接口默认方法示例:

public interface Flyable {
    void fly();
    // 默认方法(JDK8+)
    default void land() {
        System.out.println("安全着陆");
    }
    // 静态方法(JDK8+)
    static void maxSpeed() {
        System.out.println("最高速度:800km/h");
    }
}

集合框架

集合体系总览

Java集合框架(Java Collections Framework)提供统一接口操作对象集合:

  • Collection(单值集合):
    • List(有序可重复):ArrayList、LinkedList、Vector
    • Set(无序不重复):HashSet、LinkedHashSet、TreeSet
  • Map(键值对集合):HashMap、LinkedHashMap、TreeMap、ConcurrentHashMap

核心接口对比:

接口 有序 可重复 线程安全 典型实现
ArrayList ✓ ✓ ✗ 动态数组
LinkedList ✓ ✓ ✗ 双向链表
HashSet ✗ ✗ ✗ 哈希表
TreeSet ✓(排序) ✗ ✗ 红黑树
HashMap ✗ ✓(值) ✗ 哈希表
ConcurrentHashMap ✗ ✓(值) ✓ 分段锁哈希表

常用集合操作示例

List操作:

import java.util.*;
List names = new ArrayList<>();
names.add("张三");
names.add("李四");
names.add(1, "王五"); // 指定位置插入
System.out.println(names.get(1)); // 输出:王五
System.out.println(names.size()); // 输出:3
// 增强for循环遍历
for (String name : names) {
    System.out.println(name);
}
// Lambda表达式遍历(JDK8+)
names.forEach(name -> System.out.println(name));

Map操作:

Map scores = new HashMap<>();
scores.put("语文", 95);
scores.put("数学", 92);
// 获取值
System.out.println(scores.get("语文")); // 输出:95
// 遍历键值对
scores.forEach((subject, score) ->
    System.out.println(subject + ": " + score)
);

泛型机制详解

泛型(Generics)将类型参数化,提高代码复用性与类型安全:

  • 泛型类:class Box<T> { private T value; }
  • 泛型方法:public <T> void print(T item)
  • 通配符:?、? extends T、? super T

自定义泛型类示例

public class Pair<K, V> {
    private K key;
    private V value;
    public Pair(K key, V value) {
        this.key = key;
        this.value = value;
    }
    public K getKey() { return key; }
    public V getValue() { return value; }
    public void setKey(K key) { this.key = key; }
    public void setValue(V value) { this.value = value; }
}
// 使用示例
Pair<String, Integer> pair = new Pair<>("年龄", 25);
System.out.println(pair.getKey() + " = " + pair.getValue());

多线程编程

线程创建方式

Java创建线程主要有三种方式:

  1. 继承Thread类:
    class MyThread extends Thread {
        public void run() {
            System.out.println("线程执行中...");
        }
    }
    new MyThread().start();
  2. 实现Runnable接口(推荐):
    class MyRunnable implements Runnable {
        public void run() {
            System.out.println("线程执行中...");
        }
    }
    new Thread(new MyRunnable()).start();
  3. 实现Callable接口(JDK5+):
    class MyCallable implements Callable<String> {
        public String call() {
            return "计算结果";
        }
    }
    FutureTask<String> task = new FutureTask<>(new MyCallable());
    new Thread(task).start();
    System.out.println(task.get());

推荐使用Runnable/Callable:避免单继承局限,支持多线程共享同一任务对象。

线程同步机制

多线程并发访问共享资源时需保证线程安全:

  • synchronized关键字:
    • 修饰方法:public synchronized void method()
    • 代码块:synchronized(this) { ... }
  • ReentrantLock类(JDK5+):
    Lock lock = new ReentrantLock();
    lock.lock();
    try {
        // 临界区代码
    } finally {
        lock.unlock();
    }
  • volatile关键字:保证变量可见性,禁止指令重排序

生产者-消费者示例:

class Buffer {
    private int data;
    private boolean available = false;
    public synchronized void put(int value) {
        while (available) {
            wait(); // 等待消费者消费
        }
        data = value;
        available = true;
        notifyAll(); // 唤醒等待线程
    }
    public synchronized int take() {
        while (!available) {
            wait(); // 等待生产者生产
        }
        available = false;
        notifyAll();
        return data;
    }
}

线程池与Executor框架

手动管理线程易出错,推荐使用线程池:

ExecutorService pool = Executors.newFixedThreadPool(4);
pool.execute(() -> System.out.println("任务1"));
pool.submit(() -> "任务2"); // 返回Future
pool.shutdown(); // 关闭线程池

线程池类型:

  • newFixedThreadPool:固定大小线程池
  • newCachedThreadPool:可缓存线程池
  • newSingleThreadExecutor:单线程池
  • newScheduledThreadPool:定时任务线程池

自定义线程池(推荐):

ThreadPoolExecutor pool = new ThreadPoolExecutor(
    4, // 核心线程数
    8, // 最大线程数
    60L, TimeUnit.SECONDS, // 空闲线程存活时间
    new LinkedBlockingQueue<>(100), // 任务队列
    new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略
);

数据库连接

JDBC核心操作流程

JDBC(Java Database Connectivity)提供统一API操作关系型数据库:

  1. 加载驱动:Class.forName("com.mysql.cj.jdbc.Driver")
  2. 获取连接:Connection conn = DriverManager.getConnection(url, user, pwd)
  3. 创建语句:Statement stmt = conn.createStatement()
  4. 执行查询:ResultSet rs = stmt.executeQuery(sql)
  5. 处理结果:遍历ResultSet获取数据
  6. 关闭资源:依次关闭ResultSet、Statement、Connection

完整示例(MySQL)

import java.sql.*;
public class JdbcDemo {
    public static void main(String[] args) throws SQLException {
        String url = "jdbc:mysql://localhost:3306/test?useSSL=false&serverTimezone=UTC";
        String user = "root";
        String password = "123456";
        try (Connection conn = DriverManager.getConnection(url, user, password);
             PreparedStatement stmt = conn.prepareStatement("SELECT * FROM users WHERE age > ?");
             ResultSet rs = stmt.executeQuery()) {
            stmt.setInt(1, 18);
            while (rs.next()) {
                System.out.println(rs.getInt("id") + ": " + rs.getString("name"));
            }
        }
    }
}

连接池与Druid配置

生产环境推荐使用连接池(如Druid、HikariCP):

Druid配置示例:

import com.alibaba.druid.pool.DruidDataSource;
import java.sql.Connection;
DruidDataSource ds = new DruidDataSource();
ds.setUrl("jdbc:mysql://localhost:3306/test");
ds.setUsername("root");
ds.setPassword("123456");
ds.setInitialSize(5);
ds.setMaxActive(20);
ds.setMaxWait(60000);
try (Connection conn = ds.getConnection()) {
    // 执行数据库操作
}

关键配置参数:

  • initialSize:初始连接数
  • maxActive:最大活跃连接数
  • maxWait:获取连接最大等待时间(毫秒)
  • minIdle:最小空闲连接数
  • validationQuery:连接有效性检测SQL

事务处理机制

JDBC事务控制通过Connection对象实现:

  • 关闭自动提交:conn.setAutoCommit(false)
  • 提交事务:conn.commit()
  • 回滚事务:conn.rollback()
  • 设置保存点:conn.setSavepoint()

事务处理示例

try {
    conn.setAutoCommit(false);
    // 操作1:转账扣款
    stmt.executeUpdate("UPDATE accounts SET balance = balance - 100 WHERE id = 1");
    // 操作2:转账入账
    stmt.executeUpdate("UPDATE accounts SET balance = balance + 100 WHERE id = 2");
    conn.commit(); // 提交事务
} catch (SQLException e) {
    conn.rollback(); // 回滚事务
    throw e;
} finally {
    conn.setAutoCommit(true);
}

Spring框架

Spring核心概念

Spring是Java企业级开发的轻量级框架,核心特性包括:

  • 控制反转(IoC):对象创建与依赖关系由容器管理
  • 依赖注入(DI):通过构造器/Setter注入依赖
  • 面向切面编程(AOP):分离横切关注点(日志、事务等)
  • 声明式事务:通过注解简化事务管理

IoC容器示例

// 定义Bean
@Component
public class UserService {
    @Autowired
    private UserRepository userRepository;
    public User getUser(Long id) {
        return userRepository.findById(id);
    }
}
// 配置类
@Configuration
@ComponentScan("com.example")
public class AppConfig {}
// 容器启动
AnnotationConfigApplicationContext context =
    new AnnotationConfigApplicationContext(AppConfig.class);
UserService userService = context.getBean(UserService.class);

Spring Boot快速开发

Spring Boot简化Spring应用初始搭建与开发:

  • 自动配置:基于classpath自动配置Spring
  • 起步依赖:简化Maven配置
  • 内嵌Tomcat:无需部署WAR文件
  • Actuator监控:提供健康检查、指标收集

Hello World示例

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}
@RestController
public class HelloController {
    @GetMapping("/hello")
    public String hello() {
        return "Hello, Spring Boot!";
    }
}

application.yml配置:

server:
  port: 8080
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/demo
    username: root
    password: 123456
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true

Spring Data JPA高效开发

Spring Data JPA简化数据库访问:

import org.springframework.data.jpa.repository.JpaRepository;
public interface UserRepository extends JpaRepository<User, Long> {
    // 自定义查询方法
    List<User> findByName(String name);
    // 使用@Query自定义SQL
    @Query("SELECT u FROM User u WHERE u.age > ?1")
    List<User> findAdults(int age);
}

实体类定义

@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private Integer age;
    // getters and setters
}

实战项目

项目结构设计

典型Java Web项目分层结构:

  • 表现层(Controller):处理HTTP请求,返回视图或JSON
  • 业务层(Service):实现业务逻辑,事务管理
  • 数据访问层(DAO):与数据库交互
  • 实体层(Entity):ORM映射数据库表
  • 工具层(Util):通用工具类(日期、加密、验证)

目录结构示例

src/main/java
├── com.example.project
│   ├── controller      # 控制器层
│   │   └── UserController.java
│   ├── service         # 业务层
│   │   └── UserService.java
│   │   └── impl        # 实现类
│   │       └── UserServiceImpl.java
│   ├── dao             # 数据访问层
│   │   └── UserRepository.java
│   ├── entity          # 实体类
│   │   └── User.java
│   ├── util            # 工具类
│   │   └── DateUtils.java
│   └── ProjectApplication.java  # 启动类

RESTful API设计规范

遵循RESTful风格的API设计原则:

  • 资源命名:使用名词复数(/users),避免动词
  • HTTP方法:
    • GET:获取资源
    • POST:创建资源
    • PUT:更新资源(全量)
    • PATCH:更新资源(部分)
    • DELETE:删除资源
  • 状态码:
    • 200:请求成功
    • 201:资源创建成功
    • 400:请求参数错误
    • 404:资源不存在
    • 500:服务器内部错误

Spring Boot控制器示例

@RestController
@RequestMapping("/api/users")
public class UserController {
    @Autowired
    private UserService userService;
    // 获取用户列表
    @GetMapping
    public List<User> getAllUsers() {
        return userService.findAll();
    }
    // 创建用户
    @PostMapping
    public ResponseEntity<User> createUser(@RequestBody User user) {
        User saved = userService.save(user);
        return ResponseEntity.status(HttpStatus.CREATED).body(saved);
    }
    // 更新用户
    @PutMapping("/{id}")
    public ResponseEntity<User> updateUser(@PathVariable Long id,
                                           @RequestBody User user) {
        user.setId(id);
        User updated = userService.update(user);
        return ResponseEntity.ok(updated);
    }
}

项目构建与部署

Maven配置(pom.xml)

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.12</version>
    </parent>
    <groupId>com.example</groupId>
    <artifactId>demo-project</artifactId>
    <version>1.0.0</version>
    <packaging>jar</packaging>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

构建与运行

# 构建JAR包
mvn clean package -DskipTests
# 运行应用
java -jar target/demo-project-1.0.0.jar
# 指定配置文件
java -jar demo-project.jar --spring.profiles.active=prod

常见问题

Q1:Java和JavaScript有什么区别?

Java是静态类型、编译型、面向对象的语言,主要用于后端开发;JavaScript是动态类型、解释型、基于原型的语言,主要用于前端浏览器交互。两者仅在语法上部分相似,本质完全不同。

Q2:如何选择Java版本?

生产环境建议使用LTS版本:Java 8(2014)、Java 11(2018)、Java 17(2021)。新项目优先选择Java 17,老项目可平滑升级至Java 11或17。避免使用非LTS版本(如Java 9-10、12-16)。

Q3:IDEA和Eclipse如何选择?

初学者推荐IntelliJ IDEA Community(免费版),界面友好、智能提示强;企业开发建议使用Ultimate版(付费),支持Spring全栈开发。Eclipse适合历史项目维护,内存占用较高但插件丰富。

Q4:如何解决OOM(内存溢出)问题?

常见原因:堆内存不足、线程栈溢出、Metaspace溢出。解决方案:

  • 调整JVM参数:-Xmx(最大堆)、-Xms(初始堆)、-Xss(线程栈)
  • 使用VisualVM或JProfiler分析内存泄漏
  • 优化代码:避免大对象、及时释放资源、使用对象池

Q5:Spring Boot如何配置多环境?

通过application-{profile}.yml区分环境:

  • application-dev.yml(开发环境)
  • application-test.yml(测试环境)
  • application-prod.yml(生产环境)
启动时指定:java -jar app.jar --spring.profiles.active=prod

网友还关心

  • Java学习路线:基础语法 → 面向对象 → 集合框架 → 多线程 → JDBC → Spring → Spring Boot → 微服务 → 分布式
  • 就业方向:Web后端开发、Android应用开发、大数据工程师、云计算开发、测试开发
  • 薪资水平:初级Java工程师(8-12K)、中级(15-25K)、高级(30K+),一线城市溢价30%-50%
  • 必备技能:熟练使用Git、理解Linux命令、掌握SQL、了解Docker、熟悉RESTful API设计
  • 开发工具:IntelliJ IDEA、Git、Maven、Postman、Navicat、Jenkins

学习资源推荐

  • 官方文档:
    • Java SE API文档:https://docs.oracle.com/en/java/javase/17/docs/api/
    • Spring Framework文档:https://spring.io/projects/spring-framework
  • 开源项目:
    • Spring Boot官方示例:https://github.com/spring-projects/spring-boot/tree/main/spring-boot-samples
    • Java技术栈:https://github.com/itwanger/toBeBetterJavaer
  • 在线学习:
    • 菜鸟教程Java教程:https://www.runoob.com/java/java-tutorial.html
    • 慕课网Java课程:https://www.imooc.com/learn/158