Java知识点汇总

前言

这里只是简单列出Java语言的知识点

---

一、基础语法

1.1 程序结构

// 类声明
public class Main {
    // 主方法 - 程序入口
    public static void main(String[] args) {
        System.out.println("Hello World!"); // 输出语句
    }
}

1.2 数据类型

类型	说明	示例
byte	8位整数	byte b = 100;
short	16位整数	short s = 1000;
int	32位整数	int i = 100000;
long	64位整数	long l = 100000L;
float	32位浮点	float f = 3.14f;
double	64位浮点	double d = 3.14159;
char	16位Unicode	char c = 'A';
boolean	布尔值	boolean flag = true;
String	字符串(类)	String str = "Java";

1.3 变量与常量

int count = 10;          // 变量
final double PI = 3.14;    // 常量
var list = new ArrayList<String>(); // 局部变量类型推断(Java 10+)

---

二、运算符

2.1 算术运算符

+ - * / % ++ --

2.2 关系运算符

== != > < >= <=

2.3 逻辑运算符

&& || !

2.4 位运算符

& | ^ ~ << >> >>>

2.5 赋值运算符

= += -= *= /= %= &= |= ^= <<= >>= >>>=

2.6 三目运算符

condition ? expr1 : expr2

2.7 instanceof 运算符

obj instanceof String

---

三、流程控制

3.1 条件语句

if (condition) {
    // ...
} else if (condition2) {
    // ...
} else {
    // ...
}

switch (variable) {
    case 1: 
        // ...
        break;
    default:
        // ...
}

3.2 循环结构

// for循环
for (int i = 0; i < 10; i++) { /*...*/ }

// 增强for循环
for (String item : collection) { /*...*/ }

// while循环
while (condition) { /*...*/ }

// do-while循环
do { /*...*/ } while (condition);

---

四、方法与函数

4.1 方法定义

[修饰符] 返回类型 方法名(参数列表) {
    // 方法体
    return 返回值;
}

4.2 方法重载

void print(int i) { /*...*/ }
void print(String s) { /*...*/ }

4.3 可变参数

void method(String... args) { /*...*/ }

4.4 Lambda表达式(Java 8+)

Function<Integer, Integer> square = x -> x * x;

---

五、面向对象编程

5.1 类与对象

public class Person {
    // 字段
    private String name;
    
    // 构造方法
    public Person(String name) {
        this.name = name;
    }
    
    // 方法
    public String getName() {
        return name;
    }
}

5.2 继承

class Student extends Person {
    // ...
}

5.3 多态

interface Animal {
    void sound();
}

class Dog implements Animal {
    public void sound() { System.out.println("Woof"); }
}

5.4 抽象类与接口

abstract class Shape {
    abstract void draw();
}

interface Drawable {
    void draw();
}

---

六、异常处理

6.1 try-catch-finally

try {
    // 可能抛出异常的代码
} catch (IOException e) {
    // 异常处理
} finally {
    // 最终执行的代码
}

6.2 throws声明

void readFile() throws IOException { /*...*/ }

6.3 自定义异常

class MyException extends Exception {
    // ...
}

---

七、集合框架

7.1 主要接口

List<String> list = new ArrayList<>();  // 有序可重复
Set<Integer> set = new HashSet<>();    // 无序唯一
Map<String, Integer> map = new HashMap<>(); // 键值对

7.2 常用操作

list.add("Java");          // 添加元素
set.contains(5);          // 检查存在
map.put("key", 10);       // 放入键值

7.3 流式操作(Java 8+)

list.stream()
    .filter(s -> s.length() > 3)
    .map(String::toUpperCase)
    .forEach(System.out::println);

---

八、输入输出

8.1 文件读写

try (BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {
    String line;
    while ((line = br.readLine()) != null) {
        System.out.println(line);
    }
}

8.2 标准I/O

Scanner sc = new Scanner(System.in);
String input = sc.nextLine();

九、多线程

9.1 线程创建

// 继承Thread类
class MyThread extends Thread {
    public void run() { /*...*/ }
}

// 实现Runnable接口
Runnable task = () -> { /*...*/ };
new Thread(task).start();

9.2 线程池

ExecutorService executor = Executors.newFixedThreadPool(5);
executor.submit(() -> System.out.println("Task running"));

9.3 同步机制

synchronized (lockObject) {
    // 同步代码块
}

---

十、现代Java特性

10.1 记录类(Java 16+)

record Point(int x, int y) { }

10.2 模式匹配(Java 17+)

if (obj instanceof String s) {
    System.out.println(s.length());
}

10.3 密封类(Java 17+)

sealed class Shape permits Circle, Square { }

---

十一、注解与反射

11.1 内置注解

@Override
@Deprecated
@SuppressWarnings("unchecked")

11.2 自定义注解

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
    String value() default "";
}

11.3 反射API

Class<?> clazz = Class.forName("java.lang.String");
Method method = clazz.getMethod("length");

---

十二、模块系统(Java 9+)

12.1 模块声明

module com.example.myapp {
    requires java.base;
    exports com.example.mypackage;
}

---

十三、最佳实践

1. 遵循命名规范(驼峰命名法)
2. 使用面向接口编程
3. 优先使用集合框架而非数组
4. 合理使用异常处理机制
5. 避免使用原始类型(优先泛型)
6. 使用try-with-resources管理资源
7. 遵循SOLID设计原则
8. 使用不可变对象提高线程安全性
9. 合理使用Optional避免NullPointerException
10. 保持代码可读性和可维护性
    注：本文档涵盖Java 8到Java 17的主要语法特性，实际使用时需注意JDK版本支持情况。

---