544 lines
9.9 KiB
Markdown
544 lines
9.9 KiB
Markdown
# Java基础
|
||
|
||
## 目录
|
||
- [面向对象编程](#面向对象编程)
|
||
- [集合框架](#集合框架)
|
||
- [异常处理](#异常处理)
|
||
- [泛型](#泛型)
|
||
- [反射](#反射)
|
||
- [注解](#注解)
|
||
- [多线程基础](#多线程基础)
|
||
- [IO流](#io流)
|
||
- [JVM基础](#jvm基础)
|
||
- [面试常见问题](#面试常见问题)
|
||
|
||
---
|
||
|
||
## 面向对象编程
|
||
|
||
### 三大特性
|
||
|
||
#### 1. 封装
|
||
|
||
```java
|
||
// 封装：隐藏内部实现，提供公共接口
|
||
public class User {
|
||
private String name; // 私有属性
|
||
private int age;
|
||
|
||
// 公共方法访问私有属性
|
||
public String getName() {
|
||
return name;
|
||
}
|
||
|
||
public void setName(String name) {
|
||
this.name = name;
|
||
}
|
||
}
|
||
```
|
||
|
||
#### 2. 继承
|
||
|
||
```java
|
||
// 继承：子类继承父类的属性和方法
|
||
public class Animal {
|
||
protected String name;
|
||
|
||
public void eat() {
|
||
System.out.println("Animal is eating");
|
||
}
|
||
}
|
||
|
||
public class Dog extends Animal {
|
||
public void bark() {
|
||
System.out.println("Dog is barking");
|
||
}
|
||
|
||
@Override
|
||
public void eat() {
|
||
System.out.println("Dog is eating");
|
||
}
|
||
}
|
||
```
|
||
|
||
#### 3. 多态
|
||
|
||
```java
|
||
// 多态：同一接口，不同实现
|
||
Animal animal1 = new Dog();
|
||
Animal animal2 = new Cat();
|
||
animal1.eat(); // 调用 Dog 的 eat 方法
|
||
animal2.eat(); // 调用 Cat 的 eat 方法
|
||
```
|
||
|
||
### 抽象类和接口
|
||
|
||
```java
|
||
// 抽象类：可以有抽象方法和具体方法
|
||
public abstract class Animal {
|
||
public abstract void makeSound();
|
||
|
||
public void sleep() {
|
||
System.out.println("Animal is sleeping");
|
||
}
|
||
}
|
||
|
||
// 接口：只有抽象方法（Java 8+ 可以有默认方法）
|
||
public interface Flyable {
|
||
void fly();
|
||
|
||
default void land() {
|
||
System.out.println("Landing");
|
||
}
|
||
}
|
||
```
|
||
|
||
---
|
||
|
||
## 集合框架
|
||
|
||
### List
|
||
|
||
```java
|
||
// ArrayList：动态数组
|
||
List<String> list = new ArrayList<>();
|
||
list.add("A");
|
||
list.add("B");
|
||
list.get(0); // "A"
|
||
|
||
// LinkedList：双向链表
|
||
List<String> linkedList = new LinkedList<>();
|
||
linkedList.add("A");
|
||
linkedList.addFirst("B");
|
||
```
|
||
|
||
### Set
|
||
|
||
```java
|
||
// HashSet：无序，不重复
|
||
Set<String> set = new HashSet<>();
|
||
set.add("A");
|
||
set.add("B");
|
||
set.add("A"); // 重复，不会添加
|
||
|
||
// TreeSet：有序，不重复
|
||
Set<String> treeSet = new TreeSet<>();
|
||
treeSet.add("C");
|
||
treeSet.add("A");
|
||
treeSet.add("B");
|
||
// 输出：A, B, C
|
||
```
|
||
|
||
### Map
|
||
|
||
```java
|
||
// HashMap：键值对，无序
|
||
Map<String, Integer> map = new HashMap<>();
|
||
map.put("A", 1);
|
||
map.put("B", 2);
|
||
map.get("A"); // 1
|
||
|
||
// TreeMap：键值对，有序
|
||
Map<String, Integer> treeMap = new TreeMap<>();
|
||
treeMap.put("C", 3);
|
||
treeMap.put("A", 1);
|
||
treeMap.put("B", 2);
|
||
// 按键排序：A, B, C
|
||
```
|
||
|
||
### 集合遍历
|
||
|
||
```java
|
||
// for-each 循环
|
||
for (String item : list) {
|
||
System.out.println(item);
|
||
}
|
||
|
||
// Iterator
|
||
Iterator<String> iterator = list.iterator();
|
||
while (iterator.hasNext()) {
|
||
String item = iterator.next();
|
||
System.out.println(item);
|
||
}
|
||
|
||
// Stream API（Java 8+）
|
||
list.stream()
|
||
.filter(s -> s.startsWith("A"))
|
||
.forEach(System.out::println);
|
||
```
|
||
|
||
---
|
||
|
||
## 异常处理
|
||
|
||
### 异常类型
|
||
|
||
```java
|
||
// Throwable
|
||
// ├── Error（错误，不可恢复）
|
||
// └── Exception（异常，可恢复）
|
||
// ├── RuntimeException（运行时异常）
|
||
// └── CheckedException（检查异常）
|
||
|
||
// RuntimeException：不需要捕获
|
||
int[] arr = new int[5];
|
||
int value = arr[10]; // ArrayIndexOutOfBoundsException
|
||
|
||
// CheckedException：必须捕获或声明
|
||
try {
|
||
FileInputStream fis = new FileInputStream("file.txt");
|
||
} catch (FileNotFoundException e) {
|
||
e.printStackTrace();
|
||
}
|
||
```
|
||
|
||
### 异常处理
|
||
|
||
```java
|
||
// try-catch-finally
|
||
try {
|
||
// 可能抛出异常的代码
|
||
int result = 10 / 0;
|
||
} catch (ArithmeticException e) {
|
||
// 处理异常
|
||
System.out.println("除零错误");
|
||
} catch (Exception e) {
|
||
// 处理其他异常
|
||
e.printStackTrace();
|
||
} finally {
|
||
// 无论是否异常都会执行
|
||
System.out.println("清理资源");
|
||
}
|
||
|
||
// try-with-resources（Java 7+）
|
||
try (FileInputStream fis = new FileInputStream("file.txt")) {
|
||
// 使用资源
|
||
} catch (IOException e) {
|
||
e.printStackTrace();
|
||
} // 自动关闭资源
|
||
```
|
||
|
||
### 自定义异常
|
||
|
||
```java
|
||
// 自定义异常
|
||
public class CustomException extends Exception {
|
||
public CustomException(String message) {
|
||
super(message);
|
||
}
|
||
}
|
||
|
||
// 使用
|
||
public void method() throws CustomException {
|
||
throw new CustomException("自定义异常");
|
||
}
|
||
```
|
||
|
||
---
|
||
|
||
## 泛型
|
||
|
||
### 泛型类
|
||
|
||
```java
|
||
// 泛型类
|
||
public class Box<T> {
|
||
private T item;
|
||
|
||
public void setItem(T item) {
|
||
this.item = item;
|
||
}
|
||
|
||
public T getItem() {
|
||
return item;
|
||
}
|
||
}
|
||
|
||
// 使用
|
||
Box<String> stringBox = new Box<>();
|
||
stringBox.setItem("Hello");
|
||
String value = stringBox.getItem();
|
||
```
|
||
|
||
### 泛型方法
|
||
|
||
```java
|
||
// 泛型方法
|
||
public <T> T getValue(T value) {
|
||
return value;
|
||
}
|
||
|
||
// 使用
|
||
String str = getValue("Hello");
|
||
Integer num = getValue(123);
|
||
```
|
||
|
||
### 通配符
|
||
|
||
```java
|
||
// 上界通配符：? extends T
|
||
List<? extends Number> list1; // 可以是 Number 及其子类
|
||
|
||
// 下界通配符：? super T
|
||
List<? super Integer> list2; // 可以是 Integer 及其父类
|
||
|
||
// 无界通配符：?
|
||
List<?> list3; // 可以是任何类型
|
||
```
|
||
|
||
---
|
||
|
||
## 反射
|
||
|
||
### 获取 Class 对象
|
||
|
||
```java
|
||
// 方式1：通过类名
|
||
Class<?> clazz = String.class;
|
||
|
||
// 方式2：通过对象
|
||
String str = "Hello";
|
||
Class<?> clazz2 = str.getClass();
|
||
|
||
// 方式3：通过类名字符串
|
||
Class<?> clazz3 = Class.forName("java.lang.String");
|
||
```
|
||
|
||
### 反射操作
|
||
|
||
```java
|
||
// 创建对象
|
||
Class<?> clazz = User.class;
|
||
User user = (User) clazz.newInstance();
|
||
|
||
// 获取字段
|
||
Field field = clazz.getDeclaredField("name");
|
||
field.setAccessible(true);
|
||
field.set(user, "John");
|
||
|
||
// 获取方法
|
||
Method method = clazz.getMethod("getName");
|
||
String name = (String) method.invoke(user);
|
||
|
||
// 获取构造函数
|
||
Constructor<?> constructor = clazz.getConstructor(String.class);
|
||
User user2 = (User) constructor.newInstance("John");
|
||
```
|
||
|
||
---
|
||
|
||
## 注解
|
||
|
||
### 内置注解
|
||
|
||
```java
|
||
// @Override：重写方法
|
||
@Override
|
||
public void method() { }
|
||
|
||
// @Deprecated：已废弃
|
||
@Deprecated
|
||
public void oldMethod() { }
|
||
|
||
// @SuppressWarnings：抑制警告
|
||
@SuppressWarnings("unchecked")
|
||
public void method() { }
|
||
```
|
||
|
||
### 自定义注解
|
||
|
||
```java
|
||
// 定义注解
|
||
@Target(ElementType.METHOD)
|
||
@Retention(RetentionPolicy.RUNTIME)
|
||
public @interface MyAnnotation {
|
||
String value() default "";
|
||
int count() default 0;
|
||
}
|
||
|
||
// 使用注解
|
||
@MyAnnotation(value = "test", count = 5)
|
||
public void method() { }
|
||
|
||
// 读取注解
|
||
Method method = MyClass.class.getMethod("method");
|
||
MyAnnotation annotation = method.getAnnotation(MyAnnotation.class);
|
||
String value = annotation.value();
|
||
```
|
||
|
||
---
|
||
|
||
## 多线程基础
|
||
|
||
### 创建线程
|
||
|
||
```java
|
||
// 方式1：继承 Thread
|
||
public class MyThread extends Thread {
|
||
@Override
|
||
public void run() {
|
||
System.out.println("Thread running");
|
||
}
|
||
}
|
||
MyThread thread = new MyThread();
|
||
thread.start();
|
||
|
||
// 方式2：实现 Runnable
|
||
public class MyRunnable implements Runnable {
|
||
@Override
|
||
public void run() {
|
||
System.out.println("Thread running");
|
||
}
|
||
}
|
||
Thread thread2 = new Thread(new MyRunnable());
|
||
thread2.start();
|
||
|
||
// 方式3：Lambda 表达式
|
||
Thread thread3 = new Thread(() -> {
|
||
System.out.println("Thread running");
|
||
});
|
||
thread3.start();
|
||
```
|
||
|
||
### 线程同步
|
||
|
||
```java
|
||
// synchronized 关键字
|
||
public class Counter {
|
||
private int count = 0;
|
||
|
||
public synchronized void increment() {
|
||
count++;
|
||
}
|
||
}
|
||
|
||
// Lock
|
||
private Lock lock = new ReentrantLock();
|
||
|
||
public void method() {
|
||
lock.lock();
|
||
try {
|
||
// 临界区代码
|
||
} finally {
|
||
lock.unlock();
|
||
}
|
||
}
|
||
```
|
||
|
||
---
|
||
|
||
## IO流
|
||
|
||
### 字节流
|
||
|
||
```java
|
||
// FileInputStream / FileOutputStream
|
||
try (FileInputStream fis = new FileInputStream("input.txt");
|
||
FileOutputStream fos = new FileOutputStream("output.txt")) {
|
||
int data;
|
||
while ((data = fis.read()) != -1) {
|
||
fos.write(data);
|
||
}
|
||
}
|
||
```
|
||
|
||
### 字符流
|
||
|
||
```java
|
||
// FileReader / FileWriter
|
||
try (FileReader fr = new FileReader("input.txt");
|
||
FileWriter fw = new FileWriter("output.txt")) {
|
||
int data;
|
||
while ((data = fr.read()) != -1) {
|
||
fw.write(data);
|
||
}
|
||
}
|
||
```
|
||
|
||
### 缓冲流
|
||
|
||
```java
|
||
// BufferedInputStream / BufferedOutputStream
|
||
try (BufferedInputStream bis = new BufferedInputStream(
|
||
new FileInputStream("input.txt"));
|
||
BufferedOutputStream bos = new BufferedOutputStream(
|
||
new FileOutputStream("output.txt"))) {
|
||
int data;
|
||
while ((data = bis.read()) != -1) {
|
||
bos.write(data);
|
||
}
|
||
}
|
||
```
|
||
|
||
---
|
||
|
||
## JVM基础
|
||
|
||
### 内存区域
|
||
|
||
```java
|
||
// JVM 内存区域
|
||
// 1. 程序计数器：当前执行指令的地址
|
||
// 2. 虚拟机栈：方法执行时的栈帧
|
||
// 3. 本地方法栈：Native 方法执行
|
||
// 4. 堆：对象实例
|
||
// 5. 方法区：类信息、常量、静态变量
|
||
```
|
||
|
||
### 垃圾回收
|
||
|
||
```java
|
||
// GC 算法
|
||
// 1. 标记-清除
|
||
// 2. 标记-复制
|
||
// 3. 标记-整理
|
||
// 4. 分代收集
|
||
|
||
// GC 类型
|
||
// - Minor GC：新生代回收
|
||
// - Major GC：老年代回收
|
||
// - Full GC：整个堆回收
|
||
```
|
||
|
||
---
|
||
|
||
## 面试常见问题
|
||
|
||
### Q1: Java 三大特性？
|
||
|
||
**答案：**
|
||
1. **封装**：隐藏内部实现，提供公共接口
|
||
2. **继承**：子类继承父类的属性和方法
|
||
3. **多态**：同一接口，不同实现
|
||
|
||
### Q2: ArrayList 和 LinkedList 的区别？
|
||
|
||
**答案：**
|
||
- **ArrayList**：基于数组，随机访问快，插入删除慢
|
||
- **LinkedList**：基于链表，随机访问慢，插入删除快
|
||
|
||
### Q3: HashMap 的实现原理？
|
||
|
||
**答案：**
|
||
- 基于数组和链表（Java 8+ 使用红黑树）
|
||
- 通过 hashCode 计算数组索引
|
||
- 解决冲突使用链表或红黑树
|
||
|
||
### Q4: 异常处理的机制？
|
||
|
||
**答案：**
|
||
- **try-catch-finally**：捕获和处理异常
|
||
- **throws**：声明可能抛出的异常
|
||
- **throw**：抛出异常
|
||
|
||
### Q5: 泛型的作用？
|
||
|
||
**答案：**
|
||
1. 类型安全：编译时检查类型
|
||
2. 消除强制转换
|
||
3. 提高代码可读性
|
||
|
||
---
|
||
|
||
*最后更新：2024年*
|