Java 核心概念

FreeGuideOnline 最新 2026-07-15

java int count = 10; double price = 99.99; char grade = 'A'; boolean isAvailable = true; String message = "Hello Java"; // String是引用类型


### 运算符

- **算术运算符**：`+`, `-`, `*`, `/`, `%`（取模）
- **关系运算符**：`>`, `<`, `>=`, `<=`, `==`, `!=`
- **逻辑运算符**：`&&`（逻辑与）, `||`（逻辑或）, `!`（逻辑非）
- **赋值运算符**：`=`, `+=`, `-=`, `*=`, `/=` 等
- **自增自减**：`++`（前/后）, `--`（前/后）
- **三元运算符**：`条件 ? 表达式1 : 表达式2`

### 控制流程

#### 条件语句
- **if-else**
```java
if (score >= 90) {
    grade = 'A';
} else if (score >= 80) {
    grade = 'B';
} else {
    grade = 'C';
}
  • switch（支持 int、char、String、枚举）
switch (day) {
    case "MON": System.out.println("星期一"); break;
    default: System.out.println("其他");
}

循环语句

  • for 循环
for (int i = 0; i < 5; i++) {
    System.out.println(i);
}
  • 增强 for 循环（foreach）
int[] numbers = {1, 2, 3};
for (int num : numbers) {
    System.out.println(num);
}
  • while 循环 与 do-while 循环

跳转语句

  • break：结束当前循环。
  • continue：跳过本次循环剩余语句，进入下一次迭代。
  • return：退出方法并返回值。

面向对象编程（OOP）核心

Java 中一切代码都定义在类（class）中，OOP 是其灵魂。

类与对象

类是对象的蓝图，对象是类的一个实例。

// 定义一个类
public class Dog {
    String breed;    // 属性（成员变量）
    int age;

    // 方法（行为）
    void bark() {
        System.out.println("汪！");
    }
}

// 创建对象
Dog myDog = new Dog();
myDog.breed = "金毛";
myDog.bark();

封装

封装是指将数据（属性）和操作数据的方法绑定在一起，并隐藏内部实现细节，仅对外暴露必要的接口。实现方式：

  • 使用 private 修饰属性
  • 提供 public 的 getter/setter 方法
public class Person {
    private int age;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age >= 0) this.age = age;
    }
}

继承

子类可以继承父类的属性和方法，实现代码复用和层次结构。使用 extends 关键字，Java 只支持单继承。

public class Animal {
    public void eat() { System.out.println("吃东西"); }
}

public class Cat extends Animal {
    public void meow() { System.out.println("喵"); }
}
// Cat 对象同时拥有 eat() 和 meow()

多态

多态是指同一个方法调用，作用于不同对象时表现出不同的行为。主要通过方法重写和父类引用指向子类对象实现。

Animal a = new Cat();
a.eat();   // 调用 Cat 中重写的 eat()
  • 编译时多态：方法重载（相同方法名，不同参数列表）
  • 运行时多态：方法重写（子类覆盖父类方法）

抽象类与接口

抽象类用 abstract 修饰，可以包含抽象方法（无方法体）和具体方法。它不能被实例化，用于被继承。

public abstract class Shape {
    abstract double area();
}

接口用 interface 声明，是更纯粹的抽象约定。Java 8 后允许 default 方法和静态方法。一个类可以实现多个接口，弥补了单继承的限制。

public interface Flyable {
    void fly();   // 默认 public abstract
}
public class Bird implements Flyable {
    public void fly() { System.out.println("飞行"); }
}

区别：抽象类强调“是什么”（is-a），接口强调“能做什么”（can-do）。

异常处理

异常是程序运行时发生的不正常事件。Java 通过 try-catch-finally 结构捕获和处理异常。

try {
    int result = 10 / 0;   // 可能抛出 ArithmeticException
} catch (ArithmeticException e) {
    System.out.println("除数不能为零");
} finally {
    System.out.println("无论是否异常都会执行");
}

关键字：

  • throw：手动抛出异常对象。
  • throws：声明方法可能抛出的异常类型。
  • 检查型异常必须在编译时处理（try-catch或throws），非检查型异常（RuntimeException）不强制。

集合框架基础

Java 集合框架提供了一组接口和类，用于存储和操作数据组。

List — 有序、可重复

  • ArrayList：基于动态数组，查询快，增删较慢。
  • LinkedList：基于双向链表，增删快，查询慢。
List<String> list = new ArrayList<>();
list.add("Java");

Set — 无序、不可重复

  • HashSet：基于哈希表，元素无序。
  • TreeSet：基于红黑树，元素排序。
Set<Integer> set = new HashSet<>();
set.add(1);

Map — 键值对

  • HashMap：键值对存储，键不可重复。
  • TreeMap：按键排序。
Map<String, Integer> map = new HashMap<>();
map.put("key", 100);

泛型与枚举

泛型：允许在定义类、接口、方法时使用类型参数，增强代码复用性和类型安全。

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<>();

枚举：一种特殊的类，用于定义一组固定常量，可包含方法和属性。

public enum Color {
    RED, GREEN, BLUE;
}

输入输出（I/O）基础

Java I/O 主要通过 java.io 包中的流实现。

  • 字节流：InputStream / OutputStream
  • 字符流：Reader / Writer

读取文件示例（字符流）：

try (BufferedReader br = new BufferedReader(new FileReader("test.txt"))) {
    String line;
    while ((line = br.readLine()) != null) {
        System.out.println(line);
    }
} catch (IOException e) {
    e.printStackTrace();
}

多线程初步

多线程允许程序并发执行多个任务。Java 提供了 Thread 类和 Runnable 接口。

class MyTask implements Runnable {
    public void run() {
        System.out.println("线程运行中");
    }
}
Thread t = new Thread(new MyTask());
t.start();

关键概念：同步（synchronized）、锁、线程池（ExecutorService）等。

Java 新特性概览（8+）

  • Lambda 表达式：简化函数式接口的实例化。
List<String> names = Arrays.asList("a", "b");
names.forEach(s -> System.out.println(s));
  • Stream API：对集合进行声明式处理（映射、过滤、归约）。
int sum = list.stream().filter(n -> n > 0).mapToInt(Integer::intValue).sum();