Java入门教程 - 零基础学习Java编程完整指南
2024/1/15大约 30 分钟
Java入门教程 - 零基础学习Java编程完整指南
本教程适合零基础的Java初学者，通过系统化的学习路径，帮助你快速掌握Java编程语言的核心知识。
📚 目录导航
- Java简介与概述
- Java开发环境搭建
- 第一个Java程序Hello World
- Java基础语法详解
- 面向对象编程核心概念
- Java常用类库和API
- 异常处理机制
- Java集合框架
- IO流操作
- 多线程编程
- 网络编程基础
- Java新特性简介
- 学习路径与进阶方向
1. Java简介与概述
1.1 什么是Java编程语言
Java是一种高级、面向对象的编程语言，由Sun Microsystems公司（现已被Oracle收购）的James Gosling等人于1995年正式发布。Java语言设计之初就遵循"一次编写，到处运行"（Write Once, Run Anywhere）的理念，这使得Java成为世界上最流行的编程语言之一。
1.2 Java语言的核心特点
跨平台性（平台无关性）
Java程序编译后生成字节码（bytecode），可以在任何安装了Java虚拟机（JVM）的平台上运行，无需重新编译。这是Java最重要的特性之一。
Java源代码(.java)
↓ 编译
字节码(.class)
↓ JVM解释执行
不同平台运行（Windows、Linux、macOS等）面向对象编程
Java是完全面向对象的语言，所有代码都必须写在类中。Java支持封装、继承、多态等面向对象的核心特性。
简单易学
Java语法相对简洁，去除了C++中复杂的指针、多重继承等特性，降低了学习难度。
安全性
Java提供了多层安全机制：
- 字节码验证
- 安全管理器
- 沙箱机制
- 自动内存管理
多线程支持
Java内置了多线程支持，可以轻松创建和管理多个线程，实现并发编程。
自动内存管理（垃圾回收）
Java的垃圾回收器（Garbage Collector）自动管理内存，程序员无需手动释放内存，大大降低了内存泄漏的风险。
1.3 Java版本发展历史
| 版本 | 发布时间 | 主要特性 |
|---|---|---|
| Java 1.0 | 1996年 | 第一个正式版本 |
| Java 1.2 | 1998年 | 引入集合框架（Collection Framework） |
| Java 5.0 | 2004年 | 泛型、注解、枚举、自动装箱/拆箱 |
| Java 8 | 2014年 | Lambda表达式、Stream API、新的日期时间API |
| Java 11 | 2018年 | LTS版本，移除部分模块 |
| Java 17 | 2021年 | 当前LTS版本，长期支持 |
| Java 21 | 2023年 | 最新LTS版本 |
LTS版本说明：LTS（Long Term Support）表示长期支持版本，Oracle会提供长期的技术支持和安全更新。
1.4 Java的应用领域
Web开发
Java在Web开发领域占据重要地位，主要框架包括：
- Spring Framework：企业级应用开发框架
- Spring Boot：快速开发微服务应用
- Struts：MVC框架
- Hibernate：ORM持久层框架
移动开发
- Android开发：Android应用主要使用Java或Kotlin开发
- 大量Android应用都是基于Java开发的
企业级应用
- 大型企业系统
- 银行、金融系统
- 电商平台
- ERP系统
大数据处理
- Hadoop：分布式计算框架
- Spark：大数据处理引擎
- Kafka：消息队列系统
游戏开发
- Minecraft：著名的沙盒游戏
- 各种手机游戏和网络游戏
嵌入式系统
- 物联网（IoT）设备
- 智能卡应用
- 嵌入式系统开发
1.5 Java技术体系
Java技术体系主要包括：
- Java SE（Java Standard Edition）：标准版，用于桌面应用开发
- Java EE（Java Enterprise Edition）：企业版，用于企业级应用开发
- Java ME（Java Micro Edition）：微型版，用于移动设备开发
1.6 为什么选择学习Java
- ✅ 市场需求大：Java开发岗位需求量大，就业机会多
- ✅ 薪资待遇好：Java开发工程师薪资水平较高
- ✅ 生态完善：拥有丰富的类库和框架
- ✅ 社区活跃：有庞大的开发者社区支持
- ✅ 应用广泛：在各个领域都有应用
- ✅ 学习资源丰富：教程、文档、书籍等学习资源丰富
2. Java开发环境搭建
2.1 前置准备
在开始学习Java之前，需要准备以下内容：
- 操作系统：Windows、macOS或Linux
- 网络连接：用于下载开发工具
- 学习热情：保持学习的热情和耐心
2.2 理解JDK、JRE和JVM
在学习Java之前，需要理解三个重要概念：
JDK（Java Development Kit）- Java开发工具包
JDK是Java开发工具包，包含了：
- Java编译器（javac）：将Java源代码编译成字节码
- Java运行时环境（JRE）
- 开发工具：调试工具、文档生成工具等
- 类库：Java标准类库
开发Java程序必须安装JDK。
JRE（Java Runtime Environment）- Java运行时环境
JRE是Java运行时环境，包含了：
- JVM（Java虚拟机）
- Java核心类库
- 其他支持文件
运行Java程序只需要安装JRE。
JVM（Java Virtual Machine）- Java虚拟机
JVM是Java虚拟机，负责：
- 解释执行字节码
- 内存管理
- 垃圾回收
关系图：
JDK = JRE + 开发工具
JRE = JVM + 核心类库2.3 Windows系统安装JDK
步骤1：下载JDK
- 访问Oracle官网：https://www.oracle.com/java/technologies/downloads/
- 或访问OpenJDK：https://adoptium.net/
- 选择适合的版本（推荐Java 17或Java 21 LTS版本）
- 选择Windows x64版本下载
步骤2：安装JDK
- 运行下载的安装程序（如：
jdk-17_windows-x64_bin.exe） - 点击"下一步"
- 选择安装路径（建议使用默认路径，如：
C:\Program Files\Java\jdk-17） - 记住安装路径，后续配置环境变量需要用到
- 完成安装
步骤3：配置环境变量
打开环境变量设置
- 右键"此电脑" → "属性"
- 点击"高级系统设置"
- 点击"环境变量"按钮
配置JAVA_HOME
- 在"系统变量"区域点击"新建"
- 变量名：
JAVA_HOME - 变量值：JDK安装路径（如：
C:\Program Files\Java\jdk-17） - 点击"确定"
配置Path变量
- 在"系统变量"中找到
Path变量，点击"编辑" - 点击"新建"，添加：
%JAVA_HOME%\bin - 点击"确定"保存
- 在"系统变量"中找到
验证安装
- 打开命令提示符（Win+R，输入cmd）
- 输入以下命令验证：
java -version javac -version- 如果显示版本信息，说明安装成功
步骤4：验证安装
打开命令提示符，执行以下命令：
# 查看Java版本
java -version
# 查看Java编译器版本
javac -version
# 查看Java安装路径
java -XshowSettings:properties -version 2>&1 | findstr "java.home"预期输出示例：
java version "17.0.8" 2023-07-18 LTS
Java(TM) SE Runtime Environment (build 17.0.8+9-LTS-211)
Java HotSpot(TM) 64-Bit Server VM (build 17.0.8+9-LTS-211, mixed mode, sharing)2.4 macOS系统安装JDK
方式一：使用Homebrew安装（推荐）
# 安装Homebrew（如果未安装）
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
# 安装OpenJDK
brew install openjdk@17
# 配置环境变量
echo 'export PATH="/opt/homebrew/opt/openjdk@17/bin:$PATH"' >> ~/.zshrc
source ~/.zshrc方式二：手动下载安装
- 访问Oracle或Adoptium官网下载macOS版本
- 下载
.dmg文件并安装 - 配置环境变量
编辑~/.zshrc或~/.bash_profile文件：
export JAVA_HOME=$(/usr/libexec/java_home)
export PATH=$JAVA_HOME/bin:$PATH然后执行：
source ~/.zshrc验证安装
java -version
javac -version2.5 Linux系统安装JDK
Ubuntu/Debian系统
# 更新包列表
sudo apt update
# 安装OpenJDK
sudo apt install openjdk-17-jdk
# 验证安装
java -version
javac -versionCentOS/RHEL系统
# 安装OpenJDK
sudo yum install java-17-openjdk-devel
# 验证安装
java -version
javac -version2.6 安装IDE（集成开发环境）
虽然可以使用文本编辑器和命令行开发Java，但使用IDE可以大大提高开发效率。
IntelliJ IDEA（强烈推荐）
优点：
- 功能强大，智能提示完善
- 代码重构能力强
- 插件丰富
- 对Java支持最好
下载安装：
- 访问：https://www.jetbrains.com/idea/
- 下载Community版本（免费）或Ultimate版本（付费）
- 按照安装向导完成安装
Eclipse
优点：
- 免费开源
- 插件丰富
- 跨平台
下载安装：
- 访问：https://www.eclipse.org/downloads/
- 下载Eclipse IDE for Java Developers
- 解压即可使用
VS Code
优点：
- 轻量级
- 免费
- 跨平台
配置：
- 安装Java扩展包
- 配置Java环境
2.7 验证开发环境
创建一个简单的测试程序验证环境：
- 创建测试文件：
HelloWorld.java - 编写代码：
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello, World!");
}
}- 编译：
javac HelloWorld.java- 运行：
java HelloWorld如果输出"Hello, World!"，说明环境配置成功！
3. 第一个Java程序Hello World
3.1 创建第一个Java程序
让我们从经典的"Hello World"程序开始，这是学习任何编程语言的第一步。
步骤1：创建Java源文件
创建一个名为HelloWorld.java的文件（文件名必须与类名相同，区分大小写）。
步骤2：编写代码
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello, World!");
}
}步骤3：编译程序
打开命令行，进入文件所在目录，执行：
javac HelloWorld.java如果编译成功，会生成HelloWorld.class文件（字节码文件）。
步骤4：运行程序
java HelloWorld注意：运行时不加.class扩展名。
预期输出：
Hello, World!3.2 程序结构详解
让我们详细分析这个简单的程序：
public class HelloWorld {
// ↑
// 1. public：访问修饰符，表示公共的，可以被外部访问
// 2. class：关键字，用于定义类
// 3. HelloWorld：类名，必须与文件名相同
public static void main(String[] args) {
// ↑
// 1. public：公共方法
// 2. static：静态方法，可以直接通过类名调用
// 3. void：返回类型，表示无返回值
// 4. main：方法名，程序入口点
// 5. String[] args：命令行参数数组
System.out.println("Hello, World!");
// System：系统类
// out：标准输出流对象
// println：打印并换行
}
}3.3 Java程序的基本结构
一个Java程序的基本结构：
// 1. 包声明（可选）
package com.example;
// 2. 导入语句（可选）
import java.util.Scanner;
// 3. 类定义
public class ClassName {
// 4. 成员变量（可选）
private int value;
// 5. 构造方法（可选）
public ClassName() {
// 构造方法体
}
// 6. 方法定义
public static void main(String[] args) {
// 方法体
}
// 7. 其他方法（可选）
public void method() {
// 方法体
}
}3.4 使用IDE创建项目
使用IntelliJ IDEA
创建新项目
- File → New → Project
- 选择Java项目
- 选择JDK版本
- 点击Next → Finish
创建类
- 右键src文件夹 → New → Java Class
- 输入类名：HelloWorld
- 选择Class类型
编写代码
- 在编辑器中输入代码
运行程序
- 右键代码 → Run 'HelloWorld.main()'
- 或点击运行按钮
使用Eclipse
创建项目
- File → New → Java Project
- 输入项目名
- 点击Finish
创建类
- 右键src → New → Class
- 输入类名
- 勾选"public static void main"
- 点击Finish
运行程序
- 右键代码 → Run As → Java Application
3.5 常见错误和解决方法
错误1：找不到或无法加载主类
错误信息：
Error: Could not find or load main class HelloWorld原因：
- 类名与文件名不一致
- 当前目录不正确
- 类文件不存在
解决方法：
- 确保类名与文件名完全一致（包括大小写）
- 确保在正确的目录下运行
- 先编译再运行
错误2：找不到符号
错误信息：
error: cannot find symbol原因：
- 拼写错误
- 缺少导入语句
- 类名错误
解决方法：
- 检查拼写
- 添加必要的import语句
- 检查类名是否正确
错误3：类名与文件名不一致
错误信息：
error: class HelloWorld is public, should be declared in a file named HelloWorld.java解决方法：
- 确保文件名与public类名完全一致
4. Java基础语法详解
4.1 Java注释
注释是代码中用于说明的文字，不会被编译器执行。Java支持三种注释方式：
单行注释
// 这是单行注释
int x = 10; // 这也是单行注释多行注释
/*
* 这是多行注释
* 可以写多行内容
* 用于较长的说明
*/文档注释
/**
* 这是文档注释
* 用于生成API文档
*
* @author 作者名
* @version 版本号
* @param 参数说明
* @return 返回值说明
*/
public class MyClass {
/**
* 方法说明
* @param name 姓名
* @return 问候语
*/
public String greet(String name) {
return "Hello, " + name;
}
}4.2 Java标识符和关键字
标识符规则
标识符是用于命名变量、方法、类等的名称，必须遵循以下规则：
- 必须以字母、下划线(_)或美元符号($)开头
- 后续可以是字母、数字、下划线或美元符号
- 不能使用Java关键字
- 区分大小写
- 没有长度限制
合法标识符示例：
int age;
String userName;
double _value;
int $count;
String user_name;非法标识符示例：
int 2age; // 不能以数字开头
String user-name; // 不能包含连字符
int class; // 不能使用关键字Java关键字
Java关键字是语言预定义的，不能用作标识符。常见关键字包括：
abstract, assert, boolean, break, byte, case, catch, char,
class, const, continue, default, do, double, else, enum,
extends, final, finally, float, for, goto, if, implements,
import, instanceof, int, interface, long, native, new,
package, private, protected, public, return, short, static,
strictfp, super, switch, synchronized, this, throw, throws,
transient, try, void, volatile, while4.3 Java数据类型
Java是强类型语言，每个变量都必须声明类型。Java数据类型分为两大类：
基本数据类型（Primitive Types）
| 类型 | 大小 | 范围 | 默认值 | 说明 |
|---|---|---|---|---|
| byte | 1字节 | -128 到 127 | 0 | 字节型 |
| short | 2字节 | -32,768 到 32,767 | 0 | 短整型 |
| int | 4字节 | -2³¹ 到 2³¹-1 | 0 | 整型（最常用） |
| long | 8字节 | -2⁶³ 到 2⁶³-1 | 0L | 长整型 |
| float | 4字节 | 约 ±3.4E38 | 0.0f | 单精度浮点型 |
| double | 8字节 | 约 ±1.7E308 | 0.0d | 双精度浮点型（最常用） |
| char | 2字节 | Unicode字符 | '\u0000' | 字符型 |
| boolean | 1位 | true/false | false | 布尔型 |
示例代码：
// 整数类型
byte b = 100;
short s = 1000;
int i = 100000;
long l = 10000000000L; // long类型需要加L后缀
// 浮点类型
float f = 3.14f; // float类型需要加f后缀
double d = 3.14159; // double类型可以不加d后缀
// 字符类型
char c = 'A';
char chinese = '中';
char unicode = '\u0041'; // Unicode编码
// 布尔类型
boolean flag = true;
boolean isReady = false;引用数据类型（Reference Types）
引用类型包括：
- 类（Class）：如String、自定义类
- 接口（Interface）
- 数组（Array）
示例代码：
// String类型
String str = "Hello World";
String name = new String("Java");
// 数组类型
int[] arr = {1, 2, 3};
String[] names = new String[5];
// 自定义类
Person person = new Person();4.4 变量和常量
变量声明和初始化
// 方式1：先声明后赋值
int age;
age = 25;
// 方式2：声明时初始化（推荐）
int age = 25;
String name = "张三";
// 方式3：多个变量声明
int x = 1, y = 2, z = 3;变量命名规范
- 使用有意义的名称
- 驼峰命名法：
userName、totalCount - 常量全大写：
MAX_SIZE、PI - 避免使用单个字母（循环变量除外）
常量定义
使用final关键字定义常量：
// 常量定义
final int MAX_SIZE = 100;
final double PI = 3.14159;
final String COMPANY_NAME = "Java公司";
// 常量命名通常使用全大写字母，单词间用下划线分隔
final int MAX_USER_COUNT = 1000;注意：常量一旦赋值就不能修改。
变量作用域
public class VariableScope {
static int classVariable = 100; // 类变量（静态变量）
int instanceVariable = 200; // 实例变量
public void method() {
int localVariable = 300; // 局部变量
{
int blockVariable = 400; // 块变量
System.out.println(blockVariable);
}
// System.out.println(blockVariable); // 错误！超出作用域
}
}4.5 Java运算符
算术运算符
int a = 10, b = 3;
System.out.println(a + b); // 13 加法
System.out.println(a - b); // 7 减法
System.out.println(a * b); // 30 乘法
System.out.println(a / b); // 3 除法（整数除法）
System.out.println(a % b); // 1 取余（模运算）
// 浮点数除法
double x = 10.0, y = 3.0;
System.out.println(x / y); // 3.3333333333333335
// 自增自减
int x = 5;
x++; // x = 6（后置自增）
++x; // x = 7（前置自增）
x--; // x = 6（后置自减）
--x; // x = 5（前置自减）
// 前置和后置的区别
int a = 5;
int b = a++; // b = 5, a = 6（先赋值后自增）
int c = ++a; // c = 7, a = 7（先自增后赋值）关系运算符
int a = 10, b = 20;
System.out.println(a == b); // false 等于
System.out.println(a != b); // true 不等于
System.out.println(a < b); // true 小于
System.out.println(a > b); // false 大于
System.out.println(a <= b); // true 小于等于
System.out.println(a >= b); // false 大于等于逻辑运算符
boolean x = true, y = false;
System.out.println(x && y); // false 逻辑与（两个都为true才为true）
System.out.println(x || y); // true 逻辑或（有一个为true就为true）
System.out.println(!x); // false 逻辑非（取反）
// 短路求值
int a = 5;
boolean result = (a > 10) && (a++ > 0); // a++不会执行，因为第一个条件为false
System.out.println(a); // 5赋值运算符
int a = 10;
a += 5; // a = a + 5, 结果：15
a -= 3; // a = a - 3, 结果：12
a *= 2; // a = a * 2, 结果：24
a /= 4; // a = a / 4, 结果：6
a %= 4; // a = a % 4, 结果：2三元运算符（条件运算符）
int a = 10, b = 20;
// 语法：条件 ? 值1 : 值2
int max = (a > b) ? a : b; // 如果a>b返回a，否则返回b
System.out.println(max); // 20
// 嵌套使用
int score = 85;
String grade = (score >= 90) ? "优秀" :
(score >= 80) ? "良好" :
(score >= 60) ? "及格" : "不及格";
System.out.println(grade); // 良好位运算符（了解即可）
int a = 5; // 二进制：101
int b = 3; // 二进制：011
System.out.println(a & b); // 1 按位与
System.out.println(a | b); // 7 按位或
System.out.println(a ^ b); // 6 按位异或
System.out.println(~a); // -6 按位取反
System.out.println(a << 1); // 10 左移
System.out.println(a >> 1); // 2 右移4.6 控制流程语句
if-else语句
int score = 85;
// 简单if语句
if (score >= 60) {
System.out.println("及格");
}
// if-else语句
if (score >= 60) {
System.out.println("及格");
} else {
System.out.println("不及格");
}
// if-else if-else语句
if (score >= 90) {
System.out.println("优秀");
} else if (score >= 80) {
System.out.println("良好");
} else if (score >= 60) {
System.out.println("及格");
} else {
System.out.println("不及格");
}switch语句
int day = 3;
switch (day) {
case 1:
System.out.println("星期一");
break;
case 2:
System.out.println("星期二");
break;
case 3:
System.out.println("星期三");
break;
case 4:
System.out.println("星期四");
break;
case 5:
System.out.println("星期五");
break;
case 6:
case 7:
System.out.println("周末");
break;
default:
System.out.println("无效的日期");
}
// Java 14+ 支持switch表达式
String dayName = switch (day) {
case 1 -> "星期一";
case 2 -> "星期二";
case 3 -> "星期三";
default -> "其他";
};for循环
// 传统for循环
for (int i = 0; i < 10; i++) {
System.out.println(i);
}
// 增强for循环（for-each）
int[] numbers = {1, 2, 3, 4, 5};
for (int num : numbers) {
System.out.println(num);
}
// 嵌套循环
for (int i = 1; i <= 9; i++) {
for (int j = 1; j <= i; j++) {
System.out.print(j + "×" + i + "=" + (i*j) + "\t");
}
System.out.println();
}while循环
int i = 0;
while (i < 10) {
System.out.println(i);
i++;
}
// do-while循环（至少执行一次）
int j = 0;
do {
System.out.println(j);
j++;
} while (j < 10);break和continue
// break：跳出循环
for (int i = 0; i < 10; i++) {
if (i == 5) {
break; // 当i=5时跳出循环
}
System.out.println(i);
}
// 输出：0, 1, 2, 3, 4
// continue：跳过本次循环
for (int i = 0; i < 10; i++) {
if (i % 2 == 0) {
continue; // 跳过偶数
}
System.out.println(i);
}
// 输出：1, 3, 5, 7, 9
// 标签break（跳出多层循环）
outer: for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if (i == 1 && j == 1) {
break outer; // 跳出外层循环
}
System.out.println(i + "," + j);
}
}4.7 数组
数组声明和初始化
// 方式1：声明后初始化
int[] arr1 = new int[5]; // 创建长度为5的数组，默认值为0
arr1[0] = 1;
arr1[1] = 2;
// 方式2：声明时初始化
int[] arr2 = {1, 2, 3, 4, 5};
// 方式3：使用new关键字
int[] arr3 = new int[]{1, 2, 3, 4, 5};
// 获取数组长度
System.out.println(arr2.length); // 5数组遍历
int[] arr = {1, 2, 3, 4, 5};
// 方式1：传统for循环
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
// 方式2：增强for循环（推荐）
for (int num : arr) {
System.out.println(num);
}多维数组
// 二维数组
int[][] matrix = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
// 访问元素
System.out.println(matrix[0][0]); // 1
System.out.println(matrix[1][2]); // 6
// 遍历二维数组
for (int i = 0; i < matrix.length; i++) {
for (int j = 0; j < matrix[i].length; j++) {
System.out.print(matrix[i][j] + " ");
}
System.out.println();
}数组常用操作
import java.util.Arrays;
int[] arr = {3, 1, 4, 1, 5, 9, 2, 6};
// 排序
Arrays.sort(arr);
System.out.println(Arrays.toString(arr)); // [1, 1, 2, 3, 4, 5, 6, 9]
// 查找
int index = Arrays.binarySearch(arr, 5); // 必须先排序
System.out.println(index);
// 填充
int[] arr2 = new int[5];
Arrays.fill(arr2, 10);
System.out.println(Arrays.toString(arr2)); // [10, 10, 10, 10, 10]
// 复制
int[] arr3 = Arrays.copyOf(arr, arr.length);4.8 字符串操作
String类
// 创建字符串
String str1 = "Hello";
String str2 = new String("World");
// 字符串连接
String result = str1 + " " + str2; // "Hello World"
// 常用方法
String text = "Hello World";
System.out.println(text.length()); // 11 获取长度
System.out.println(text.charAt(0)); // H 获取字符
System.out.println(text.substring(0, 5)); // Hello 截取子串
System.out.println(text.indexOf("World")); // 6 查找位置
System.out.println(text.toUpperCase()); // HELLO WORLD 转大写
System.out.println(text.toLowerCase()); // hello world 转小写
System.out.println(text.equals("Hello")); // false 比较内容
System.out.println(text.contains("World")); // true 是否包含
System.out.println(text.startsWith("Hello")); // true 是否以...开头
System.out.println(text.endsWith("World")); // true 是否以...结尾
System.out.println(text.replace("World", "Java")); // Hello Java 替换
System.out.println(text.trim()); // 去除首尾空格StringBuilder和StringBuffer
// StringBuilder（非线程安全，性能更好）
StringBuilder sb = new StringBuilder();
sb.append("Hello");
sb.append(" ");
sb.append("World");
String result = sb.toString(); // "Hello World"
// StringBuffer（线程安全）
StringBuffer sbf = new StringBuffer();
sbf.append("Hello");
sbf.append(" World");
String result2 = sbf.toString();何时使用：
- 字符串拼接次数少：使用
+或String - 字符串拼接次数多：使用
StringBuilder或StringBuffer - 多线程环境：使用
StringBuffer
5. 面向对象编程核心概念
5.1 什么是面向对象编程
面向对象编程（Object-Oriented Programming，OOP）是一种编程范式，它将程序组织成对象的集合，每个对象都有自己的属性和行为。
面向对象的三大特性
- 封装（Encapsulation）：将数据和方法包装在一起，隐藏内部实现
- 继承（Inheritance）：子类继承父类的属性和方法
- 多态（Polymorphism）：同一个接口可以有不同的实现方式
5.2 类和对象
类的定义
// 定义一个类
public class Student {
// 属性（成员变量）
private String name;
private int age;
private String studentId;
// 构造方法
public Student(String name, int age, String studentId) {
this.name = name;
this.age = age;
this.studentId = studentId;
}
// 无参构造方法
public Student() {
}
// 方法
public void study() {
System.out.println(name + "正在学习");
}
public void introduce() {
System.out.println("我是" + name + "，今年" + 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) {
this.age = age;
}
public String getStudentId() {
return studentId;
}
public void setStudentId(String studentId) {
this.studentId = studentId;
}
}创建和使用对象
// 创建对象
Student student1 = new Student("张三", 20, "2024001");
Student student2 = new Student(); // 使用无参构造方法
// 调用方法
student1.study();
student1.introduce();
// 访问属性（通过getter/setter）
student2.setName("李四");
student2.setAge(21);
System.out.println(student2.getName());5.3 构造方法
构造方法是用于创建对象的特殊方法，特点：
- 方法名与类名相同
- 没有返回值（连void都没有）
- 在创建对象时自动调用
public class Person {
private String name;
private int age;
// 无参构造方法
public Person() {
this.name = "未知";
this.age = 0;
}
// 有参构造方法
public Person(String name, int age) {
this.name = name;
this.age = age;
}
// 构造方法重载
public Person(String name) {
this.name = name;
this.age = 0;
}
}5.4 访问修饰符
Java提供了四种访问修饰符：
| 修饰符 | 同类 | 同包 | 子类 | 不同包 | 说明 |
|---|---|---|---|---|---|
| private | ✓ | ✗ | ✗ | ✗ | 私有，只能在本类访问 |
| 默认 | ✓ | ✓ | ✗ | ✗ | 包级别访问 |
| protected | ✓ | ✓ | ✓ | ✗ | 受保护，子类可访问 |
| public | ✓ | ✓ | ✓ | ✓ | 公共，所有地方可访问 |
public class AccessModifier {
private int privateVar = 1; // 私有，只能在本类访问
int defaultVar = 2; // 默认，同包可访问
protected int protectedVar = 3; // 受保护，子类可访问
public int publicVar = 4; // 公共，所有地方可访问
}5.5 封装
封装是将数据和方法包装在一起，隐藏内部实现细节，只暴露必要的接口。
public class BankAccount {
private double balance; // 私有属性，外部不能直接访问
public BankAccount(double initialBalance) {
if (initialBalance >= 0) {
this.balance = initialBalance;
} else {
this.balance = 0;
}
}
// 通过公共方法访问私有属性
public double getBalance() {
return balance;
}
public void deposit(double amount) {
if (amount > 0) {
balance += amount;
System.out.println("存款成功，余额：" + balance);
} else {
System.out.println("存款金额必须大于0");
}
}
public boolean withdraw(double amount) {
if (amount > 0 && amount <= balance) {
balance -= amount;
System.out.println("取款成功，余额：" + balance);
return true;
} else {
System.out.println("余额不足或金额无效");
return false;
}
}
}5.6 继承
继承允许一个类继承另一个类的属性和方法。
// 父类
public class Animal {
protected String name;
protected int age;
public Animal(String name, int age) {
this.name = name;
this.age = age;
}
public void eat() {
System.out.println(name + "正在吃东西");
}
public void sleep() {
System.out.println(name + "正在睡觉");
}
public void introduce() {
System.out.println("我是" + name + "，今年" + age + "岁");
}
}
// 子类
public class Dog extends Animal {
private String breed;
public Dog(String name, int age, String breed) {
super(name, age); // 调用父类构造方法
this.breed = breed;
}
// 重写父类方法
@Override
public void eat() {
System.out.println(name + "（" + breed + "）正在吃狗粮");
}
// 子类特有方法
public void bark() {
System.out.println(name + "正在汪汪叫");
}
// 重写introduce方法，添加品种信息
@Override
public void introduce() {
super.introduce(); // 调用父类方法
System.out.println("我是一只" + breed);
}
}
// 使用
Dog dog = new Dog("旺财", 3, "金毛");
dog.eat(); // 调用重写后的方法
dog.sleep(); // 调用继承的方法
dog.bark(); // 调用子类特有方法
dog.introduce(); // 调用重写后的方法super关键字
public class Parent {
protected int value = 100;
public void method() {
System.out.println("父类方法");
}
}
public class Child extends Parent {
private int value = 200;
public void method() {
super.method(); // 调用父类方法
System.out.println("子类方法");
System.out.println("子类value: " + value);
System.out.println("父类value: " + super.value); // 访问父类属性
}
}5.7 多态
多态是指同一个接口可以有不同的实现方式。
// 父类
public class Shape {
public void draw() {
System.out.println("绘制图形");
}
public double getArea() {
return 0;
}
}
// 子类1
public class Circle extends Shape {
private double radius;
public Circle(double radius) {
this.radius = radius;
}
@Override
public void draw() {
System.out.println("绘制圆形，半径：" + radius);
}
@Override
public double getArea() {
return Math.PI * radius * radius;
}
}
// 子类2
public class Rectangle extends Shape {
private double width;
private double height;
public Rectangle(double width, double height) {
this.width = width;
this.height = height;
}
@Override
public void draw() {
System.out.println("绘制矩形，宽：" + width + "，高：" + height);
}
@Override
public double getArea() {
return width * height;
}
}
// 使用多态
Shape shape1 = new Circle(5);
Shape shape2 = new Rectangle(4, 6);
shape1.draw(); // 绘制圆形，半径：5
shape2.draw(); // 绘制矩形，宽：4，高：6
System.out.println("圆形面积：" + shape1.getArea());
System.out.println("矩形面积：" + shape2.getArea());5.8 抽象类
抽象类不能实例化，只能被继承。抽象类可以包含抽象方法和普通方法。
// 抽象类
public abstract class Animal {
protected String name;
public Animal(String name) {
this.name = name;
}
// 抽象方法，子类必须实现
public abstract void makeSound();
// 普通方法
public void sleep() {
System.out.println(name + "正在睡觉");
}
public void eat() {
System.out.println(name + "正在吃东西");
}
}
// 实现抽象类
public class Cat extends Animal {
public Cat(String name) {
super(name);
}
@Override
public void makeSound() {
System.out.println(name + "喵喵叫");
}
}
public class Dog extends Animal {
public Dog(String name) {
super(name);
}
@Override
public void makeSound() {
System.out.println(name + "汪汪叫");
}
}
// 使用
Animal cat = new Cat("小花");
cat.makeSound(); // 小花喵喵叫
cat.sleep(); // 小花正在睡觉5.9 接口
接口定义了一组方法的规范，类可以实现接口。
// 接口
public interface Flyable {
void fly(); // 接口方法默认是public abstract
// Java 8+ 支持默认方法
default void takeOff() {
System.out.println("起飞");
}
// Java 8+ 支持静态方法
static void info() {
System.out.println("这是一个飞行接口");
}
}
public interface Swimmable {
void swim();
}
// 实现接口
public class Bird implements Flyable {
@Override
public void fly() {
System.out.println("鸟儿在飞翔");
}
}
public class Duck implements Flyable, Swimmable {
@Override
public void fly() {
System.out.println("鸭子飞");
}
@Override
public void swim() {
System.out.println("鸭子游");
}
}
// 使用
Bird bird = new Bird();
bird.fly();
bird.takeOff();
Flyable.info();5.10 内部类
成员内部类
public class Outer {
private int outerVar = 10;
class Inner {
private int innerVar = 20;
public void display() {
System.out.println("外部变量: " + outerVar);
System.out.println("内部变量: " + innerVar);
}
}
public void createInner() {
Inner inner = new Inner();
inner.display();
}
}
// 使用
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();
inner.display();静态内部类
public class Outer {
private static int outerVar = 10;
static class Inner {
public void display() {
System.out.println("外部变量: " + outerVar);
}
}
}
// 使用
Outer.Inner inner = new Outer.Inner();
inner.display();局部内部类
public class Outer {
public void method() {
class LocalInner {
public void display() {
System.out.println("局部内部类");
}
}
LocalInner local = new LocalInner();
local.display();
}
}匿名内部类
// 接口
interface Greeting {
void greet();
}
// 使用匿名内部类
Greeting greeting = new Greeting() {
@Override
public void greet() {
System.out.println("Hello");
}
};
greeting.greet();6. Java常用类库和API
6.1 Object类
Object是所有类的父类，常用方法：
public class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
// 重写toString方法
@Override
public String toString() {
return "Person{name='" + name + "', age=" + age + "}";
}
// 重写equals方法
@Override
public boolean equals(Object obj) {
if (this == obj) return true;
if (obj == null || getClass() != obj.getClass()) return false;
Person person = (Person) obj;
return age == person.age && name.equals(person.name);
}
// 重写hashCode方法
@Override
public int hashCode() {
return name.hashCode() * 31 + age;
}
}6.2 包装类
基本数据类型对应的包装类：
// 装箱：基本类型 → 包装类
Integer i1 = Integer.valueOf(100); // 推荐方式
Integer i2 = 100; // 自动装箱
// 拆箱：包装类 → 基本类型
int value1 = i1.intValue();
int value2 = i1; // 自动拆箱
// 字符串转换
String str = "123";
int num = Integer.parseInt(str);
Integer num2 = Integer.valueOf(str);
// 其他包装类
Double d = Double.valueOf(3.14);
Boolean b = Boolean.valueOf(true);
Character c = Character.valueOf('A');6.3 Math类
// 数学运算
System.out.println(Math.abs(-10)); // 10 绝对值
System.out.println(Math.max(5, 10)); // 10 最大值
System.out.println(Math.min(5, 10)); // 5 最小值
System.out.println(Math.pow(2, 3)); // 8.0 幂运算
System.out.println(Math.sqrt(16)); // 4.0 平方根
System.out.println(Math.round(3.7)); // 4 四舍五入
System.out.println(Math.ceil(3.2)); // 4.0 向上取整
System.out.println(Math.floor(3.8)); // 3.0 向下取整
System.out.println(Math.random()); // 0.0-1.0之间的随机数
// 生成指定范围的随机数
int random = (int)(Math.random() * 100); // 0-99的随机整数6.4 新的日期时间API（Java 8+）
import java.time.*;
import java.time.format.DateTimeFormatter;
// LocalDate：日期
LocalDate date = LocalDate.now();
LocalDate specificDate = LocalDate.of(2024, 1, 15);
System.out.println(date); // 2024-01-15
// LocalTime：时间
LocalTime time = LocalTime.now();
LocalTime specificTime = LocalTime.of(14, 30, 45);
System.out.println(time); // 14:30:45
// LocalDateTime：日期时间
LocalDateTime dateTime = LocalDateTime.now();
System.out.println(dateTime); // 2024-01-15T14:30:45
// 格式化
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String formatted = dateTime.format(formatter);
System.out.println(formatted); // 2024-01-15 14:30:45
// 日期计算
LocalDate tomorrow = date.plusDays(1);
LocalDate lastWeek = date.minusWeeks(1);7. 异常处理机制
7.1 什么是异常
异常是程序运行时发生的错误或意外情况。Java提供了完善的异常处理机制。
7.2 异常类型
Java异常层次结构：
ThrowableError：系统错误，通常不需要处理Exception：异常，需要处理RuntimeException：运行时异常- 其他Exception：检查异常
7.3 try-catch-finally
try {
int result = 10 / 0; // 可能抛出异常
} catch (ArithmeticException e) {
System.out.println("除零错误: " + e.getMessage());
} catch (Exception e) {
System.out.println("其他异常: " + e.getMessage());
} finally {
System.out.println("无论是否异常都会执行");
}7.4 抛出异常
public class Calculator {
public int divide(int a, int b) throws ArithmeticException {
if (b == 0) {
throw new ArithmeticException("除数不能为0");
}
return a / b;
}
}
// 使用
Calculator calc = new Calculator();
try {
int result = calc.divide(10, 0);
} catch (ArithmeticException e) {
System.out.println("捕获异常: " + e.getMessage());
}7.5 自定义异常
// 自定义异常类
public class CustomException extends Exception {
public CustomException(String message) {
super(message);
}
}
// 使用自定义异常
public class BankAccount {
private double balance;
public void withdraw(double amount) throws CustomException {
if (amount > balance) {
throw new CustomException("余额不足");
}
balance -= amount;
}
}8. Java集合框架
8.1 Collection接口
List接口
ArrayList（动态数组）
import java.util.ArrayList;
import java.util.List;
List<String> list = new ArrayList<>();
list.add("苹果");
list.add("香蕉");
list.add("橙子");
System.out.println(list.size()); // 3
System.out.println(list.get(0)); // 苹果
list.remove(1); // 删除索引1的元素
System.out.println(list.contains("苹果")); // true
// 遍历
for (String fruit : list) {
System.out.println(fruit);
}LinkedList（链表）
import java.util.LinkedList;
LinkedList<String> linkedList = new LinkedList<>();
linkedList.add("第一个");
linkedList.addFirst("最前面");
linkedList.addLast("最后面");
linkedList.removeFirst();
linkedList.removeLast();Set接口
HashSet（哈希集合，无序）
import java.util.HashSet;
import java.util.Set;
Set<String> set = new HashSet<>();
set.add("苹果");
set.add("香蕉");
set.add("苹果"); // 重复元素，不会添加
System.out.println(set.size()); // 2
System.out.println(set.contains("苹果")); // true8.2 Map接口
HashMap（哈希映射）
import java.util.HashMap;
import java.util.Map;
Map<String, Integer> map = new HashMap<>();
map.put("苹果", 10);
map.put("香蕉", 5);
map.put("橙子", 8);
System.out.println(map.get("苹果")); // 10
System.out.println(map.containsKey("苹果")); // true
System.out.println(map.size()); // 3
// 遍历
for (Map.Entry<String, Integer> entry : map.entrySet()) {
System.out.println(entry.getKey() + ": " + entry.getValue());
}9. IO流操作
9.1 文件操作
import java.io.File;
File file = new File("test.txt");
System.out.println(file.exists()); // 文件是否存在
System.out.println(file.isFile()); // 是否是文件
System.out.println(file.isDirectory()); // 是否是目录
System.out.println(file.length()); // 文件大小
System.out.println(file.getName()); // 文件名9.2 字符流
import java.io.*;
// 写入文件
try (FileWriter fw = new FileWriter("output.txt")) {
fw.write("Hello World");
} catch (IOException e) {
e.printStackTrace();
}
// 读取文件
try (FileReader fr = new FileReader("output.txt")) {
char[] buffer = new char[1024];
int length = fr.read(buffer);
String content = new String(buffer, 0, length);
System.out.println(content);
} catch (IOException e) {
e.printStackTrace();
}10. 多线程编程
10.1 创建线程
方式1：继承Thread类
public class MyThread extends Thread {
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName() + ": " + i);
}
}
}
// 使用
MyThread thread = new MyThread();
thread.start();方式2：实现Runnable接口
public class MyRunnable implements Runnable {
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName() + ": " + i);
}
}
}
// 使用
Thread thread = new Thread(new MyRunnable());
thread.start();10.2 线程同步
public class Counter {
private int count = 0;
public synchronized void increment() {
count++;
}
public synchronized int getCount() {
return count;
}
}11. 网络编程基础
11.1 Socket编程
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
// 服务器端
public class Server {
public static void main(String[] args) {
try (ServerSocket serverSocket = new ServerSocket(8888)) {
System.out.println("服务器启动，等待客户端连接...");
Socket socket = serverSocket.accept();
System.out.println("客户端已连接");
BufferedReader in = new BufferedReader(
new InputStreamReader(socket.getInputStream())
);
PrintWriter out = new PrintWriter(
socket.getOutputStream(), true
);
String message = in.readLine();
System.out.println("收到消息: " + message);
out.println("服务器已收到: " + message);
} catch (IOException e) {
e.printStackTrace();
}
}
}12. Java新特性简介
12.1 Java 8新特性
- Lambda表达式：简化代码
- Stream API：强大的数据处理
- Optional类：优雅处理空值
- 新的日期时间API：解决旧API问题
12.2 Java后续版本特性
- Java 9：模块系统
- Java 10：局部变量类型推断
- Java 11：HTTP客户端
- Java 17：模式匹配、密封类
13. 学习路径与进阶方向
13.1 学习路径总结
- 基础阶段：语法、数据类型、控制流程
- 面向对象：类、对象、继承、多态、接口
- 核心API：集合、IO、异常处理
- 高级特性：多线程、网络编程、反射
- 框架学习：Spring、Spring Boot、MyBatis等
13.2 编程实践建议
- 多写代码：理论结合实践，多动手编程
- 阅读源码：学习Java标准库源码
- 做项目：通过实际项目巩固知识
- 参与开源：贡献开源项目，提升能力
- 持续学习：关注Java新特性和最佳实践
13.3 推荐资源
- 官方文档：https://docs.oracle.com/javase/
- Java教程：Oracle官方Java教程
- 在线练习：LeetCode、牛客网
- 书籍推荐：
- 《Java核心技术》
- 《Effective Java》
- 《Java并发编程实战》
13.4 下一步学习方向
Java 8+新特性
- Lambda表达式
- Stream API
- Optional类
框架学习
- Spring框架
- Spring Boot
- MyBatis
数据库
- MySQL
- Redis
工具和中间件
- Maven/Gradle
- Git
- Docker
结语
恭喜你完成了Java入门教程的学习！Java是一门功能强大、应用广泛的编程语言。通过本教程，你已经掌握了Java的基础知识。
记住：
- 多实践：理论结合实践，多写代码
- 多思考：理解原理，不要死记硬背
- 多学习：关注社区，持续学习
祝你学习愉快，编程顺利！ 🚀
本教程由Java突击队学习社区编写，如有问题欢迎反馈。