Java 入门教程

FreeGuideOnline 最新 2026-07-14

java public class HelloWorld { public static void main(String[] args) { System.out.println("Hello, Java!"); } }


代码解释：
- `public class HelloWorld`：定义了一个公共类，类名必须与文件名一致。
- `public static void main(String[] args)`：程序的主入口方法，JVM 从这里开始执行。
- `System.out.println()`：将文本输出到控制台。

### 3.2 编译与运行
1.  打开命令行，切换到文件所在目录。
2.  编译：`javac HelloWorld.java`，生成 `HelloWorld.class` 字节码文件。
3.  运行：`java HelloWorld`，控制台打印 `Hello, Java!`。

### 3.3 IDE 中运行
在 IntelliJ IDEA 中右键点击代码编辑区，选择 **Run 'HelloWorld.main()'**，结果会显示在下方控制台。

---

## 第四章：Java 基础语法

### 4.1 注释
注释用于解释代码，不会被执行。

```java
// 单行注释

/*
   多行注释
*/

/**
 * 文档注释，用于生成 API 文档
 */

4.2 变量与数据类型

Java 是强类型语言，变量必须先声明类型。

基本数据类型（8 种）：

整数型：byte (1字节)、short (2字节)、int (4字节)、long (8字节，值加 L)
浮点型：float (4字节，值加 f)、double (8字节)
字符型：char (2字节，Unicode 编码)
布尔型：boolean (true/false)

声明示例：

int age = 25;
double price = 99.8;
char grade = 'A';
boolean isActive = true;
String name = "Java"; // String 是引用类型，不是基本类型

4.3 运算符

算术运算符：+ - * / % (取余)
关系运算符：> < == != >= <=
逻辑运算符：&& (与) || (或) ! (非)
赋值运算符：= += -= 等
自增自减：++ --

4.4 控制流程

条件语句：

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

循环语句：

// for 循环
for (int i = 0; i < 5; i++) {
    System.out.println(i);
}

// while 循环
int j = 0;
while (j < 5) {
    System.out.println(j);
    j++;
}

4.5 数组

数组用于存储固定长度的同类型元素。

// 声明与初始化
int[] numbers = new int[5];
int[] scores = {90, 85, 78};

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

// 增强 for 循环（遍历所有元素）
for (int s : scores) {
    System.out.println(s);
}

第五章：面向对象编程（OOP）

面向对象是 Java 的核心思想，主要围绕类与对象。

5.1 类与对象

类是抽象模板，对象是具体实例。

// 定义一个 Student 类
public 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();
    }
}

5.2 封装与访问修饰符

封装通过 private 隐藏内部细节，提供公有方法访问。

private：仅本类可见。
default（无修饰符）：同包可见。
protected：同包及子类可见。
public：所有类可见。

标准封装写法：

public class Person {
    private String name;

    // getter 方法
    public String getName() {
        return name;
    }

    // setter 方法
    public void setName(String name) {
        this.name = name; // this 指当前对象
    }
}

5.3 构造方法

构造方法用于初始化对象，名称与类名相同，无返回值。

public class Person {
    private String name;

    // 无参构造（默认存在，但若定义了有参构造则需显式写出）
    public Person() {
    }

    // 有参构造
    public Person(String name) {
        this.name = name;
    }
}

// 使用
Person p = new Person("李四");

5.4 继承

使用 extends 关键字实现继承，Java 只支持单继承。

// 父类
public class Animal {
    public void eat() {
        System.out.println("吃东西");
    }
}

// 子类
public class Dog extends Animal {
    public void bark() {
        System.out.println("汪汪叫");
    }
}

// 测试
Dog dog = new Dog();
dog.eat();  // 继承自父类
dog.bark();

子类可以重写（Override）父类方法，要求方法签名一致。

5.5 多态

多态指同一行为具有不同表现，实现前提是继承 + 重写 + 父类引用指向子类对象。

Animal a = new Dog();   // 向上转型
a.eat();                // 调用的是 Dog 类重写后的 eat 方法

第六章：常用核心类库

6.1 String 类

字符串是使用最频繁的对象，注意其不可变性。

String s1 = "Hello";
String s2 = new String("Hello");

// 常用方法
int len = s1.length();           // 长度
String sub = s1.substring(1,4); // 子串 [1,4)
String upper = s1.toUpperCase(); // 转大写
boolean eq = s1.equals(s2);     // 内容比较，切勿用 ==

6.2 包装类

为基本类型提供对象封装，实现自动装箱/拆箱。

int → Integer
char → Character
其他为首字母大写。

Integer num = 100;          // 自动装箱
int value = num;            // 自动拆箱
String str = "123";
int parsed = Integer.parseInt(str);

6.3 数学与随机数

Math.abs(-5);           // 绝对值
Math.max(3, 8);         // 最大值
Math.random();          // [0.0, 1.0) 随机数
Random rand = new Random();
rand.nextInt(100);      // 0~99 随机整数

第七章：异常处理

异常处理机制增强程序健壮性，防止崩溃。

7.1 try-catch-finally

try {
    int result = 10 / 0;   // 可能发生异常的代码
} catch (ArithmeticException e) {
    System.out.println("除数不能为0");
} finally {
    System.out.println("始终执行，用于释放资源");
}

7.2 throws 与自定义异常

当方法内无法处理异常时，可以抛出给调用者。

public void checkAge(int age) throws Exception {
    if (age < 0) {
        throw new Exception("年龄不能为负");
    }
}

第八章：集合框架

集合存储数量可变的对象引用，位于 java.util 包。

常用接口	实现类	特点
List	ArrayList	有序可重复，基于动态数组
Set	HashSet	无序不可重复
Map	HashMap	键值对，键不可重复

示例：

// List
List<String> list = new ArrayList<>();
list.add("Java");
list.add("Python");
for (String item : list) {
    System.out.println(item);
}

// Map
Map<String, Integer> map = new HashMap<>();
map.put("张三", 90);
map.put("李四", 85);
int score = map.get("张三");

泛型（< >）约束集合中元素的类型，提高安全性。

第九章：输入输出与文件操作

9.1 控制台输入

使用 Scanner 类。

import java.util.Scanner;

Scanner scanner = new Scanner(System.in);
System.out.print("请输入姓名：");
String name = scanner.nextLine();
System.out.println("你好，" + name);

9.2 文件读写（基础）

推荐使用现代的 java.nio.file 包。

// 读取所有行
List<String> lines = Files.readAllLines(Paths.get("test.txt"));
for (String line : lines) {
    System.out.println(line);
}

// 写入
Files.writeString(Paths.get("output.txt"), "Hello File");