系统·专业·实用

Java编程入门教程

本教程面向零基础学习者,系统化讲解Java语言从安装配置到实际开发的全过程,内容覆盖语法基础、面向对象编程、集合框架、异常处理、输入输出、多线程、网络编程、数据库连接等核心模块,并延伸至开发者工具使用、高频面试题解析、优质学习资源推荐、常见误区警示等实用周边知识,帮助读者建立完整的知识体系,高效入门Java开发。

Java语言自1995年由Sun公司发布以来,凭借其“一次编写,到处运行”的跨平台特性、强大的生态系统、稳健的性能表现以及活跃的社区支持,长期稳居全球主流编程语言前列。根据TIOBE指数统计,Java常年位列前三,是企业级应用开发、Android原生开发、大数据处理(如Hadoop、Spark)、微服务架构(Spring Boot/Cloud)等领域的首选语言。对于初学者而言,Java语法相对规整、类型安全、错误提示明确,是进入编程世界的理想起点。

本教程摒弃“碎片化”教学模式,采用“理论+示例+练习”三维一体结构,每章均配备可运行的完整代码示例,强调动手实践。所有代码均通过JDK 17标准编译验证,确保示例可复现性。教程特别注重初学者认知规律,对抽象概念(如JVM内存模型、反射机制、泛型擦除)采用类比与图解辅助理解,并设置“新手易错点”提示框,降低学习曲线。

学习路径建议:掌握基础语法 → 熟练面向对象 → 深入核心API → 接触开发工具 → 实战综合项目 → 拓展高级特性。每个阶段设置明确目标与验收标准,避免盲目学习。教程将持续更新,紧跟Java技术演进节奏,例如新版本中的模式匹配(Pattern Matching)、记录类(Records)、虚拟线程(Virtual Threads)等特性也将适时纳入进阶内容。

⚙️ 开发环境搭建

搭建规范、稳定的开发环境是编程学习的第一步。Java开发依赖三大核心组件:JDK(Java Development Kit,开发工具包)、JRE(Java Runtime Environment,运行环境)、JVM(Java Virtual Machine,虚拟机)。JDK包含JRE,JRE包含JVM,构成完整的Java运行与开发体系。

1. 选择JDK版本

当前主流JDK版本分为两类:长期支持版(LTS)与最新版。LTS版本每三年发布一次,提供5年免费更新,是生产环境首选;最新版每半年发布一次,包含新特性,适合尝鲜与学习。截至2025年,LTS版本包括JDK 8(2014)、JDK 11(2018)、JDK 17(2021)、JDK 21(2023);最新版为JDK 22(2024)。建议初学者从JDK 17入手,兼顾稳定性与现代特性。

主流发行版对比:

发行商 是否免费 更新周期 推荐场景
Oracle JDK 商业使用需付费(LTS免费至发布后1年) 每半年 企业生产环境(已购买许可)
Adoptium (Temurin) 完全免费 LTS长期支持 个人学习、开源项目首选
Amazon Corretto 完全免费 LTS长期支持 AWS云环境部署
Zulu (Azul) 基础版免费 LTS长期支持 跨平台企业应用

推荐使用Eclipse Temurin(原AdoptOpenJDK),由Eclipse基金会维护,下载地址:https://adoptium.net/。下载对应系统(Windows/macOS/Linux)的JDK 17安装包即可。

2. 配置环境变量

安装后需配置环境变量,确保命令行可识别java与javac指令:

  1. 右键“此电脑” → “属性” → “高级系统设置” → “环境变量”
  2. 新建系统变量:
    • 变量名:JAVA_HOME
    • 变量值:JDK安装路径(如 C:\Program Files\Eclipse Adoptium\jdk-17.0.10.7-hotspot)
  3. 编辑Path变量,新增:%JAVA_HOME%\bin
  4. 验证:打开命令提示符,输入java -version与javac -version,应显示版本号

macOS/Linux用户:编辑~/.bashrc或~/.zshrc,添加:

export JAVA_HOME=/Library/Java/JavaVirtualMachines/temurin-17.jdk/Contents/Home
export PATH=$JAVA_HOME/bin:$PATH

执行source ~/.zshrc生效后验证。

3. 选择IDE

集成开发环境(IDE)极大提升编码效率,推荐:

建议新手从IntelliJ IDEA Community入手,下载地址:https://www.jetbrains.com/idea/download/。安装后首次启动会引导配置JDK路径,自动识别JAVA_HOME。

4. 首个Java程序:Hello World

新建项目 → New Java Class → 输入类名HelloWorld → 编写代码:

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, Java!");
    }
}

点击运行按钮(绿色三角),控制台输出:Hello, Java!。恭喜!您已迈出编程第一步。

⚡ 基础语法核心

Java语法严谨、结构清晰,属于强类型、静态类型语言。掌握基础语法是理解后续高级特性的前提。本节系统梳理语法要点,并结合典型示例说明易错细节。

1. 数据类型与变量

Java数据类型分为两类:基本类型(8种)与引用类型(类、接口、数组)。

类型类别 类型 字节数 取值范围
基本类型 byte 1 -128 ~ 127
short 2 -32768 ~ 32767
int 4 -2³¹ ~ 2³¹-1
long 8 -2⁶³ ~ 2⁶³-1
float 4 约±3.40282347E+38F
double 8 约±1.79769313486231570E+308
char 2 0 ~ 65535(Unicode)
boolean 1位 true / false

关键规则:

2. 运算符与表达式

常见运算符分类:

典型陷阱:

int a = 1000000;
int b = 1000000;
long c = a * b; // 错误!a*b先以int计算,溢出后才转long,结果为负
long d = (long)a * b; // 正确:先将a转long,再乘

3. 控制流程

条件语句:

int score = 85;
if (score >= 90) {
    System.out.println("A");
} else if (score >= 80) {
    System.out.println("B");
} else {
    System.out.println("C");
}

循环语句:

// for循环:已知循环次数
for (int i = 1; i <= 5; i++) {
    System.out.println("第" + i + "次循环");
}
// while循环:未知次数,条件驱动
int count = 1;
while (count <= 3) {
    System.out.println("尝试第" + count + "次");
    count++;
}

增强for循环(JDK 5+):

String[] names = {"张三", "李四", "王五"};
for (String name : names) {
    System.out.println(name);
}

4. 数组

数组是相同类型元素的有序集合,长度固定。声明方式:

int[] numbers = new int[5]; // 创建长度为5的整型数组
int[] primes = {2, 3, 5, 7, 11}; // 直接初始化

数组操作示例:

int[] arr = {10, 20, 30};
System.out.println(arr.length); // 输出3
System.out.println(arr[1]); // 输出20(下标从0开始)
arr[2] = 40; // 修改第三个元素
// 遍历数组(增强for)
for (int num : arr) {
    System.out.print(num + " "); // 输出:10 20 40
}

多维数组:

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

♀♂ 面向对象编程

面向对象编程(OOP)是Java的核心思想,通过封装、继承、多态三大特性,实现代码复用、模块化与可维护性。理解OOP是掌握大型项目开发的关键。

1. 类与对象

类是对象的模板,定义属性与行为;对象是类的实例。示例:Student类:

public class Student {
    // 属性(成员变量)
    private String name;
    private int age;
    private double gpa;
    // 构造方法(初始化对象)
    public Student(String name, int age, double gpa) {
        this.name = name;
        this.age = age;
        this.gpa = gpa;
    }
    // 行为(方法)
    public void study() {
        System.out.println(name + "正在学习Java编程!");
    }
    // Getter/Setter(封装属性访问)
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public double getGpa() {
        return gpa;
    }
    public void setGpa(double gpa) {
        if (gpa >= 0.0 && gpa <= 4.0) {
            this.gpa = gpa;
        }
    }
}

创建对象并调用:

Student s = new Student("王小明", 20, 3.7);
s.study(); // 输出:王小明正在学习Java编程!
System.out.println(s.getName()); // 输出:王小明
s.setGpa(3.9); // 有效赋值
s.setGpa(5.0); // 无效,gpa保持3.7

2. 封装

将数据(属性)与操作(方法)绑定,并隐藏内部实现细节,仅暴露必要接口。通过private修饰符限制属性访问,用public方法提供受控读写。

封装优势:

3. 继承

通过extends实现类的复用与扩展。父类(超类)定义通用属性,子类添加特有属性。

public class CollegeStudent extends Student {
    private String major;
    public CollegeStudent(String name, int age, double gpa, String major) {
        super(name, age, gpa); // 调用父类构造方法
        this.major = major;
    }
    // 重写父类方法(多态体现)
    @Override
    public void study() {
        System.out.println(getName() + "正在专业课" + major + "中学习!");
    }
    // 新增方法
    public void attendLecture(String course) {
        System.out.println(getName() + "在" + course + "课上专注听讲");
    }
}

使用示例:

CollegeStudent cs = new CollegeStudent("李华", 21, 3.5, "计算机科学");
cs.study(); // 输出:李华正在专业课计算机科学中学习!
cs.attendLecture("数据结构"); // 输出:李华在数据结构课上专注听讲

关键点:

4. 多态

同一操作作用于不同对象,可产生不同效果。实现三要素:继承、重写、父类引用指向子类对象。

Student s1 = new Student("学生A", 18, 3.2);
Student s2 = new CollegeStudent("学生B", 20, 3.6, "软件工程");
// 多态调用:同一study()方法,表现不同行为
s1.study(); // 输出:学生A正在学习Java编程!
s2.study(); // 输出:学生B正在专业课软件工程中学习!

多态意义:降低耦合度,提升扩展性。新增子类(如GraduateStudent)无需修改调用方代码。

5. 抽象类与接口

抽象类(abstract class):不能实例化,可包含抽象方法(无方法体)与具体方法,用于代码复用。

public abstract class Animal {
    protected String name;
    public Animal(String name) {
        this.name = name;
    }
    // 抽象方法:强制子类实现
    public abstract void makeSound();
    // 具体方法:提供默认实现
    public void eat() {
        System.out.println(name + "正在吃东西");
    }
}

接口(interface):纯抽象,仅含抽象方法(JDK 8后可有默认方法与静态方法),支持多实现,用于定义行为规范。

public interface Flyable {
    void fly(); // 默认为public abstract
    // JDK 8+ 默认方法
    default void land() {
        System.out.println("安全着陆");
    }
}

实现与继承对比:

特性 继承(extends) 实现(implements)
类数限制 单继承(1个父类) 多实现(多个接口)
成员变量 可有实例变量 仅public static final常量
构造方法 有(用于初始化父类部分) 无
设计目的 代码复用(is-a关系) 行为规范(can-do关系)

〔〕 核心类库详解

Java标准库(Java Standard Library)提供丰富的API,覆盖字符串处理、集合框架、异常机制、输入输出、多线程等核心功能。熟练掌握核心类库是高效开发的基础。

1. 字符串处理(String & StringBuilder)

String特点:不可变(immutable),每次修改生成新对象,适合频繁读取、少修改场景。

String s = "Java";
s = s + "编程"; // 创建两个对象:原"Java" + 新"Java编程"
System.out.println(s); // 输出:Java编程

StringBuilder(线程不安全,高效)与StringBuffer(线程安全,效率略低)适用于频繁拼接。

StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    sb.append(i).append(",");
}
String result = sb.toString(); // 高效拼接

常用方法:

方法 说明 示例
.length() 字符串长度 "Hello".length() → 5
.equals() 内容比较(区分大小写) "java".equals("Java") → false
.equalsIgnoreCase() 内容比较(忽略大小写) "java".equalsIgnoreCase("Java") → true
.substring() 截取子串 "Hello".substring(1, 3) → "el"
.replace() 替换字符/字符串 "Java".replace('a', 'o') → "Joao"
.split() 按分隔符拆分 "a,b,c".split(",") → ["a","b","c"]

2. 集合框架(Collections Framework)

Java集合分为三大体系:Collection(单值集合)、Map(键值对集合)。核心接口及实现类:

接口 特点 常用实现类 典型场景
List 有序、可重复 ArrayList(数组)、LinkedList(链表) 需要索引访问、频繁遍历
Set 无序、不可重复 HashSet(哈希)、TreeSet(排序) 去重、集合运算
Map 键值对、键唯一 HashMap(非线程安全)、TreeMap(排序) 键值映射、快速查找

List使用示例:

List names = new ArrayList<>();
names.add("张三");
names.add("李四");
names.add(1, "王五"); // 插入到索引1位置
System.out.println(names.get(1)); // 输出:王五
names.remove("张三");
System.out.println(names.size()); // 输出:2

Map使用示例:

Map scores = new HashMap<>();
scores.put("语文", 92);
scores.put("数学", 88);
System.out.println(scores.get("数学")); // 输出:88
System.out.println(scores.containsKey("英语")); // 输出:false
for (Map.Entry entry : scores.entrySet()) {
    System.out.println(entry.getKey() + ":" + entry.getValue());
}

3. 异常处理(Exception Handling)

Java异常体系分:Error(严重错误,如内存溢出)、Exception(可处理异常),后者又分:RuntimeException(运行时异常,如空指针)与Checked Exception(编译时异常,如IO异常)。

异常处理语法:

try {
    int result = 10 / 0; // 可能抛出ArithmeticException
} catch (ArithmeticException e) {
    System.out.println("除零错误:" + e.getMessage());
} finally {
    System.out.println("操作结束");
}

自定义异常:

public class InvalidScoreException extends Exception {
    public InvalidScoreException(String message) {
        super(message);
    }
}
public void setScore(int score) throws InvalidScoreException {
    if (score < 0 || score > 100) {
        throw new InvalidScoreException("分数必须在0~100之间");
    }
    this.score = score;
}

4. 输入输出(I/O)

文件读写核心类:

类 用途 示例
FileReader/FileWriter 字符流(文本文件) 逐字符读写
BufferedReader/BufferedWriter 缓冲字符流(高效) 支持按行读取(readLine())
FileInputStream/FileOutputStream 字节流(二进制文件) 读写图片、音频等

按行读取文本文件示例:

try (BufferedReader br = new BufferedReader(new FileReader("input.txt"))) {
    String line;
    while ((line = br.readLine()) != null) {
        System.out.println(line);
    }
} catch (IOException e) {
    System.err.println("文件读取失败:" + e.getMessage());
}

写入文件示例:

try (BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"))) {
    bw.write("Hello, Java I/O!");
    bw.newLine();
    bw.write("文件写入成功");
} catch (IOException e) {
    System.err.println("文件写入失败:" + e.getMessage());
}

5. 多线程(Multithreading)

Java内置多线程支持,通过Thread类或Runnable接口实现。线程状态:新建→就绪→运行→阻塞→终止。

实现方式1:继承Thread类

public class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程执行:" + i);
        }
    }
}
// 启动线程
MyThread t = new MyThread();
t.start(); // 注意:必须调用start(),直接run()是同步调用

实现方式2:实现Runnable接口(推荐)

public class MyTask implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("任务执行:" + i);
        }
    }
}
// 启动线程
Thread t = new Thread(new MyTask());
t.start();

线程同步:解决多线程并发访问共享资源的线程安全问题。

// 使用synchronized关键字
public synchronized void increment() {
    count++;
}
// 或使用同步代码块
synchronized (lockObject) {
    count++;
}

6. 网络编程(Socket)

Java通过java.net包提供网络编程支持。典型应用:客户端-服务器通信。

服务器端(Server)

ServerSocket server = new ServerSocket(8080); // 监听8080端口
Socket client = server.accept(); // 阻塞等待客户端连接
BufferedReader in = new BufferedReader(new InputStreamReader(client.getInputStream()));
PrintWriter out = new PrintWriter(client.getOutputStream(), true);
String msg = in.readLine();
out.println("收到消息:" + msg);
client.close();
server.close();

客户端(Client)

Socket socket = new Socket("localhost", 8080);
PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
out.println("Hello, Server!");
String response = in.readLine();
System.out.println("服务器响应:" + response);
socket.close();

〔〕 开发工具与工程化

现代Java开发依赖专业工具提升效率,本节介绍必备工具链:构建工具、版本控制、测试框架、调试技巧。

1. 构建工具:Maven与Gradle

Maven(基于XML配置):

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>5.3.21</version>
    </dependency>
</dependencies>

Gradle(基于Groovy/Kotlin DSL):

dependencies {
    implementation 'org.springframework:spring-core:5.3.21'
}

两者均支持自动下载依赖、统一构建流程、集成CI/CD,推荐Gradle作为新项目首选。

2. 版本控制:Git

分布式版本控制系统,核心命令:

分支操作:

git branch feature-login       # 创建分支
git checkout feature-login     # 切换分支
git merge feature-login         # 合并分支到当前分支

配合GitHub/GitLab实现团队协作与代码托管。

3. 测试框架:JUnit

单元测试是保障代码质量的基石。JUnit 5核心注解:

注解 作用 示例
@Test 标记测试方法 @Test void testAdd()
@BeforeEach 每个测试前执行 初始化测试数据
@AfterEach 每个测试后执行 清理资源
@DisplayName 测试名称(中文友好) @DisplayName("加法测试")

测试示例:

@Test
@DisplayName("验证字符串长度")
void testStringLength() {
    String text = "Hello";
    assertEquals(5, text.length(), "长度应为5");
}

4. 调试技巧

断点调试步骤:

  1. 在代码行号处点击设置断点
  2. 右键代码 → Debug → 选择启动方式
  3. 使用调试控制按钮:
    • Step Over(F8):执行下一行
    • Step Into(F7):进入方法内部
    • Step Out(Shift+F8):跳出当前方法
    • Resume(F9):运行到下一断点
  4. 在Variables窗口查看变量值变化

日志调试:使用System.out.println()或日志框架(如Log4j2)记录关键变量值。

● 高频面试题解析

根据2024年招聘平台数据,Java岗位面试高频考点集中在以下方面,结合真实题目解析核心知识点。

Q1: Java与C++的主要区别?

答:

  • 内存管理:Java有垃圾回收(GC)自动管理内存;C++需手动管理new/delete,易出内存泄漏。
  • 跨平台性:Java通过JVM实现“一次编译,到处运行”;C++编译为平台特定机器码。
  • 指针:Java无指针(用引用代替),更安全;C++支持指针运算,灵活但危险。
  • 继承:Java单继承(类)+多实现(接口);C++多继承。
  • 泛型:Java泛型为伪泛型(类型擦除);C++模板为真泛型。

Q2: 重载(Overload)与重写(Override)的区别?

答:

对比项 重载(Overload) 重写(Override)
发生位置 同一类中 子类与父类之间
方法名 相同 相同
参数列表 必须不同(类型/个数/顺序) 必须相同
返回类型 可不同 相同或协变返回类型
访问修饰符 无限制 子类不能比父类更严格

Q1: 接口与抽象类的区别?

答:参考前文“2. 抽象类与接口”部分,重点强调:

  • 设计目的:抽象类为代码复用(is-a),接口为行为规范(can-do)。
  • 成员限制:接口仅能含抽象方法(JDK 8前)、常量;抽象类可有具体方法与实例变量。
  • 多继承支持:类单继承但可多实现接口;抽象类不能解决多继承问题。

Q2: super与this的使用规则?

答:

  • super()与this()都必须在构造方法首行,因此不能同时存在。
  • super调用父类构造方法;this调用本类其他构造方法。
  • super.属性访问父类成员;this.属性访问本类成员(区分同名变量)。

Q1: HashMap与HashTable的区别?

答:

对比项 HashMap HashTable
线程安全 线程不安全(高效) 线程安全(方法synchronized)
空键值 允许一个null键、多个null值 不允许null键/值
默认容量 16 11
扩容机制 2倍扩容 2n+1扩容
替代方案 线程安全用ConcurrentHashMap 基本淘汰,推荐用ConcurrentHashMap

Q2: ArrayList与LinkedList的区别?

答:

  • 底层结构:ArrayList基于动态数组;LinkedList基于双向链表。
  • 随机访问:ArrayList O(1)(下标直接访问);LinkedList O(n)(需遍历)。
  • 插入/删除:ArrayList尾部O(1),中间/头部O(n)(需移动元素);LinkedList任意位置O(1)(修改指针)。
  • 内存占用:ArrayList连续内存,空间利用率高;LinkedList节点存储额外指针,空间开销大。

Q1: synchronized与ReentrantLock的区别?

答:

对比项 synchronized ReentrantLock
实现层面 JVM关键字 API类(java.util.concurrent.locks)
锁获取 自动获取/释放 手动lock()/unlock()(需try-finally)
中断响应 不支持 支持(lockInterruptibly())
超时机制 不支持 支持(tryLock(timeout))
公平锁 非公平 可选(构造传true)

Q2: volatile关键字的作用?

答:

  • 可见性:保证变量修改对所有线程立即可见(强制从主内存读写)。
  • 禁止指令重排序:通过内存屏障实现。
  • 不保证原子性:如volatile int count,count++仍非原子操作。
  • 典型场景:状态标志(如volatile boolean running)、双重检查锁中的单例。

《》 优质学习资源推荐

精选国内外权威资源,覆盖视频课程、经典书籍、开源项目、技术社区,帮助学习者构建系统化知识体系。

视频课程

  • 《Java核心技术 卷I》(Cay Horstmann著):配套Coursera课程,理论扎实,适合打基础。
  • 慕课网《Java入门第一课》:零基础友好,代码示例丰富,节奏适中。
  • YouTube:Core Java by Telusko:免费全英文系列,讲解深入浅出,含源码解析。

经典书籍

书名 作者 推荐理由
《Effective Java》 Joshua Bloch Java开发圣经,300+条最佳实践,适合进阶提升。
《Java编程思想》 Bruce Eckel 深入讲解OOP思想,适合建立编程范式认知。
《Java并发编程实战》 Brian Goetz 并发领域权威著作,深入JMM、锁机制原理。

开源项目

  • Spring Framework:企业级开发基石,学习设计模式与IoC/AOP思想。
  • Netty:高性能网络框架,掌握NIO与事件驱动模型。
  • Hutool:Java工具类库,轻量级,适合学习实用技巧。

技术社区

  • Stack Overflow:全球最大问答社区,搜索问题必查。
  • SegmentFault:中文技术社区,问题响应快。
  • GitHub:托管代码、学习优秀项目、参与开源。

【】 新手常见误区与避坑指南

基于大量初学者反馈,总结高频错误与正确做法,帮助高效学习。

误区1:混淆“==”与“equals”

错误示例:

String a = new String("java");
String b = new String("java");
System.out.println(a == b); // 输出false(比较地址)
System.out.println(a.equals(b)); // 输出true(比较内容)

正确做法:字符串内容比较必须用equals();基本类型用==。

误区2:集合未指定泛型

错误示例:

List list = new ArrayList(); // 原始类型,类型不安全
list.add("Java");
list.add(123); // 编译通过,运行时可能出ClassCastException

正确做法:始终指定泛型类型:

List list = new ArrayList<>();
list.add("Java");
// list.add(123); // 编译错误,提前发现类型问题
误区3:忽略空指针(NullPointerException)

错误示例:

String s = null;
System.out.println(s.length()); // 直接抛NPE

正确做法:使用Objects.requireNonNull()或Optional(JDK 8+):

String s = null;
if (s != null) {
    System.out.println(s.length());
} else {
    System.out.println("字符串为空");
}
误区4:循环中频繁拼接字符串

错误示例:

String result = "";
for (int i = 0; i < 1000; i++) {
    result += i; // 每次创建新对象,效率极低
}

正确做法:使用StringBuilder:

StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    sb.append(i);
}
String result = sb.toString();