admin/mkdocs

Fork 0

Files

renjianbo c7b3e9744d 鏇存柊鏂囨。

2026-01-15 11:53:37 +08:00

9.9 KiB

Raw Permalink Blame History

Java基础

面向对象编程

三大特性

1. 封装

// 封装：隐藏内部实现，提供公共接口
public class User {
    private String name;  // 私有属性
    private int age;
    
    // 公共方法访问私有属性
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
}

2. 继承

// 继承：子类继承父类的属性和方法
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. 多态

// 多态：同一接口，不同实现
Animal animal1 = new Dog();
Animal animal2 = new Cat();
animal1.eat(); // 调用 Dog 的 eat 方法
animal2.eat(); // 调用 Cat 的 eat 方法

抽象类和接口

// 抽象类：可以有抽象方法和具体方法
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

// 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

// 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

// 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

集合遍历

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

异常处理

异常类型

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

异常处理

// 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();
} // 自动关闭资源

自定义异常

// 自定义异常
public class CustomException extends Exception {
    public CustomException(String message) {
        super(message);
    }
}

// 使用
public void method() throws CustomException {
    throw new CustomException("自定义异常");
}

泛型

泛型类

// 泛型类
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();

泛型方法

// 泛型方法
public <T> T getValue(T value) {
    return value;
}

// 使用
String str = getValue("Hello");
Integer num = getValue(123);

通配符

// 上界通配符：? extends T
List<? extends Number> list1; // 可以是 Number 及其子类

// 下界通配符：? super T
List<? super Integer> list2; // 可以是 Integer 及其父类

// 无界通配符：?
List<?> list3; // 可以是任何类型

反射

获取 Class 对象

// 方式1：通过类名
Class<?> clazz = String.class;

// 方式2：通过对象
String str = "Hello";
Class<?> clazz2 = str.getClass();

// 方式3：通过类名字符串
Class<?> clazz3 = Class.forName("java.lang.String");

反射操作

// 创建对象
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");

注解

内置注解

// @Override：重写方法
@Override
public void method() { }

// @Deprecated：已废弃
@Deprecated
public void oldMethod() { }

// @SuppressWarnings：抑制警告
@SuppressWarnings("unchecked")
public void method() { }

自定义注解

// 定义注解
@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();

多线程基础

创建线程

// 方式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();

线程同步

// 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流

字节流

// 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);
    }
}

字符流

// 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);
    }
}

缓冲流

// 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基础

内存区域

// JVM 内存区域
// 1. 程序计数器：当前执行指令的地址
// 2. 虚拟机栈：方法执行时的栈帧
// 3. 本地方法栈：Native 方法执行
// 4. 堆：对象实例
// 5. 方法区：类信息、常量、静态变量

垃圾回收

// GC 算法
// 1. 标记-清除
// 2. 标记-复制
// 3. 标记-整理
// 4. 分代收集

// GC 类型
// - Minor GC：新生代回收
// - Major GC：老年代回收
// - Full GC：整个堆回收

面试常见问题

Q1: Java 三大特性？

答案：

封装：隐藏内部实现，提供公共接口
继承：子类继承父类的属性和方法
多态：同一接口，不同实现

Q2: ArrayList 和 LinkedList 的区别？

答案：

ArrayList：基于数组，随机访问快，插入删除慢
LinkedList：基于链表，随机访问慢，插入删除快

Q3: HashMap 的实现原理？

答案：

基于数组和链表（Java 8+ 使用红黑树）
通过 hashCode 计算数组索引
解决冲突使用链表或红黑树

Q4: 异常处理的机制？

答案：

try-catch-finally：捕获和处理异常
throws：声明可能抛出的异常
throw：抛出异常

Q5: 泛型的作用？

答案：

类型安全：编译时检查类型
消除强制转换
提高代码可读性

最后更新：2024年

9.9 KiB Raw Permalink Blame History Unescape Escape

Java基础

目录

面向对象编程

三大特性

1. 封装

2. 继承

3. 多态

抽象类和接口

集合框架

List

Set

Map

集合遍历

异常处理

异常类型

异常处理

自定义异常

泛型

泛型类

泛型方法

通配符

反射

获取 Class 对象

反射操作

注解

内置注解

自定义注解

多线程基础

创建线程

线程同步

IO流

字节流

字符流

缓冲流

JVM基础

内存区域

垃圾回收

面试常见问题

Q1: Java 三大特性？

Q2: ArrayList 和 LinkedList 的区别？

Q3: HashMap 的实现原理？

Q4: 异常处理的机制？

Q5: 泛型的作用？

9.9 KiB

Raw Permalink Blame History