初学java从这里开始

很多新手学 Java，一上来就被”JDK、JVM、JRE、环境变量、面向对象、多态”这一堆词砸晕，不知道先抓哪头。这篇文章把 Java 入门必须过的 18 个知识点串成一条线：先让程序跑起来，再学语言基础，最后进到面向对象和高级特性。跟着这条线走，你会对 Java 有一个完整而不混乱的骨架。

说明：原文笔记里用到的 J2SE、J2EE、J2SDK 是早期（Java 5 之前）叫法，现在分别对应 Java SE（标准版）、Java EE / Jakarta EE（企业版）。正文首次出现时会标注现代叫法，方便你对照资料。

一、先把环境跑起来

1. Java 程序开发三步

Java 不是写完就能直接运行，而是要经过”写 → 编译 → 执行”三步：

源代码(.java)  --编译(javac)-->  字节码(.class)  --交给 JVM 执行-->  运行结果

• JVM（Java 虚拟机）：负责解释执行 .class 字节码。它是 Java”一次编写，到处运行”的关键——你写的代码不直接跑在操作系统上，而是跑在 JVM 上，所以换台机器只要有对应 JVM 就能跑。

2. JDK 家族：别被名字绕晕

记住一句话：想写 Java 程序，装 JDK 就够了；J2SE/J2EE 只是 JDK 按用途划分的版本。

3. JAVA_HOME 与核心工具

装好 JDK 后，关键目录是 JAVA_HOME（JDK 安装根目录）：

• 编译器：%JAVA_HOME%\bin\javac.exe
• 解释器：%JAVA_HOME%\bin\java.exe
• 类库：各种 *.jar 文件

4. 编译与执行命令

# 编译：把 .java 变成 .class
javac Hello.java

# 执行：交给 JVM 跑，注意【不能带 .class 后缀】
java Hello

5. PATH 环境变量

• 作用：告诉系统去哪些目录找可执行文件（让 javac、java 在任意目录都能敲）。
• 格式：set path=%path%;C:\Java\jdk\bin
• %path% 代表已有的 path 内容；查看当前配置直接敲 path。

6. CLASSPATH 环境变量

• 作用：告诉 JVM 去哪些目录找 .class 文件（即字节码搜索路径）。
• 格式：set classpath=%classpath%;路径

现代开发基本用构建工具（Maven/Gradle）或 IDE 管理依赖，很少手动配 CLASSPATH，但理解它的含义能帮你排查”找不到类”的报错。

7. 开发工具

原文提到 Eclipse、JBuilder。现在主流是：

• IntelliJ IDEA（社区版免费，功能强，新手首选）
• Eclipse（老牌免费）
• 也可以用 VS Code + Java 插件

新手建议直接上 IntelliJ IDEA，自带编译运行，不用手敲命令也能学。

二、语言基础

8. 数据类型

原始（基本）数据类型——8 种：

引用数据类型：数组、类、接口（本质是”指向对象的引用”，不是值本身）。

9. 运算符

int score = 85;
String level = score >= 60 ? "及格" : "不及格";  // 条件运算符

10. 控制语句

三类：判断、循环、跳转。

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

// 循环
for (int i = 1; i <= 5; i++) {
  System.out.println("第" + i + "次");
}

// 跳转
for (int i = 0; i < 10; i++) {
  if (i == 3) continue;   // 跳过本次
  if (i == 8) break;     // 结束循环
  System.out.println(i);
}

三、数组

数组是”同一类型元素的集合”，三种写法：

int[] array;             // 仅声明
int[] array = new int[5];     // 声明 + 创建（长度 5）
int[] array = {1, 2, 3, 4, 5};  // 声明 + 创建 + 初始化

遍历：

for (int x : array) {
  System.out.println(x);
}

四、面向对象（OOP 核心）

11. 对象与类

• 类：对象的”模板/原型”，定义了一类事物长什么样、能干什么。
• 对象：类的实体，用 new 创建。

class Student {
  String name;
  void study() {
    System.out.println(name + "在学习");
  }
}

// 创建对象
Student s = new Student();
s.name = "小明";
s.study();

12. 类的定义

用 class 关键字。类里包含：

• 属性（字段）
• 方法（行为，含构造方法）
• 构造方法：没有返回类型，名字和类名一样，用来初始化对象

class Student {
  String name;
  int age;

  // 构造方法
  Student(String name, int age) {
    this.name = name;
    this.age = age;
  }

  // 普通方法：方法名、返回值类型(void)、参数列表、方法体
  void sayHi() {
    System.out.println("我是" + name + "，" + age + "岁");
  }
}

13. 封装、抽象、继承、多态（四大特性）

封装：隐藏内部细节，只暴露安全的访问方式。靠修饰符实现：

class Student {
  private int age;      // 私有，外部不能直接改

  public int getAge() { return age; }
  public void setAge(int age) {
    if (age > 0) this.age = age;   // 在 setter 里加校验，这就是封装的价值
  }
}

非权限修饰符也常用：

• static：静态成员，可通过类直接调用（Student.count），静态方法内不能调非静态成员；静态块用于初始化静态成员。
• final：final 变量值不可变（常量）；final 方法不能被重写；final 类不能被继承。
• abstract：抽象方法无方法体；含抽象方法的类必须是抽象类，抽象类不能 new 对象；即使没有抽象方法也可声明为抽象类。

接口（interface）：比抽象类更”纯”的抽象。

• 用 interface 定义，implements 实现
• 方法默认 public，只有声明没有实现
• 一个类可实现多个接口
• 接口可用 extends 继承其他接口

interface Flyable {
  void fly();
}
class Bird implements Flyable {
  public void fly() { System.out.println("鸟在飞"); }
}

继承：用 extends。

• 子类继承父类所有方法和属性
• 不继承构造方法
• 创建子类对象时，父类构造方法先于子类调用

class Animal {
  Animal() { System.out.println("动物初始化"); }
}
class Dog extends Animal {
  Dog() { System.out.println("狗初始化"); }
}
// new Dog() 会先打印"动物初始化"，再打印"狗初始化"

多态：同一操作作用不同对象表现不同，主要靠：

• 方法重载（overload）：同名、参数列表不同（不看返回值）
• 方法重写（override）：子类重新定义父类方法体

class Calc {
  int add(int a, int b) { return a + b; }
  double add(double a, double b) { return a + b; }  // 重载
}
class Cat extends Animal {
  @Override
  void sound() { System.out.println("喵"); }      // 重写
}

五、异常处理

异常：程序运行时发生的错误。Java 用 try/catch 优雅处理，不让程序直接崩：

try {
  int r = 10 / 0;
} catch (ArithmeticException e) {
  System.out.println("除零错误：" + e.getMessage());
} finally {
  System.out.println("无论对错都会执行");   // 资源释放常放这里
}

四种处理方式：

1. try/catch 单 catch 或多重 catch
2. try/catch/finally
3. throw（手动抛）/throws（声明抛出）
4. 自定义异常类（继承 Exception）

// 自定义异常
class AgeException extends Exception {
  AgeException(String msg) { super(msg); }
}
// 使用
if (age < 0) throw new AgeException("年龄不能为负");

六、包（package）

包用来组织类、避免命名冲突，类似文件夹。

package com.zhou.demo;      // 声明包（文件第一行）

import com.zhou.util.Tools;   // 导入指定类
import com.zhou.util.*;     // 导入包下所有 public 类

编译带包的文件要指定输出目录：

javac -d . Demo.java    # . 表示当前目录，自动按包名建子目录
java com.zhou.demo.Demo   # 执行时写 包名.类名

常用包：java.lang（基础类，自动导入）、java.util（集合等工具）、java.io（输入输出）。

七、输入输出 I/O

Java 用”流”处理输入输出。java.io 包下读文本文件示例：

import java.io.*;
import java.nio.file.*;

public class ReadFile {
  public static void main(String[] args) throws IOException {
    // 现代简洁写法（Java 7+）
    String content = new String(Files.readAllBytes(Paths.get("test.txt")));
    System.out.println(content);
  }
}

传统写法是用 FileInputStream / BufferedReader 等，理解”流”的概念即可，实战中按需查文档。

八、并发与多线程

单线程像一条流水线，多线程让程序”同时”做几件事（如一边下载一边刷新界面）。Java 创建线程两种主流方式：

// 方式一：继承 Thread
class MyThread extends Thread {
  public void run() { System.out.println("线程运行中"); }
}
new MyThread().start();

// 方式二：实现 Runnable（更推荐，避免单继承限制）
class MyTask implements Runnable {
  public void run() { System.out.println("任务运行中"); }
}
new Thread(new MyTask()).start();

多线程涉及线程安全、锁等进阶话题，入门阶段先理解”线程是什么、怎么启动”就够了。

九、下一步去哪

走完上面 18 站，你已经有了 Java 的完整骨架。后续建议路线：

一句话总结：Java 不难在某一知识点，难在”先建立完整地图，再逐点深挖”。这篇文章就是那张地图——收藏它，每学一个新概念，回来对照它在整张图里的位置，就不会迷路。