目录
BufferedReader 和 BufferedWriter
Java 自 1995 年问世以来，一直是编程领域的重要角色。它的跨平台特性、强大的生态系统和广泛的应用领域，使其成为初学者和专业开发者的首选语言之一。本文将为您提供一条详细而全面的 Java 学习路线，帮助您从零开始，逐步深入，最终掌握这门强大的编程语言。
一、引言
Java 的背景和发展
Java 由 Sun Microsystems 的詹姆斯·高斯林（James Gosling）及其团队开发，最初旨在为家用电器和嵌入式系统提供一种便携的编程语言。随着互联网的兴起，Java 的“写一次，处处运行”特性使其在网络应用开发中迅速流行。现在，Java 已经被广泛应用于企业级应用、大数据、移动开发和物联网等多个领域。
学习 Java 的意义
- 广泛的应用领域：掌握 Java，您可以从事 Web 开发、Android 移动应用、大数据处理等多种工作。
- 强大的社区支持：Java 拥有庞大的开发者社区，丰富的开源库和框架，学习资源极其丰富。
- 面向对象编程：深入理解 Java，有助于掌握面向对象编程思想，提高编程能力。
二、Java 的核心特性
1. 面向对象编程（OOP）
Java 是一门纯面向对象的编程语言，支持封装、继承、多态和抽象等基本特性。
- 封装：通过访问控制符（public、private、protected）来控制类成员的可见性，保护数据的完整性。
- 继承：使用
extends关键字，使子类继承父类的属性和方法，实现代码重用。 - 多态：通过方法重载和方法重写，实现同一接口的不同实现，提高代码的灵活性。
2. 跨平台性
Java 的跨平台特性源于其虚拟机机制。Java 源代码被编译为与平台无关的字节码，由 Java 虚拟机（JVM）执行。这意味着同一份代码可以在安装了 JVM 的任何设备上运行，实现了真正的“写一次，处处运行”。
3. 自动内存管理
Java 提供了垃圾回收机制（Garbage Collection），自动管理内存的分配和释放。开发者无需手动释放内存，减少了内存泄漏和指针错误的风险。
4. 强大的标准库
Java 拥有丰富的标准库，涵盖了数据结构、网络编程、数据库连接、GUI 开发等多个方面，极大地提高了开发效率。
三、Java 基础语法
1. 变量和数据类型
原始数据类型
Java 提供了八种原始数据类型：
- 数值型：byte、short、int、long、float、double
- 字符型：char
- 布尔型：boolean
每种类型都有固定的内存大小和取值范围。例如：
int age = 30;
double salary = 5000.50;
boolean isEmployed = true;
引用数据类型
包括类、接口、数组和枚举等。引用类型的变量存储对象的内存地址。
String name = "Alice";
int[] numbers = {1, 2, 3, 4, 5};
2. 运算符
- 算术运算符：
+、-、*、/、% - 赋值运算符：
=、+=、-=等 - 比较运算符：
==、!=、>、<、>=、<= - 逻辑运算符：
&&、||、!
示例：
int a = 10;
int b = 20;
int sum = a + b;
boolean isEqual = (a == b);
boolean logicalResult = (a > 5) && (b < 30);
3. 控制结构
条件语句
- if-else 语句
if (condition) {
// 当条件为真时执行
} else {
// 当条件为假时执行
}
- switch 语句
switch (variable) {
case value1:
// 代码块
break;
case value2:
// 代码块
break;
default:
// 默认代码块
}
循环语句
- for 循环
for (initialization; condition; update) {
// 循环体
}
- while 循环
while (condition) {
// 循环体
}
- do-while 循环
do {
// 循环体
} while (condition);
示例：打印 1 到 5 的数字
for (int i = 1; i <= 5; i++) {
System.out.println(i);
}
4. 数组
一维数组
- 声明和初始化
int[] numbers = new int[5];
int[] scores = {90, 85, 70, 95, 80};
- 遍历数组
for (int i = 0; i < scores.length; i++) {
System.out.println(scores[i]);
}
多维数组
- 声明和初始化
int[][] matrix = new int[3][3];
int[][] data = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
- 遍历多维数组
for (int i = 0; i < data.length; i++) {
for (int j = 0; j < data[i].length; j++) {
System.out.print(data[i][j] + " ");
}
System.out.println();
}
四、面向对象编程
1. 类和对象
- 类的定义
public class Person {
// 属性
private String name;
private int age;
// 构造方法
public Person(String name, int age) {
this.name = name;
this.age = age;
}
// 方法
public void introduce() {
System.out.println("大家好，我叫 " + name + "，今年 " + age + " 岁。");
}
}
- 对象的创建
Person person = new Person("Alice", 25);
person.introduce();
2. 封装
-
访问控制修饰符
public：对所有类可见。private：仅对本类可见。protected：对本类、同包内的类和子类可见。- 默认（不写）：对同包内的类可见。
-
getter 和 setter 方法
public class Person {
private String name;
private int age;
// Getter 方法
public String getName() {
return name;
}
// Setter 方法
public void setName(String name) {
this.name = name;
}
}
3. 继承
-
继承的概念
使用
extends关键字，子类继承父类的属性和方法。
public class Animal {
public void eat() {
System.out.println("动物在吃东西");
}
}
public class Dog extends Animal {
public void bark() {
System.out.println("狗在汪汪叫");
}
}
-
super 关键字
用于调用父类的构造方法或方法。
public class Dog extends Animal {
public Dog() {
super(); // 调用父类的构造方法
}
@Override
public void eat() {
super.eat(); // 调用父类的方法
System.out.println("狗在吃骨头");
}
}
4. 多态
-
方法重载
同一类中，方法名相同但参数列表不同。
public class Calculator {
public int add(int a, int b) {
return a + b;
}
public double add(double a, double b) {
return a + b;
}
}
-
方法重写
子类重新定义父类的方法，方法签名相同。
public class Animal {
public void makeSound() {
System.out.println("动物发出声音");
}
}
public class Cat extends Animal {
@Override
public void makeSound() {
System.out.println("猫在喵喵叫");
}
}
- 多态的应用
Animal animal = new Cat();
animal.makeSound(); // 输出：猫在喵喵叫
5. 接口和抽象类
-
接口
-
定义
public interface Movable { void move(); } -
实现
public class Car implements Movable { @Override public void move() { System.out.println("汽车在行驶"); } }
-
-
抽象类
-
public abstract class Shape {
public abstract double getArea();
}
-
继承
public class Circle extends Shape { private double radius; public Circle(double radius) { this.radius = radius; } @Override public double getArea() { return Math.PI * radius * radius; } }
-
-
接口与抽象类的区别
- 抽象类：可以包含具体方法和抽象方法，适用于具有共同特征的类。
- 接口：只包含抽象方法（Java 8 之后可以有默认方法和静态方法），强调实现类需要具备某种能力。
五、Java 内置类和库
1. 常用类
String 类
-
字符串的创建
String str = "Hello, World!";
-
常用方法
length()：获取字符串长度。charAt(int index)：获取指定位置的字符。substring(int beginIndex, int endIndex)：截取子字符串。equals(Object anObject)：比较字符串内容是否相同。
-
示例
String greeting = "Hello"; String name = "Alice"; String message = greeting + ", " + name + "!"; System.out.println(message); // 输出：Hello, Alice!
Math 类
-
常用方法
abs(double a)：绝对值。max(double a, double b)：最大值。min(double a, double b)：最小值。pow(double a, double b)：幂运算。sqrt(double a)：平方根。random()：返回 0.0 到 1.0 的随机数。
-
示例
double randomNumber = Math.random(); // 生成 0.0 到 1.0 之间的随机数 int max = Math.max(10, 20); // 20
2. 集合框架
List 接口
-
ArrayList
-
基于动态数组，适合随机访问。
-
示例
double randomNumber = Math.random(); // 生成 0.0 到 1.0 之间的随机数 int max = Math.max(10, 20); // 20
-
-
LinkedList
- 基于双向链表，适合频繁的插入和删除操作。
Set 接口
-
HashSet
- 不允许重复元素，元素无序。
-
TreeSet
- 元素有序，不允许重复，基于红黑树实现。
-
示例
Set<Integer> set = new HashSet<>(); set.add(1); set.add(2); set.add(1); // 重复元素，不会添加 System.out.println(set.size()); // 输出：2
Map 接口
-
HashMap
- 键值对存储，键不可重复，无序。
-
TreeMap
- 键值对按键排序，基于红黑树实现。
-
示例
Map<String, Integer> map = new HashMap<>(); map.put("Apple", 3); map.put("Banana", 2); System.out.println(map.get("Apple")); // 输出：3
3. Java 时间和日期 API
Java 8 引入了新的日期和时间 API，提供了更好的易用性和安全性。
-
LocalDate、LocalTime、LocalDateTime
-
获取当前日期和时间
LocalDate date = LocalDate.now(); LocalTime time = LocalTime.now(); LocalDateTime dateTime = LocalDateTime.now();
-
指定日期和时间
LocalDate specificDate = LocalDate.of(2021, 12, 31); LocalTime specificTime = LocalTime.of(23, 59, 59);
-
日期和时间操作
LocalDate tomorrow = date.plusDays(1); LocalTime nextHour = time.plusHours(1);
-
-
DateTimeFormatter
-
格式化日期和时间
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"); String formattedDateTime = dateTime.format(formatter); System.out.println(formattedDateTime); // 输出：2021-12-31 23:59:59
-
4. 文件 I/O 操作
File 类
用于表示文件或目录的信息。
File file = new File("test.txt");
if (file.exists()) {
System.out.println("文件存在");
}
BufferedReader 和 BufferedWriter
用于高效地读写文本文件。
-
读取文件
try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"))) { String line; while ((line = reader.readLine()) != null) { System.out.println(line); } } catch (IOException e) { e.printStackTrace(); } -
写入文件
try (BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"))) { writer.write("Hello, World!"); } catch (IOException e) { e.printStackTrace(); }
六、异常处理和日志记录
1. 异常的分类
-
检查异常（Checked Exception）
必须显式处理，如 IOException、SQLException。
-
运行时异常（Runtime Exception）
可以选择处理，如 NullPointerException、ArithmeticException。
-
错误（Error）
严重错误，通常不处理，如 OutOfMemoryError。
2. 异常处理机制
-
try-catch 语句
try { // 可能抛出异常的代码 } catch (ExceptionType name) { // 异常处理 } -
finally 块
无论是否发生异常，都会执行。
try { // 可能抛出异常的代码 } catch (ExceptionType name) { // 异常处理 } finally { // 清理操作 }
3. 自定义异常
public class MyCustomException extends Exception {
public MyCustomException(String message) {
super(message);
}
}
使用自定义异常
if (someCondition) {
throw new MyCustomException("发生了自定义异常");
}
4. 日志记录
-
使用日志框架
- Log4j、SLF4J、Logback 等是常用的日志框架。
-
示例
import org.slf4j.Logger; import org.slf4j.LoggerFactory; public class MyClass { private static final Logger logger = LoggerFactory.getLogger(MyClass.class); public void doSomething() { logger.info("开始执行方法"); try { // 业务逻辑 } catch (Exception e) { logger.error("发生异常", e); } } }
七、多线程和并发编程
1. 线程的创建
-
继承 Thread 类
public class MyThread extends Thread { @Override public void run() { // 线程执行的代码 } } MyThread thread = new MyThread(); thread.start(); -
实现 Runnable 接口
public class MyRunnable implements Runnable { @Override public void run() { // 线程执行的代码 } } Thread thread = new Thread(new MyRunnable()); thread.start();
2. 同步和锁
-
synchronized 关键字
public synchronized void method() { // 线程安全的代码 } -
锁机制
import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class MyClass { private Lock lock = new ReentrantLock(); public void method() { lock.lock(); try { // 线程安全的代码 } finally { lock.unlock(); } } }
3. 并发工具类
-
线程池
ExecutorService executor = Executors.newFixedThreadPool(10); executor.submit(new MyRunnable()); executor.shutdown();
-
同步工具
- CountDownLatch
- CyclicBarrier
- Semaphore
4. 常用并发类
-
ConcurrentHashMap
线程安全的 HashMap 实现。
-
CopyOnWriteArrayList
适用于读多写少的场景。
八、Java 新特性
1. Lambda 表达式
-
语法
(parameters) -> expression
(parameters) -> { statements; } -
示例
List<String> names = Arrays.asList("Alice", "Bob", "Charlie"); names.forEach(name -> System.out.println(name));-> System.out.println(name));
2. Stream API
-
创建流
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5); Stream<Integer> stream = numbers.stream();
-
中间操作
filter：过滤元素。map：元素映射。sorted：排序。
-
终止操作
forEach：遍历元素。collect：收集结果。reduce：聚合操作。
-
示例
int sum = numbers.stream()
.filter(n -> n % 2 == 0)
.mapToInt(n -> n)
.sum();
3. Optional 类
-
避免 NullPointerException
Optional<String> optional = Optional.ofNullable(getValue()); optional.ifPresent(value -> System.out.println(value));
4. 模块化系统（Java 9）
-
模块定义
module com.example.myapp { requires java.base; exports com.example.myapp.api; } -
优势
- 更好的封装性。
- 解决类冲突问题。
- 提高应用的可维护性。
总结
通过本篇指南，相信您已经对 Java 的学习路线有了全面的了解。Java 的世界广阔而丰富，从基础语法到高级特性，再到实际项目的开发，每一步都充满了挑战和乐趣。希望您在学习的过程中，保持热情，不断探索，最终成为一名优秀的 Java 开发者。
扫一扫
4850
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
