Java 从入门到企业级开发指南

这是 Java 最核心的 8 种'元素'。

• 整型 (Integer Types): 用于存放整数。
  • int: 最常用，范围约 -21 亿到 21 亿。
  • long: 用于存放非常大的整数，需要在数字末尾加 L。
  • short: 较小的整数。
  • byte: 非常小的整数。
• 浮点型 (Floating-Point Types): 用于存放小数。
  • double: 最常用，双精度小数。
  • float: 单精度小数，需要在数字末尾加 F。
• 字符型 (Character Type)
  • char: 用于存放单个字符，用单引号'括起来。
• 布尔型 (Boolean Type)
  • boolean: 只有两个值：true (真) 和 false (假)。

代码示例：

public class BasicDataTypes {
    public static void main(String[] args) {
        // 声明一个整型变量 age，并赋值为 25
        int age = 25;
        System.out.println("我的年龄是：" + age);
        
        // 声明一个长整型变量，用于存储地球人口
        long earthPopulation = 7800000000L;
        System.out.println("地球人口大约是：" + earthPopulation);
        
        // 声明一个双精度浮点型变量，用于存储圆周率
        double pi = 3.1415926535;
        System.out.println("圆周率是：" + pi);
        
        // 声明一个字符型变量
        char grade = 'A';
        System.out.println("我的评级是：" + grade);
        
        // 声明一个布尔型变量
        boolean isJavaFun = true;
        System.out.println("Java 有趣吗？" + isJavaFun);
    }
}

2. 引用数据类型 (Reference Types)

除了基本元素，我们还有更复杂的'化合物'。最常用的就是字符串 (String)。

• String: 用于存放一串文本，用双引号"括起来。它不是基本类型，而是一个功能强大的类。

public class StringExample {
    public static void main(String[] args) {
        // 声明一个字符串变量
        String greeting = "欢迎来到 Java 的宇宙!";
        // 字符串拼接
        String message = greeting + " 祝你旅途愉快。";
        System.out.println(message);
    }
}

第三章：创造的法则 —— 运算符

有了元素，我们还需要法则来让它们互动。运算符就是这些法则。

• 算术运算符: + (加), - (减), * (乘), / (除), % (取余)
• 赋值运算符: = (赋值), +=, -=, *=, /=
• 关系运算符: == (等于), != (不等于), > (大于), < (小于), >=, <=
• 逻辑运算符: && (与), || (或), ! (非)

代码示例：

public class OperatorsExample {
    public static void main(String[] args) {
        int a = 10;
        int b = 4;
        
        // 算术运算
        System.out.println("a + b = " + (a + b)); // 输出 14
        System.out.println("a / b = " + (a / b)); // 输出 2 (整数相除，结果也是整数)
        System.out.println("a % b = " + (a % b)); // 输出 2 (10 除以 4 的余数)
        
        // 关系运算
        boolean isEqual = (a == b);
        System.out.println("a 等于 b 吗？" + isEqual); // 输出 false
        
        // 逻辑运算
        boolean condition1 = (a > 5); // true
        boolean condition2 = (b < 3); // false
        System.out.println("条件 1 和 条件 2 都成立吗？" + (condition1 && condition2)); // 输出 false
        System.out.println("条件 1 或 条件 2 任意一个成立吗？" + (condition1 || condition2)); // 输出 true
    }
}

第四章：宇宙的秩序 —— 控制流程

一个静态的世界是无趣的。我们需要让程序能够做决定和重复执行，这就是控制流程。

1. 条件语句 (做决定)

• if-else: 如果...那么...否则...

public class IfElseExample {
    public static void main(String[] args) {
        int score = 85;
        if (score >= 90) {
            System.out.println("优秀!");
        } else if (score >= 80) {
            System.out.println("良好!");
        } else if (score >= 60) {
            System.out.println("及格!");
        } else {
            System.out.println("需要努力!");
        }
    }
}

• switch: 适用于对一个变量进行多值判断。

public class SwitchExample {
    public static void main(String[] args) {
        char level = 'B';
        switch (level) {
            case 'A':
                System.out.println("王者");
                break;
            case 'B':
                System.out.println("钻石");
                break;
            case 'C':
                System.out.println("铂金");
                break;
            default:
                System.out.println("青铜");
                break;
        }
    }
}

2. 循环语句 (重复执行)

• for 循环: 适用于已知循环次数的场景。

public class ForLoopExample {
    public static void main(String[] args) {
        // 打印从 1 到 5
        for (int i = 1; i <= 5; i++) {
            System.out.println("当前数字是：" + i);
        }
    }
}

• while 循环: 适用于未知循环次数，但知道循环结束条件的场景。

public class WhileLoopExample {
    public static void main(String[] args) {
        int count = 1;
        while (count <= 3) {
            System.out.println("这是第 " + count + " 次问好。");
            count++; // 别忘了更新循环变量，否则会死循环！
        }
    }
}

第五章：创造生命体 —— 类与对象 (OOP 入门)

这是 Java 最核心、最伟大的思想：面向对象编程 (Object-Oriented Programming)。

• 类 (Class): 是一个蓝图或模板，描述了一类事物共同的属性（特征）和方法（行为）。
• 对象 (Object): 是根据这个蓝图创造出来的具体实例。

让我们来设计一个'狗'的蓝图 (Dog 类):

// Dog.java
public class Dog {
    // 属性 (Fields / Instance Variables)
    String name;
    String breed;
    int age;
    
    // 方法 (Methods)
    public void bark() {
        System.out.println(name + " Says: 汪汪!");
    }
    
    public void introduce() {
        System.out.println("你好，我是 " + name + ", 一只 " + age + " 岁的" + breed + "。");
    }
}

现在，让我们根据这个蓝图，创造两只具体的狗（对象）：

// DogCreator.java
public class DogCreator {
    public static void main(String[] args) {
        // 1. 根据 Dog 蓝图，创建一只名为 dog1 的狗对象
        Dog dog1 = new Dog();
        // 2. 为 dog1 设置属性
        dog1.name = "旺财";
        dog1.breed = "中华田园犬";
        dog1.age = 3;
        // 3. 调用 dog1 的方法
        dog1.introduce();
        dog1.bark();
        
        System.out.println("--------------------");
        
        // 4. 创建第二只狗对象
        Dog dog2 = new Dog();
        dog2.name = "小白";
        dog2.breed = "萨摩耶";
        dog2.age = 2;
        dog2.introduce();
        dog2.bark();
    }
}

通过类和对象，我们把现实世界的事物抽象到了代码中，让程序结构变得清晰、可复用。

第六章：面向对象的三大支柱与抽象

掌握了基本的类与对象，我们现在要学习构建大型软件的真正基石。

1. 封装 (Encapsulation) —— '信息隐藏的艺术'

概念： 将对象的数据（属性）和操作这些数据的方法（行为）捆绑在一起，并对外部隐藏对象的内部实现细节。

实现： 使用 private 关键字修饰属性，并提供 public 的 getter 和 setter 方法来访问。

代码示例：

// BankAccount.java
public class BankAccount {
    // 设为私有，外部无法直接访问 balance
    private double balance;
    
    // 公共的存款方法
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
            System.out.println("存款成功，当前余额：" + balance);
        } else {
            System.out.println("存款金额必须为正数!");
        }
    }
    
    // 公共的取款方法
    public void withdraw(double amount) {
        if (amount > 0 && balance >= amount) {
            balance -= amount;
            System.out.println("取款成功，当前余额：" + balance);
        } else {
            System.out.println("取款失败，金额无效或余额不足!");
        }
    }
    
    // 公共的查询余额方法 (Getter)
    public double getBalance() {
        return balance;
    }
}

// BankDemo.java
public class BankDemo {
    public static void main(String[] args) {
        BankAccount myAccount = new BankAccount();
        // myAccount.balance = -10000; // 错误！无法直接访问私有属性
        myAccount.deposit(500);
        myAccount.withdraw(200);
        myAccount.withdraw(400); // 这次会失败
        System.out.println("最终余额：" + myAccount.getBalance());
    }
}

讲解： 封装保护了数据的安全性，我们可以在 setter 和其他方法中加入逻辑校验，防止非法操作。

2. 继承 (Inheritance) —— '站在巨人的肩膀上'

概念： 允许一个类（子类）继承另一个类（父类）的属性和方法，并可以添加自己的新特性或重写父类的方法。这是实现代码复用的关键。

实现： 使用 extends 关键字。

代码示例：

// Animal.java (父类)
public class Animal {
    String name;
    public Animal(String name) {
        this.name = name;
    }
    public void eat() {
        System.out.println(name + " 正在吃东西...");
    }
}

// Cat.java (子类)
public class Cat extends Animal {
    public Cat(String name) {
        super(name); // 调用父类的构造方法
    }
    
    // 子类特有的方法
    public void meow() {
        System.out.println(name + " 正在喵喵叫!");
    }
}

// InheritanceDemo.java
public class InheritanceDemo {
    public static void main(String[] args) {
        Cat myCat = new Cat("咪咪");
        myCat.eat(); // 继承自 Animal 类的方法
        myCat.meow(); // Cat 类自己的方法
    }
}

讲解： Cat 类自动拥有了 Animal 类的 name 属性和 eat() 方法，无需重复编写。

3. 多态 (Polymorphism) —— '万物归一的哲学'

概念： 同一个接口（或父类引用），使用不同的实例，执行操作时会表现出不同的行为。多态是框架设计的灵魂。

实现： 需要继承、方法重写（Override）和父类引用指向子类对象。

代码示例：

// Animal.java (重写版)
public class Animal {
    public void makeSound() {
        System.out.println("动物发出声音...");
    }
}

// Dog.java (重写版)
public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("汪汪!");
    }
}

// Cat.java (重写版)
public class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("喵喵!");
    }
}

// PolymorphismDemo.java
public class PolymorphismDemo {
    public static void main(String[] args) {
        // 父类引用指向子类对象
        Animal myDog = new Dog();
        Animal myCat = new Cat();
        
        // 调用同样的方法，表现出不同的行为
        myDog.makeSound(); // 输出：汪汪!
        myCat.makeSound(); // 输出：喵喵!
    }
}

讲解： 尽管 myDog 和 myCat 都是 Animal 类型，但它们在运行时会调用各自重写后的 makeSound 方法，这就是多态。

4. 抽象 (Abstraction) —— '定义规范，而非实现'

• 抽象类 (Abstract Class): 一个'不完整的蓝图'，不能被实例化，主要用来被继承。它可以包含抽象方法（只有声明，没有方法体）。

// Shape.java (抽象类)
public abstract class Shape {
    // 抽象方法，强制子类必须实现它
    public abstract double calculateArea();
    
    public void printInfo() {
        System.out.println("这是一个形状。");
    }
}

// Circle.java
public class Circle extends Shape {
    private double radius;
    
    public Circle(double radius) {
        this.radius = radius;
    }
    
    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;
    }
}

• 接口 (Interface): 一个'行为合同'，比抽象类更彻底。它只包含常量和抽象方法（在 Java 8 后可以有默认方法和静态方法）。一个类可以实现多个接口。

// Flyable.java (接口)
public interface Flyable {
    void fly(); // 接口中的方法默认是 public abstract 的
}

// Bird.java
public class Bird implements Flyable {
    @Override
    public void fly() {
        System.out.println("鸟儿在扇动翅膀飞翔...");
    }
}

// Airplane.java
public class Airplane implements Flyable {
    @Override
    public void fly() {
        System.out.println("飞机依靠引擎轰鸣起飞...");
    }
}

讲解： 抽象类定义了"is-a"（是什么）的关系，接口定义了"has-a"（能做什么）的能力。

第七章：组织与管理 —— 数组与集合

当我们需要管理一大批同类型的数据时（比如一个班级的所有学生），就需要用到数组或集合。

• 数组 (Array): 一个长度固定的容器。

public class ArrayExample {
    public static void main(String[] args) {
        // 声明一个能装 5 个整数的数组
        int[] scores = new int[5];
        // 赋值
        scores[0] = 95;
        scores[1] = 88;
        
        // 另一种创建方式：直接初始化
        String[] fruits = {"苹果", "香蕉", "橘子"};
        
        // 遍历数组
        for (int i = 0; i < fruits.length; i++) {
            System.out.println("我喜欢吃：" + fruits[i]);
        }
    }
}

• 集合 (Collection): ArrayList 是最常用的集合，一个长度可变的'动态数组'。

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

public class ArrayListExample {
    public static void main(String[] args) {
        // 创建一个只能装字符串的 ArrayList，推荐使用接口类型引用
        List<String> cities = new ArrayList<>();
        
        // 添加元素
        cities.add("北京");
        cities.add("上海");
        cities.add("深圳");
        
        // 获取元素
        System.out.println("第一个城市是：" + cities.get(0));
        
        // 遍历集合 (使用增强 for 循环，更简洁)
        for (String city : cities) {
            System.out.println("城市：" + city);
        }
    }
}

第八章：应对意外 —— 异常处理

健壮的程序必须能处理各种意外情况（比如文件不存在、网络中断）。异常处理就是 Java 提供的'应急预案'。

• try-catch-finally 语句：尝试执行可能出错的代码，如果出错了就捕获并处理，最后执行收尾工作。

public class ExceptionHandlingExample {
    public static void main(String[] args) {
        try {
            // 尝试执行的代码
            int[] numbers = {1, 2, 3};
            System.out.println(numbers[10]); // 这里会出错，因为数组越界了
        } catch (ArrayIndexOutOfBoundsException e) {
            // 如果发生了指定类型的异常，就执行这里的代码
            System.out.println("出错了！数组索引超出了范围。");
            // e.printStackTrace(); // 打印详细的错误信息
        } finally {
            // 无论是否发生异常，这里的代码总会执行
            System.out.println("程序块执行完毕。");
        }
        System.out.println("程序继续运行...");
    }
}

通过异常处理，即使程序遇到错误，也不会直接崩溃，而是可以优雅地处理，保证了程序的稳定性。

第九章：探索 Java 标准库 —— 核心 API 实战

Java 的强大不仅在于语言本身，更在于其庞大而成熟的标准库（Java API）。

1. 文件 I/O (Input/Output)

读写文件是常见的操作。Java NIO (java.nio) 提供了现代化的文件操作方式。

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;

public class FileIOExample {
    public static void main(String[] args) {
        Path filePath = Paths.get("my-notes.txt");
        
        // --- 写文件 ---
        try {
            String content = "这是我的第一行笔记。\nJava 文件操作真简单！";
            Files.write(filePath, content.getBytes());
            System.out.println("文件写入成功!");
        } catch (IOException e) {
            System.err.println("写入文件时出错：" + e.getMessage());
        }
        
        // --- 读文件 ---
        try {
            List<String> lines = Files.readAllLines(filePath);
            System.out.println("读取文件内容:");
            for (String line : lines) {
                System.out.println(line);
            }
        } catch (IOException e) {
            System.err.println("读取文件时出错：" + e.getMessage());
        }
    }
}

2. 多线程 (Multithreading)

让你的程序能同时做好几件事。创建线程最推荐的方式是实现 Runnable 接口。

// 创建一个任务
class PrintTask implements Runnable {
    private String taskName;
    
    public PrintTask(String name) {
        this.taskName = name;
    }
    
    @Override
    public void run() {
        for (int i = 1; i <= 3; i++) {
            System.out.println("任务 " + taskName + " 正在执行：" + i);
            try {
                Thread.sleep(1000); // 暂停 1 秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class MultiThreadingExample {
    public static void main(String[] args) {
        // 创建两个线程来执行任务
        Thread thread1 = new Thread(new PrintTask("A"));
        Thread thread2 = new Thread(new PrintTask("B"));
        
        System.out.println("开始执行多线程任务...");
        thread1.start(); // 启动线程 1
        thread2.start(); // 启动线程 2
        
        System.out.println("主线程继续执行...");
    }
}

讲解： 你会看到任务 A 和 B 的输出是交替进行的，证明它们在并发执行。

3. 网络编程 (Networking)

创建一个简单的客户端 - 服务器应用。

• 服务器端 (EchoServer)

import java.io.*;
import java.net.*;

public class EchoServer {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(9999); // 监听 9999 端口
        System.out.println("服务器已启动，等待客户端连接...");
        Socket clientSocket = serverSocket.accept(); // 阻塞，直到有客户端连接
        System.out.println("客户端已连接：" + clientSocket.getInetAddress());
        
        try (BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
             PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true)) {
            String inputLine;
            while ((inputLine = in.readLine()) != null) {
                System.out.println("收到客户端消息：" + inputLine);
                out.println("服务器回显：" + inputLine); // 将消息回显给客户端
            }
        }
    }
}

• 客户端 (EchoClient)

import java.io.*;
import java.net.*;

public class EchoClient {
    public static void main(String[] args) throws IOException {
        Socket echoSocket = new Socket("localhost", 9999);
        try (PrintWriter out = new PrintWriter(echoSocket.getOutputStream(), true);
             BufferedReader in = new BufferedReader(new InputStreamReader(echoSocket.getInputStream()));
             BufferedReader stdIn = new BufferedReader(new InputStreamReader(System.in))) {
            System.out.println("请输入要发送给服务器的消息:");
            String userInput;
            while ((userInput = stdIn.readLine()) != null) {
                out.println(userInput);
                System.out.println("收到服务器回显：" + in.readLine());
                System.out.println("请继续输入:");
            }
        }
    }
}

讲解： 先运行 EchoServer，再运行 EchoClient，在客户端的控制台输入消息，你会看到服务器收到并返回了消息。

第十章：通往现代开发 —— 框架学习之路

当你掌握了 Java 语言本身和其核心库后，你就拥有了建造任何东西的能力。但为了不重复造轮子，更快、更好地构建大型应用，我们需要学习框架。

• 什么是框架？ 框架是一个半成品的应用，它为你搭好了骨架，定义了开发的规范和流程。你只需在其中填充你的业务逻辑代码。
• 为什么需要框架？ 它们解决了通用问题，如 Web 服务、数据库访问、安全性等，让你能专注于业务本身，极大地提升了开发效率和软件质量。
• 你应该学什么？
  • Spring Boot: 事实上的行业标准。它极大地简化了 Spring 应用的搭建和开发过程，是 Java 后端开发者的必修课。
  • MyBatis/JPA: 主流的数据库访问框架，帮你优雅地与数据库交互。
  • Spring Cloud: 如果你要构建复杂的分布式系统（微服务），这是你的不二之选。

学习框架，就是将在前面章节学到的所有知识（面向对象、集合、异常、多线程等）进行综合应用的过程。

结语

恭喜你，你已经完成了这次 Java 学习之旅。从一个简单的"Hello World"，到复杂的面向对象设计，再到多线程、网络编程，你已经拥有了一张完整的 Java 知识图谱。

但这绝不是终点，而是一个全新的、更令人兴奋的起点。

最重要的建议： 不断编码，不断实践！理论知识是地图，而你亲手敲下的每一行代码，才是你在这片数字宇宙中前行的脚步。

现在，去创造吧！用你学到的知识，挑战自己，构建一个真正的项目——一个博客、一个在线商城、一个小工具。在实践中，你将真正地将知识内化，从一名 Java 学习者，蜕变为一名真正的 Java 开发者。

你的 Java 开发之旅，才刚刚拉开序幕！