1. Java基础核心知识点概述
Java作为一门面向对象的编程语言，其基础核心知识点构成了整个Java生态系统的基石。对于初学者而言，掌握这些基础概念不仅能帮助快速上手Java开发，更能为后续学习框架和高级特性打下坚实基础。本文将系统梳理Java最核心的基础知识点，包括数据类型、面向对象特性、集合框架等，并结合实际代码示例讲解其应用场景。
2. Java基础语法解析
2.1 数据类型与变量
Java是强类型语言，所有变量都必须先声明后使用。基本数据类型包括：
- 整型：byte(1字节)、short(2字节)、int(4字节)、long(8字节)
- 浮点型：float(4字节)、double(8字节)
- 字符型：char(2字节)
- 布尔型：boolean(1位)
引用数据类型包括类、接口、数组等。变量声明示例：
java复制int count = 10; // 基本类型
String name = "Java"; // 引用类型
注意：Java中基本类型存储在栈内存，而引用类型的对象存储在堆内存，变量本身存储的是引用地址。
2.2 运算符与表达式
Java支持丰富的运算符：
- 算术运算符：+、-、*、/、%
- 关系运算符：>、<、>=、<=、==、!=
- 逻辑运算符：&&、||、!
- 位运算符：&、|、^、~、<<、>>、>>>
运算符优先级决定了表达式的计算顺序，可以使用括号改变默认优先级。示例：
java复制int result = (10 + 5) * 2; // 结果为30
3. 面向对象编程核心
3.1 类与对象
类是对象的模板，对象是类的实例。定义类的基本语法：
java复制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 + "岁");
}
}
创建对象并调用方法：
java复制Person p = new Person("张三", 25);
p.introduce();
3.2 封装、继承与多态
封装：通过访问修饰符(private/protected/public)控制对类成员的访问
java复制public class Animal {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
继承：子类继承父类的属性和方法
java复制public class Dog extends Animal {
public void bark() {
System.out.println(getName() + "在汪汪叫");
}
}
多态：同一方法在不同子类中有不同实现
java复制Animal a = new Dog();
a.makeSound(); // 实际调用Dog类的实现
4. 集合框架详解
4.1 List接口及其实现
List是有序集合，允许重复元素。常用实现类：
- ArrayList：基于动态数组，随机访问快
- LinkedList：基于链表，插入删除快
示例代码：
java复制List<String> list = new ArrayList<>();
list.add("Java");
list.add("Python");
list.get(0); // 访问第一个元素
4.2 Set接口及其实现
Set是不允许重复元素的集合。常用实现类：
- HashSet：基于哈希表，无序
- TreeSet：基于红黑树，有序
示例代码：
java复制Set<Integer> set = new HashSet<>();
set.add(1);
set.add(2);
set.add(1); // 重复元素不会被添加
4.3 Map接口及其实现
Map存储键值对，键不能重复。常用实现类：
- HashMap：基于哈希表
- TreeMap：基于红黑树
示例代码：
java复制Map<String, Integer> map = new HashMap<>();
map.put("Java", 1995);
map.put("Python", 1991);
map.get("Java"); // 获取键对应的值
5. 异常处理机制
5.1 异常分类
Java异常分为：
- 检查型异常(Checked Exception)：必须处理，如IOException
- 非检查型异常(Unchecked Exception)：RuntimeException及其子类
- 错误(Error)：系统级错误，如OutOfMemoryError
5.2 try-catch-finally
基本异常处理结构：
java复制try {
// 可能抛出异常的代码
FileInputStream fis = new FileInputStream("test.txt");
} catch (FileNotFoundException e) {
// 异常处理
System.out.println("文件未找到");
} finally {
// 无论是否发生异常都会执行
System.out.println("清理资源");
}
5.3 自定义异常
可以创建自己的异常类：
java复制public class MyException extends Exception {
public MyException(String message) {
super(message);
}
}
// 使用自定义异常
throw new MyException("自定义异常信息");
6. 输入输出流
6.1 字节流与字符流
Java I/O分为：
- 字节流：InputStream/OutputStream
- 字符流：Reader/Writer
文件读写示例：
java复制// 字节流读写
try (FileInputStream fis = new FileInputStream("input.txt");
FileOutputStream fos = new FileOutputStream("output.txt")) {
int data;
while ((data = fis.read()) != -1) {
fos.write(data);
}
}
// 字符流读写
try (BufferedReader br = new BufferedReader(new FileReader("input.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"))) {
String line;
while ((line = br.readLine()) != null) {
bw.write(line);
bw.newLine();
}
}
6.2 序列化与反序列化
Java对象可以序列化为字节流：
java复制public class Student implements Serializable {
private String name;
private int age;
// getters and setters
}
// 序列化
try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("student.dat"))) {
oos.writeObject(new Student("张三", 20));
}
// 反序列化
try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("student.dat"))) {
Student s = (Student) ois.readObject();
}
7. 多线程编程
7.1 线程创建方式
创建线程的三种方式：
- 继承Thread类
java复制class MyThread extends Thread {
public void run() {
System.out.println("线程运行");
}
}
new MyThread().start();
- 实现Runnable接口
java复制class MyRunnable implements Runnable {
public void run() {
System.out.println("线程运行");
}
}
new Thread(new MyRunnable()).start();
- 使用Callable和Future
java复制ExecutorService executor = Executors.newSingleThreadExecutor();
Future<Integer> future = executor.submit(() -> {
return 123;
});
Integer result = future.get();
executor.shutdown();
7.2 线程同步
使用synchronized实现线程同步：
java复制class Counter {
private int count = 0;
public synchronized void increment() {
count++;
}
public synchronized int getCount() {
return count;
}
}
使用Lock接口：
java复制class Counter {
private final Lock lock = new ReentrantLock();
private int count = 0;
public void increment() {
lock.lock();
try {
count++;
} finally {
lock.unlock();
}
}
}
8. 反射机制
8.1 获取Class对象
三种获取Class对象的方式：
java复制Class<?> clazz1 = Class.forName("java.lang.String");
Class<?> clazz2 = String.class;
Class<?> clazz3 = "".getClass();
8.2 反射操作
通过反射创建对象、调用方法：
java复制Class<?> clazz = Class.forName("com.example.Person");
Constructor<?> constructor = clazz.getConstructor(String.class, int.class);
Object obj = constructor.newInstance("张三", 25);
Method method = clazz.getMethod("introduce");
method.invoke(obj);
访问私有成员：
java复制Field field = clazz.getDeclaredField("name");
field.setAccessible(true);
field.set(obj, "李四");
9. 泛型编程
9.1 泛型类与方法
定义泛型类：
java复制public class Box<T> {
private T content;
public void setContent(T content) {
this.content = content;
}
public T getContent() {
return content;
}
}
定义泛型方法：
java复制public <T> void printArray(T[] array) {
for (T element : array) {
System.out.println(element);
}
}
9.2 类型通配符
使用通配符增加灵活性：
java复制public void processList(List<? extends Number> list) {
for (Number n : list) {
System.out.println(n.doubleValue());
}
}
10. 注解与Lambda表达式
10.1 内置注解
常用内置注解：
- @Override：标记方法重写
- @Deprecated：标记过时方法
- @SuppressWarnings：抑制警告
10.2 自定义注解
定义和使用自定义注解：
java复制@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyAnnotation {
String value() default "";
int priority() default 0;
}
class MyClass {
@MyAnnotation(value = "test", priority = 1)
public void myMethod() {}
}
10.3 Lambda表达式
Lambda表达式简化函数式接口实现：
java复制List<String> names = Arrays.asList("Java", "Python", "C++");
names.sort((a, b) -> a.compareTo(b));
names.forEach(name -> System.out.println(name));
11. 常用工具类
11.1 Arrays类
数组操作工具：
java复制int[] numbers = {3, 1, 4, 2};
Arrays.sort(numbers);
int index = Arrays.binarySearch(numbers, 3);
int[] copy = Arrays.copyOf(numbers, numbers.length);
11.2 Collections类
集合操作工具：
java复制List<Integer> list = new ArrayList<>(Arrays.asList(3, 1, 4, 2));
Collections.sort(list);
Collections.reverse(list);
Collections.shuffle(list);
11.3 Objects类
对象操作工具：
java复制String str = null;
Objects.requireNonNull(str, "参数不能为null");
Objects.equals(obj1, obj2);
Objects.hashCode(obj);
12. 日期时间API
12.1 LocalDate/LocalTime/LocalDateTime
Java 8新增的日期时间类：
java复制LocalDate today = LocalDate.now();
LocalTime now = LocalTime.now();
LocalDateTime current = LocalDateTime.now();
LocalDate birthday = LocalDate.of(1990, Month.JANUARY, 1);
LocalTime meetingTime = LocalTime.of(14, 30);
12.2 日期时间操作
日期时间计算和格式化：
java复制LocalDate tomorrow = today.plusDays(1);
LocalTime later = now.plusHours(2);
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String formatted = current.format(formatter);
LocalDateTime parsed = LocalDateTime.parse("2023-01-01 12:00:00", formatter);
13. 文件与NIO
13.1 Path和Files类
NIO.2文件操作：
java复制Path path = Paths.get("test.txt");
boolean exists = Files.exists(path);
Files.createFile(path);
List<String> lines = Files.readAllLines(path);
Files.write(path, "Hello".getBytes());
13.2 文件遍历
遍历目录和文件：
java复制try (Stream<Path> stream = Files.walk(Paths.get("."))) {
stream.filter(Files::isRegularFile)
.forEach(System.out::println);
}
14. 网络编程基础
14.1 Socket编程
TCP客户端/服务器示例：
java复制// 服务器端
try (ServerSocket server = new ServerSocket(8080);
Socket socket = server.accept();
BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
PrintWriter out = new PrintWriter(socket.getOutputStream(), true)) {
String input = in.readLine();
out.println("Echo: " + input);
}
// 客户端
try (Socket socket = new Socket("localhost", 8080);
PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()))) {
out.println("Hello");
String response = in.readLine();
System.out.println(response);
}
14.2 URLConnection
HTTP请求示例：
java复制URL url = new URL("http://example.com");
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("GET");
try (BufferedReader in = new BufferedReader(new InputStreamReader(conn.getInputStream()))) {
String line;
while ((line = in.readLine()) != null) {
System.out.println(line);
}
}
15. 数据库连接(JDBC)
15.1 基本JDBC操作
连接数据库并执行查询：
java复制String url = "jdbc:mysql://localhost:3306/test";
String user = "root";
String password = "password";
try (Connection conn = DriverManager.getConnection(url, user, password);
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery("SELECT * FROM users")) {
while (rs.next()) {
System.out.println(rs.getString("username"));
}
}
15.2 PreparedStatement
使用预编译语句防止SQL注入：
java复制String sql = "INSERT INTO users (username, password) VALUES (?, ?)";
try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setString(1, "admin");
pstmt.setString(2, "123456");
pstmt.executeUpdate();
}
16. 单元测试(JUnit)
16.1 基本测试用例
使用JUnit 5编写测试：
java复制class CalculatorTest {
@Test
void testAdd() {
Calculator calc = new Calculator();
assertEquals(5, calc.add(2, 3));
}
@Test
@DisplayName("测试除法")
void testDivide() {
Calculator calc = new Calculator();
assertThrows(ArithmeticException.class, () -> calc.divide(1, 0));
}
}
16.2 测试生命周期
使用@BeforeEach和@AfterEach：
java复制class DatabaseTest {
private Connection conn;
@BeforeEach
void setUp() throws SQLException {
conn = DriverManager.getConnection("jdbc:h2:mem:test");
}
@AfterEach
void tearDown() throws SQLException {
conn.close();
}
@Test
void testQuery() {
// 测试代码
}
}
17. 日志记录
17.1 使用SLF4J和Logback
配置和使用日志：
java复制import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class MyClass {
private static final Logger logger = LoggerFactory.getLogger(MyClass.class);
public void doSomething() {
logger.debug("调试信息");
logger.info("普通信息");
logger.warn("警告信息");
logger.error("错误信息", new Exception("测试异常"));
}
}
17.2 日志配置
logback.xml配置示例：
xml复制<configuration>
<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
<encoder>
<pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
</encoder>
</appender>
<root level="INFO">
<appender-ref ref="STDOUT" />
</root>
</configuration>
18. 设计模式基础
18.1 单例模式
线程安全的单例实现：
java复制public class Singleton {
private static volatile Singleton instance;
private Singleton() {}
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
18.2 工厂模式
简单工厂示例：
java复制interface Shape {
void draw();
}
class Circle implements Shape {
public void draw() {
System.out.println("画圆");
}
}
class ShapeFactory {
public Shape createShape(String type) {
if ("circle".equals(type)) {
return new Circle();
}
throw new IllegalArgumentException("未知形状");
}
}
19. Java内存模型
19.1 堆与栈
Java内存区域划分：
- 堆：存储对象实例，被所有线程共享
- 栈：存储局部变量和方法调用，线程私有
- 方法区：存储类信息、常量、静态变量
19.2 垃圾回收
GC主要算法：
- 标记-清除
- 复制
- 标记-整理
- 分代收集
手动触发GC（仅用于测试）：
java复制System.gc();
20. Java新特性
20.1 Java 8新特性
主要新特性：
- Lambda表达式
- Stream API
- 方法引用
- 默认方法
- 新的日期时间API
Stream API示例：
java复制List<String> names = Arrays.asList("Java", "Python", "C++");
long count = names.stream()
.filter(name -> name.startsWith("J"))
.count();
20.2 Java 11新特性
主要新特性：
- 局部变量类型推断(var)
- 新的字符串方法
- HTTP Client API
- 单文件源代码程序
var关键字示例：
java复制var list = new ArrayList<String>();
var stream = list.stream();
在实际Java开发中，我发现基础知识的扎实程度直接决定了开发效率和代码质量。特别是在多线程编程和集合框架使用方面，深入理解其原理能有效避免很多潜在问题。建议初学者在学习过程中多动手实践，通过编写小程序来巩固各个知识点。