Java 从入门到高级实战全套教程

原创于 2026-05-25 17:42:05 发布 · 358 阅读

9 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

标签

#java #开发语言

Java 从基础到高级完整学习手册

一、Java 简介

Java 是一种面向对象、高性能、跨平台的编程语言。

Java 的核心特点：

一次编写，到处运行（Write Once Run Anywhere）
面向对象
安全性高
拥有强大的生态
企业级开发首选语言之一

Java 广泛应用于：

后端开发
Android 开发
大数据开发
游戏服务端
企业系统
金融系统
云计算

二、Java 开发环境搭建

1. 安装 JDK

JDK（Java Development Kit）是 Java 开发工具包。

推荐版本：

JDK 17（长期支持版）
JDK 21（最新长期支持版）

官方地址：

2. 配置环境变量

配置：

JAVA_HOME
Path

测试是否成功：

java -version
javac -version

三、第一个 Java 程序

// public 表示公共类
public class Main {

    // main 是程序入口
    public static void main(String[] args) {

        // 输出内容到控制台
        System.out.println("Hello Java");
    }
}

四、Java 基础语法

1. 变量

变量用于存储数据。

public class Main {
    public static void main(String[] args) {

        // 整数类型
        int age = 18;

        // 小数类型
        double price = 99.9;

        // 字符类型
        char gender = '男';

        // 布尔类型
        boolean flag = true;

        // 字符串类型
        String name = "张三";

        System.out.println(age);
        System.out.println(price);
        System.out.println(gender);
        System.out.println(flag);
        System.out.println(name);
    }
}

2. 数据类型

基本数据类型

类型	大小	示例
byte 字节	1字节	byte a = 1
short 短整数	2字节	short a = 10
int 整数	4字节	int a = 100
long 长整数	8字节	long a = 100L
float 单精度浮点型	4字节	float a = 1.2F
double 双精度浮点型	8字节	double a = 3.14
char 字符	2字节	char a = ‘A’
boolean 布尔类型	1位	true/false

3. 运算符

算术运算符

public class Main {
    public static void main(String[] args) {

        int a = 10;
        int b = 3;

        // 加法
        System.out.println(a + b);

        // 减法
        System.out.println(a - b);

        // 乘法
        System.out.println(a * b);

        // 除法
        System.out.println(a / b);

        // 取余
        System.out.println(a % b);
    }
}

4. 输入输出

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {

        // 创建输入对象
        Scanner sc = new Scanner(System.in);

        // 提示用户输入
        System.out.println("请输入名字：");

        // 接收字符串
        String name = sc.nextLine();

        System.out.println("你好：" + name);
    }
}

五、流程控制

1. if 判断

public class Main {
    public static void main(String[] args) {

        int age = 20;

        // 判断年龄
        if (age >= 18) {
            System.out.println("成年");
        } else {
            System.out.println("未成年");
        }
    }
}

2. switch

public class Main {
    public static void main(String[] args) {

        int day = 3;

        switch (day) {
            case 1:
                System.out.println("星期一");
                break;

            case 2:
                System.out.println("星期二");
                break;

            case 3:
                System.out.println("星期三");
                break;

            default:
                System.out.println("未知");
        }
    }
}

3. for 循环

public class Main {
    public static void main(String[] args) {

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

4. while 循环

public class Main {
    public static void main(String[] args) {

        int i = 1;

        while (i <= 5) {
            System.out.println(i);
            i++;
        }
    }
}

六、数组

1. 一维数组

public class Main {
    public static void main(String[] args) {

        // 创建数组
        int[] nums = {1, 2, 3, 4, 5};

        // 输出数组元素
        System.out.println(nums[0]);
        System.out.println(nums[1]);

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

2. 二维数组

public class Main {
    public static void main(String[] args) {

        int[][] arr = {
                {1, 2},
                {3, 4},
                {5, 6}
        };

        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
    }
}

七、方法（函数）

1. 方法定义

public class Main {

    // 定义加法方法
    public static int add(int a, int b) {
        return a + b;
    }

    public static void main(String[] args) {

        // 调用方法
        int result = add(10, 20);

        System.out.println(result);
    }
}

2. 方法重载

public class Main {

    // int 类型加法
    public static int add(int a, int b) {
        return a + b;
    }

    // double 类型加法
    public static double add(double a, double b) {
        return a + b;
    }

    public static void main(String[] args) {

        System.out.println(add(1, 2));
        System.out.println(add(1.5, 2.5));
    }
}

八、面向对象编程 OOP

1. 类与对象

// 定义学生类
class Student {

    // 属性
    String name;
    int age;

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

public class Main {
    public static void main(String[] args) {

        // 创建对象
        Student s = new Student();

        // 给属性赋值
        s.name = "小明";
        s.age = 18;

        // 调用方法
        s.study();
    }
}

2. 构造方法

class Person {

    String name;
    int age;

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

    public void show() {
        System.out.println(name + " " + age);
    }
}

public class Main {
    public static void main(String[] args) {

        Person p = new Person("张三", 20);

        p.show();
    }
}

3. 封装

class User {

    // 私有属性
    private String password;

    // 设置密码
    public void setPassword(String password) {
        this.password = password;
    }

    // 获取密码
    public String getPassword() {
        return password;
    }
}

public class Main {
    public static void main(String[] args) {

        User u = new User();

        u.setPassword("123456");

        System.out.println(u.getPassword());
    }
}

4. 继承

// 父类
class Animal {

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

// 子类
class Dog extends Animal {

    public void bark() {
        System.out.println("狗在叫");
    }
}

public class Main {
    public static void main(String[] args) {

        Dog d = new Dog();

        d.eat();
        d.bark();
    }
}

5. 多态

class Animal {
    public void sound() {
        System.out.println("动物叫声");
    }
}

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

public class Main {
    public static void main(String[] args) {

        // 父类引用指向子类对象
        Animal a = new Cat();

        a.sound();
    }
}

6. 抽象类

// 抽象类
abstract class Shape {

    // 抽象方法
    public abstract double area();
}

class Circle extends Shape {

    double r;

    public Circle(double r) {
        this.r = r;
    }

    @Override
    public double area() {
        return 3.14 * r * r;
    }
}

public class Main {
    public static void main(String[] args) {

        Circle c = new Circle(5);

        System.out.println(c.area());
    }
}

7. 接口

// 定义接口
interface Fly {

    void fly();
}

class Bird implements Fly {

    @Override
    public void fly() {
        System.out.println("鸟在飞");
    }
}

public class Main {
    public static void main(String[] args) {

        Bird b = new Bird();

        b.fly();
    }
}

九、字符串 String

1. 常用方法

方法	作用
length()	获取长度
charAt()	获取字符
equals()	比较字符串
contains()	是否包含
substring()	截取字符串
replace()	替换字符串
toUpperCase()	转大写
toLowerCase()	转小写
trim()	去空格

2. 示例

public class Main {
    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.contains("Java"));
        System.out.println(str.substring(0, 5));
    }
}

十、集合框架

1. ArrayList

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {

        // 创建集合
        ArrayList<String> list = new ArrayList<>();

        // 添加元素
        list.add("Java");
        list.add("Python");
        list.add("Go");

        // 遍历集合
        for (String item : list) {
            System.out.println(item);
        }
    }
}

2. HashMap

import java.util.HashMap;

public class Main {
    public static void main(String[] args) {

        HashMap<String, Integer> map = new HashMap<>();

        // 添加键值对
        map.put("张三", 18);
        map.put("李四", 20);

        // 获取数据
        System.out.println(map.get("张三"));

        // 遍历
        for (String key : map.keySet()) {
            System.out.println(key + " : " + map.get(key));
        }
    }
}

十一、异常处理

1. try-catch

public class Main {
    public static void main(String[] args) {

        try {

            int a = 10 / 0;

            System.out.println(a);

        } catch (Exception e) {

            // 捕获异常
            System.out.println("程序异常：" + e.getMessage());
        }
    }
}

2. 自定义异常

// 自定义异常
class AgeException extends Exception {

    public AgeException(String msg) {
        super(msg);
    }
}

public class Main {

    public static void checkAge(int age) throws AgeException {

        if (age < 18) {
            throw new AgeException("年龄不合法");
        }
    }

    public static void main(String[] args) {

        try {
            checkAge(16);
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }
}

十二、文件操作 IO

1. 文件读取

import java.io.FileReader;

public class Main {
    public static void main(String[] args) {

        try {

            FileReader fr = new FileReader("test.txt");

            int data;

            while ((data = fr.read()) != -1) {
                System.out.print((char) data);
            }

            fr.close();

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

十三、多线程

1. 创建线程

// 继承 Thread 类
class MyThread extends Thread {

    @Override
    public void run() {

        // 线程执行内容
        for (int i = 1; i <= 5; i++) {
            System.out.println(i);
        }
    }
}

public class Main {
    public static void main(String[] args) {

        MyThread t = new MyThread();

        // 启动线程
        t.start();
    }
}

十四、Lambda 表达式

interface Test {
    void show();
}

public class Main {
    public static void main(String[] args) {

        // Lambda 写法
        Test t = () -> {
            System.out.println("Lambda 表达式");
        };

        t.show();
    }
}

十五、Stream 流

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {

        Arrays.asList(1, 2, 3, 4, 5)
                .stream()
                .filter(x -> x > 2)
                .forEach(System.out::println);
    }
}

十六、泛型

class Box<T> {

    private T value;

    public void setValue(T value) {
        this.value = value;
    }

    public T getValue() {
        return value;
    }
}

public class Main {
    public static void main(String[] args) {

        Box<String> box = new Box<>();

        box.setValue("Java");

        System.out.println(box.getValue());
    }
}

十七、JDBC 数据库操作

1. JDBC 连接 MySQL

import java.sql.Connection;
import java.sql.DriverManager;

public class Main {
    public static void main(String[] args) {

        try {

            // 数据库地址
            String url = "jdbc:mysql://localhost:3306/test";

            // 用户名
            String user = "root";

            // 密码
            String password = "123456";

            // 获取连接
            Connection conn = DriverManager.getConnection(url, user, password);

            System.out.println("数据库连接成功");

            conn.close();

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

十八、Java 常用 API

API	作用
Math	数学运算
Arrays	数组操作
Collections	集合工具类
Date	日期处理
LocalDateTime	新日期API
Scanner	输入
Random	随机数
Files	文件操作

十九、Java 高级知识

1. 反射

class User {
    public String name;
}

public class Main {
    public static void main(String[] args) throws Exception {

        // 获取 Class 对象
        Class<?> clazz = Class.forName("User");

        // 创建对象
        Object obj = clazz.newInstance();

        System.out.println(obj);
    }
}

2. 注解

class Demo {

    @Deprecated
    public void test() {
        System.out.println("旧方法");
    }
}

二十、Java 项目开发方向

1. Java Web

技术：

Servlet
JSP
Tomcat

2. Spring 全家桶

核心框架：

Spring
Spring MVC
Spring Boot
Spring Cloud

3. 微服务

常见组件：

Nacos
Gateway
OpenFeign
Redis
RabbitMQ

二十一、Java 学习路线

第一阶段

Java 基础
面向对象
数组
集合
方法

第二阶段

IO
多线程
网络编程
JDBC
数据结构

第三阶段

Maven
Git
Linux
MySQL
Spring Boot

第四阶段

微服务
Redis
Docker
Kubernetes
JVM 调优

二十二、Java 面试高频题

1. String 和 StringBuilder 区别？

String

不可变对象
每次修改都会创建新对象
性能较低

StringBuilder

可变对象
适合频繁拼接
性能高

2. == 和 equals 区别？

==

比较地址。

equals

比较内容。

3. ArrayList 和 LinkedList 区别？

集合	特点
ArrayList	查询快
LinkedList	增删快

4. HashMap 原理

核心结构：

数组
链表
红黑树

5. 什么是多态？

同一个父类引用，指向不同子类对象。

二十三、JVM 基础

JVM 组成

方法区
堆
栈
程序计数器
本地方法栈

垃圾回收 GC

常见算法：

标记清除
复制算法
标记整理

二十四、Maven 基础

pom.xml 示例

<project>
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.demo</groupId>
    <artifactId>java-demo</artifactId>
    <version>1.0</version>

    <dependencies>

        <!-- mysql 驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.33</version>
        </dependency>

    </dependencies>
</project>

二十五、Spring Boot 入门

Controller 示例

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {

    @GetMapping("/hello")
    public String hello() {

        return "Hello Spring Boot";
    }
}

二十六、Redis 基础

Redis 特点

高性能
内存数据库
常用于缓存

二十七、Docker 基础

常用命令

# 查看镜像
docker images

# 查看容器
docker ps

# 启动容器
docker start 容器ID

二十八、Java 学习建议

新手阶段

重点：

基础语法
面向对象
多写代码

进阶阶段

重点：

集合源码
JVM
多线程
Spring Boot

高级阶段

重点：

微服务
分布式
高并发
性能优化
架构设计

二十九、推荐开发工具

工具	用途
IntelliJ IDEA	Java 开发
Maven	项目管理
Git	版本控制
Navicat	数据库管理
Postman	API 测试
Docker	容器化

三十、推荐学习资源

官方文档

学习网站

三十一、常见专业术语解释

1. JDK

JDK（Java Development Kit）就是 Java 开发工具包。

简单理解：

安装 JDK 后才能开发 Java
里面包含编译工具和运行环境

官方下载：

https://www.oracle.com/java/

OpenJDK：

https://openjdk.org/

2. JVM

JVM（Java Virtual Machine）叫 Java 虚拟机。

简单理解：

Java 程序并不是直接运行在电脑上的，而是运行在 JVM 中。

这也是 Java 可以跨平台运行的原因。

例如：

Windows
Linux
macOS

只要安装 JVM，都可以运行 Java。

3. JRE

JRE（Java Runtime Environment）是 Java 运行环境。

简单理解：

JRE 负责运行 Java 程序
JDK 负责开发 Java 程序

JDK 中包含 JRE。

4. Maven

Maven 是 Java 项目管理工具。

作用：

下载依赖
管理项目
自动构建

官网：

https://maven.apache.org/

5. Spring Boot

Spring Boot 是目前最流行的 Java 后端框架之一。

简单理解：

它帮助开发者快速开发网站和接口。

官网：

https://spring.io/projects/spring-boot

6. API

API（Application Programming Interface）叫应用程序接口。

简单理解：

程序与程序之间沟通的方法。

例如：

登录接口
支付接口
天气接口

7. JDBC

JDBC 是 Java 连接数据库的技术。

简单理解：

Java 通过 JDBC 操作 MySQL 数据库。

MySQL 官网：

https://www.mysql.com/

8. SQL

SQL 是数据库查询语言。

简单理解：

通过 SQL 可以：

查询数据
添加数据
删除数据
修改数据

例如：

SELECT * FROM users;

9. Git

Git 是版本控制工具。

简单理解：

用于管理代码版本。

例如：

回退代码
团队协作
上传 GitHub

官网：

https://git-scm.com/

GitHub：

https://github.com/

10. Docker

Docker 是容器化工具。

简单理解：

可以把程序和运行环境一起打包。

作用：

快速部署
环境统一
方便运维

官网：

https://www.docker.com/

11. Redis

Redis 是高性能缓存数据库。

简单理解：

数据存储在内存中，速度极快。

常用于：

登录缓存
热门数据
秒杀系统

官网：

https://redis.io/

12. Tomcat

Tomcat 是 Java Web 服务器。

简单理解：

用于运行 Java 网站项目。

官网：

https://tomcat.apache.org/

13. JSON

JSON 是一种数据交换格式。

简单理解：

前后端传输数据最常见的格式。

示例：

{
  "name": "张三",
  "age": 18
}

14. 微服务

微服务是一种大型项目开发架构。

简单理解：

把一个大项目拆成多个小项目。

优点：

更容易维护
更容易扩展
支持多人开发

15. ORM

ORM（对象关系映射）是一种数据库操作思想。

简单理解：

通过 Java 对象操作数据库，而不是直接写 SQL。

常见框架：

MyBatis
Hibernate
JPA

三十二、推荐学习视频与文档

Java 学习网站

菜鸟教程：

https://www.runoob.com/java/java-tutorial.html

牛客网：

https://www.nowcoder.com/

LeetCode：

https://leetcode.cn/

GitHub：

https://github.com/

IntelliJ IDEA 下载

https://www.jetbrains.com/idea/

OpenJDK 下载

https://jdk.java.net/

三十三、总结

Java 是一门生态极其完善的语言。

从基础到高级建议学习顺序：

Java 基础
面向对象
集合与IO
多线程
JDBC
JVM
Spring Boot
微服务
分布式架构

学习 Java 最重要的是：

多写代码
多做项目
多看源码
多总结

坚持学习，才能真正掌握 Java。