大家好，我是 lazy，一名大二科班学生。

JavaSE 是学习 Java 后端开发的基础。很多人刚开始学 Java 时，会觉得知识点很散：变量、循环、数组、面向对象、集合、异常、IO、多线程、反射、Lambda……看起来很多，但其实 JavaSE 的核心重点可以归纳成几大块。

本文将用一篇博客帮你梳理 JavaSE 的学习重点，并配上一些常见代码示例。

---

一、Java 基础语法：先能写出基本程序

学习 JavaSE 的第一步，是掌握最基础的语法结构，包括变量、数据类型、运算符、流程控制、数组和方法。

1. 基本数据类型

Java 中常见的基本数据类型有 8 种：

public class Demo {
    public static void main(String[] args) {
        byte b = 10;
        short s = 20;
        int age = 21;
        long money = 100000L;

        float score = 98.5F;
        double price = 19.99;

        char gender = '男';
        boolean flag = true;

        System.out.println(age);
    }
}

重点要掌握：

int 是最常用的整数类型；
double 是最常用的小数类型；
boolean 只有 true 和 false；
char 表示单个字符；
String 不是基本类型，而是引用类型。

---

二、流程控制：控制程序怎么执行

流程控制主要包括 if、switch、for、while 等。

1. if 判断

public class IfDemo {
    public static void main(String[] args) {
        int score = 85;

        if (score >= 90) {
            System.out.println("优秀");
        } else if (score >= 60) {
            System.out.println("及格");
        } else {
            System.out.println("不及格");
        }
    }
}

2. for 循环

public class ForDemo {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {
            System.out.println("第 " + i + " 次循环");
        }
    }
}

循环是后面学习数组、集合和算法的基础，必须熟练掌握。

---

三、数组：存储一组相同类型的数据

数组可以存储多个相同类型的数据。

public class ArrayDemo {
    public static void main(String[] args) {
        int[] scores = {90, 80, 70, 60};

        for (int i = 0; i < scores.length; i++) {
            System.out.println(scores[i]);
        }
    }
}

也可以使用增强 for 循环：

public class ArrayDemo2 {
    public static void main(String[] args) {
        String[] names = {"张三", "李四", "王五"};

        for (String name : names) {
            System.out.println(name);
        }
    }
}

数组的重点是：

理解下标从 0 开始；
掌握数组遍历；
理解数组长度固定；
后面集合就是对数组缺点的一种改进。

---

四、面向对象：JavaSE 最核心的部分

Java 是面向对象语言，面向对象是 JavaSE 的重点中的重点。

面向对象主要包括：

类和对象；
成员变量和成员方法；
构造方法；
封装；
继承；
多态；
抽象类；
接口。

1. 类和对象

class Student {
    String name;
    int age;

    public void study() {
        System.out.println(name + " 正在学习");
    }
}

public class Test {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.name = "张三";
        stu.age = 20;
        stu.study();
    }
}

类可以理解为模板，对象是根据模板创建出来的具体实例。

---

2. 封装

封装就是把属性私有化，通过方法进行访问。

class User {
    private String username;
    private String password;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public void setPassword(String password) {
        if (password.length() >= 6) {
            this.password = password;
        } else {
            System.out.println("密码长度不能小于 6 位");
        }
    }
}

封装的好处是提高安全性，防止外部随意修改对象内部数据。

---

3. 继承

继承可以让子类复用父类的代码。

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

class Dog extends Animal {
    public void bark() {
        System.out.println("狗会叫");
    }
}

public class ExtendsDemo {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();
        dog.bark();
    }
}

重点理解：

子类可以继承父类的属性和方法；
Java 中只能单继承；
所有类默认继承 Object 类。

---

4. 多态

多态指的是同一个对象，在不同时刻表现出不同形态。

class Animal {
    public void speak() {
        System.out.println("动物发出声音");
    }
}

class Cat extends Animal {
    @Override
    public void speak() {
        System.out.println("猫喵喵叫");
    }
}

class Dog extends Animal {
    @Override
    public void speak() {
        System.out.println("狗汪汪叫");
    }
}

public class PolymorphismDemo {
    public static void main(String[] args) {
        Animal a1 = new Cat();
        Animal a2 = new Dog();

        a1.speak();
        a2.speak();
    }
}

多态的核心写法：

父类类型 变量名 = new 子类对象();

多态的好处是提高代码扩展性。

---

五、String：Java 中最常用的类之一

String 表示字符串，在 Java 开发中使用非常频繁。

public class StringDemo {
    public static void main(String[] args) {
        String str = "hello java";

        System.out.println(str.length());
        System.out.println(str.charAt(0));
        System.out.println(str.substring(0, 5));
        System.out.println(str.contains("java"));
        System.out.println(str.replace("java", "world"));
    }
}

重点掌握：

String 是不可变对象；
字符串比较内容要用 equals()；
不能用 == 比较字符串内容。

public class StringCompare {
    public static void main(String[] args) {
        String a = new String("hello");
        String b = new String("hello");

        System.out.println(a == b);        // false
        System.out.println(a.equals(b));   // true
    }
}

---

六、集合：JavaSE 学习的重点

集合是 JavaSE 中非常重要的内容，比数组更灵活。

1. ArrayList

import java.util.ArrayList;

public class ListDemo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();

        list.add("Java");
        list.add("MySQL");
        list.add("Redis");

        for (String item : list) {
            System.out.println(item);
        }
    }
}

ArrayList 特点：

查询快；
增删相对慢；
元素有序；
可以重复。

---

2. HashSet

import java.util.HashSet;

public class SetDemo {
    public static void main(String[] args) {
        HashSet<String> set = new HashSet<>();

        set.add("Java");
        set.add("Java");
        set.add("MySQL");

        System.out.println(set);
    }
}

HashSet 特点：

元素不能重复；
存取顺序不固定；
底层和哈希表有关。

---

3. HashMap

import java.util.HashMap;
import java.util.Map;

public class MapDemo {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();

        map.put("张三", 90);
        map.put("李四", 80);
        map.put("王五", 70);

        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            System.out.println(entry.getKey() + "：" + entry.getValue());
        }
    }
}

HashMap 是键值对结构：

key -> value

比如：

"张三" -> 90
"李四" -> 80

重点掌握：

key 不能重复；
value 可以重复；
常用于根据某个 key 快速查找数据。

---

七、异常处理：让程序更稳定

异常是程序运行过程中出现的问题。

常见异常：

NullPointerException：空指针异常
ArrayIndexOutOfBoundsException：数组下标越界
ArithmeticException：算术异常
ClassCastException：类型转换异常

try-catch 示例

public class ExceptionDemo {
    public static void main(String[] args) {
        try {
            int result = 10 / 0;
            System.out.println(result);
        } catch (ArithmeticException e) {
            System.out.println("除数不能为 0");
        } finally {
            System.out.println("程序执行结束");
        }
    }
}

异常处理重点：

try 中写可能出错的代码；
catch 捕获异常；
finally 一般用于释放资源；
不要乱用异常，能提前判断就提前判断。

---

八、泛型：让集合更加安全

泛型可以限制集合中存储的数据类型。

import java.util.ArrayList;

public class GenericDemo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();

        list.add("Java");
        list.add("MySQL");
        // list.add(123); // 报错

        String value = list.get(0);
        System.out.println(value);
    }
}

没有泛型时，集合中什么类型都能放，取出来还需要强制类型转换，容易出错。

泛型的作用：

提高代码安全性；
减少强制类型转换；
让代码更加清晰。

---

九、IO 流：实现文件读写

IO 流用于读写文件，是 JavaSE 的重要内容。

1. 写文件

import java.io.FileWriter;
import java.io.IOException;

public class WriteDemo {
    public static void main(String[] args) {
        try (FileWriter writer = new FileWriter("test.txt")) {
            writer.write("Hello Java IO!");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2. 读文件

import java.io.FileReader;
import java.io.IOException;

public class ReadDemo {
    public static void main(String[] args) {
        try (FileReader reader = new FileReader("test.txt")) {
            int ch;
            while ((ch = reader.read()) != -1) {
                System.out.print((char) ch);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

这里使用了 try-with-resources，可以自动关闭资源，比手动 close() 更安全。

IO 流重点：

字节流适合处理图片、视频、音频等文件；
字符流适合处理文本文件；
缓冲流可以提高读写效率。

---

十、多线程：让程序同时做多件事

多线程是 JavaSE 中比较难但很重要的部分。

1. 继承 Thread 创建线程

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("线程正在运行：" + Thread.currentThread().getName());
    }
}

public class ThreadDemo {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();

        t1.start();
        t2.start();
    }
}

注意：启动线程要调用 start()，不是直接调用 run()。

---

2. 实现 Runnable 接口

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Runnable 线程：" + Thread.currentThread().getName());
    }
}

public class RunnableDemo {
    public static void main(String[] args) {
        Thread t1 = new Thread(new MyRunnable());
        Thread t2 = new Thread(new MyRunnable());

        t1.start();
        t2.start();
    }
}

实际开发中更推荐使用 Runnable 或线程池。

---

3. synchronized 解决线程安全问题

class Ticket implements Runnable {
    private int tickets = 100;

    @Override
    public void run() {
        while (true) {
            synchronized (this) {
                if (tickets > 0) {
                    System.out.println(Thread.currentThread().getName() + " 正在卖第 " + tickets + " 张票");
                    tickets--;
                } else {
                    break;
                }
            }
        }
    }
}

public class SyncDemo {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();

        new Thread(ticket, "窗口1").start();
        new Thread(ticket, "窗口2").start();
        new Thread(ticket, "窗口3").start();
    }
}

多线程重点：

线程创建方式；
线程生命周期；
线程安全问题；
synchronized；
锁；
线程池。

---

十一、Lambda 和 Stream：让代码更简洁

Java 8 之后，Lambda 和 Stream 使用非常多。

1. Lambda 表达式

public class LambdaDemo {
    public static void main(String[] args) {
        Runnable r = () -> {
            System.out.println("Lambda 创建线程");
        };

        new Thread(r).start();
    }
}

Lambda 可以简化匿名内部类写法。

---

2. Stream 流

import java.util.ArrayList;
import java.util.List;

public class StreamDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();

        list.add("Java");
        list.add("JavaScript");
        list.add("Python");
        list.add("MySQL");

        list.stream()
                .filter(s -> s.startsWith("Java"))
                .forEach(System.out::println);
    }
}

Stream 常用操作：

filter：过滤；
map：转换；
forEach：遍历；
collect：收集结果；
sorted：排序。

---

十二、反射：运行时获取类的信息

反射可以在程序运行时获取类、方法、属性等信息。很多框架底层都用到了反射，比如 Spring、MyBatis。

class Person {
    private String name;

    public void sayHello() {
        System.out.println("Hello");
    }
}

public class ReflectDemo {
    public static void main(String[] args) throws Exception {
        Class<?> clazz = Class.forName("Person");

        Object obj = clazz.getDeclaredConstructor().newInstance();

        clazz.getMethod("sayHello").invoke(obj);
    }
}

反射重点：

获取 Class 对象；
获取构造方法；
获取成员变量；
获取成员方法；
通过反射创建对象和调用方法。

---

十三、JavaSE 学习路线总结

学习 JavaSE 可以按照这个顺序：

其中最重要的是：

面向对象；
集合；
异常；
IO 流；
多线程；
Lambda 和 Stream；
反射。

如果以后学习 JavaWeb、Spring、Spring Boot、MyBatis，这些 JavaSE 知识都会反复用到。

---

十四、一个综合小案例：学生管理系统简化版

下面用一个小案例，把面向对象、集合、循环、方法结合起来。

import java.util.ArrayList;
import java.util.Scanner;

class Student {
    private String id;
    private String name;
    private int age;

    public Student(String id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    public String getId() {
        return id;
    }

    public void showInfo() {
        System.out.println("学号：" + id + "，姓名：" + name + "，年龄：" + age);
    }
}

public class StudentManager {
    private static ArrayList<Student> students = new ArrayList<>();
    private static Scanner scanner = new Scanner(System.in);

    public static void main(String[] args) {
        while (true) {
            System.out.println("====== 学生管理系统 ======");
            System.out.println("1. 添加学生");
            System.out.println("2. 查看学生");
            System.out.println("3. 删除学生");
            System.out.println("4. 退出系统");
            System.out.print("请输入你的选择：");

            int choice = scanner.nextInt();

            switch (choice) {
                case 1:
                    addStudent();
                    break;
                case 2:
                    showStudents();
                    break;
                case 3:
                    deleteStudent();
                    break;
                case 4:
                    System.out.println("系统退出");
                    return;
                default:
                    System.out.println("输入错误，请重新输入");
            }
        }
    }

    public static void addStudent() {
        System.out.print("请输入学号：");
        String id = scanner.next();

        System.out.print("请输入姓名：");
        String name = scanner.next();

        System.out.print("请输入年龄：");
        int age = scanner.nextInt();

        students.add(new Student(id, name, age));
        System.out.println("添加成功！");
    }

    public static void showStudents() {
        if (students.isEmpty()) {
            System.out.println("暂无学生信息");
            return;
        }

        for (Student student : students) {
            student.showInfo();
        }
    }

    public static void deleteStudent() {
        System.out.print("请输入要删除的学生学号：");
        String id = scanner.next();

        for (int i = 0; i < students.size(); i++) {
            if (students.get(i).getId().equals(id)) {
                students.remove(i);
                System.out.println("删除成功！");
                return;
            }
        }

        System.out.println("没有找到该学生");
    }
}

这个案例用到了：

类和对象；
封装；
构造方法；
集合 ArrayList；
循环；
switch；
方法封装；
字符串比较 equals()。

---

十五、总结

JavaSE 不是简单的语法学习，而是整个 Java 技术体系的基础。刚开始学习时，不需要一口气把所有内容都学到很深，但一定要把核心知识点掌握扎实。

最需要重点掌握的内容是：

JavaSE 学得越扎实，后面学习 JavaWeb、数据库、Spring Boot、微服务时就越轻松。对于初学者来说，最好的学习方法不是只看理论，而是每学一个知识点都写代码练习，边写边理解，才能真正掌握 Java。