Java 零基础完整入门教程

四、Java 第一个程序 HelloWorld

所有编程语言的入门第一课，都是编写输出 Hello World 的程序，Java 也不例外，我们分记事本手动编译运行和 IDEA 一键运行两种方式。

4.1 记事本编写 + 手动编译运行

Java 是严格区分大小写的语言，且语法规范极强，一个字符都不能错！

步骤 1：新建记事本，编写代码

新建一个 txt 文件，重命名为 HelloWorld.java（后缀必须是 .java，文件名必须和代码中的 class 类名完全一致，包括大小写），写入以下代码：

// 这是 Java 的单行注释：第一个 Java 程序 HelloWorld
public class HelloWorld {
    // main 方法：程序的入口，所有 Java 程序都从 main 方法开始执行，固定写法
    public static void main(String[] args) {
        // 输出语句：控制台打印指定内容，分号是 Java 语句的结束标志，必须加
        System.out.println("Hello World! 你好，Java！");
    }
}

步骤 2：编译 Java 源文件（javac 命令）

打开 cmd，进入 HelloWorld.java 所在的文件夹，执行编译命令：

javac HelloWorld.java

编译成功：文件夹中会新增一个 HelloWorld.class 文件（这就是 Java 的字节码文件，跨平台的核心） 编译失败：大概率是代码写错、大小写错误、少分号，对照修改即可。

步骤 3：运行字节码文件（java 命令）

在同一个 cmd 窗口，执行运行命令（命令里不要加.class 后缀）：

java HelloWorld

运行成功：控制台会打印出 Hello World! 你好，Java！

4.2 核心知识点解释

1. public class 类名：定义一个公共类，文件名必须和类名一致，Java 源文件中可以有多个类，但只能有一个 public 类。
2. public static void main(String[] args)：Java 程序的唯一入口，这个写法是固定的，没有任何例外，必须记住！
3. System.out.println("内容")：向控制台打印内容，打印后自动换行；如果不想换行，用 System.out.print("内容")。
4. 分号 ;：Java 中所有语句必须以分号结尾，这是语法规则，少写必报错。
5. 注释 //：注释是给程序员看的，编译器会忽略，不影响程序运行，单行注释用 //，多行注释用 /* 注释内容 */。

五、Java 基础核心语法

掌握了 HelloWorld，接下来就是 Java 的核心基础语法，这是所有 Java 开发的根基，重中之重，知识点按「从易到难」排序，全部是高频考点和必用知识点。

语法规则前置

1. Java 严格区分大小写（Main 和 main 是两个完全不同的东西）
2. 代码缩进不是语法要求，但必须缩进，增强可读性
3. 大括号 {} 必须成对出现，包裹代码块
4. 语句必须以分号 ; 结束

5.1 变量与数据类型

什么是变量？

变量是程序中用来存储数据的容器，本质是内存中的一块存储空间，通过变量名可以访问这块空间的数据。

Java 数据类型（两大分类，强类型语言）

Java 是强类型语言：变量在定义时，必须指定数据类型，且赋值的类型必须和定义的类型一致，不能随意转换。

① 基本数据类型（8 种，最常用，必须记）

占内存固定，效率高，是 Java 的基础类型，分为 4 类 8 种：

// 1. 整数类型：byte 占 1 字节 范围：-128 ~ 127
// short 占 2 字节 范围：-32768 ~ 32767
// int 占 4 字节 范围：-2^31 ~ 2^31-1 【默认整数类型，最常用】
// long 占 8 字节 范围极大，赋值时结尾必须加 L 例：long num = 10000000000L;
// 2. 浮点类型（小数）：float 占 4 字节 单精度，赋值时结尾必须加 F 例：float price = 9.9F;
// double 占 8 字节 双精度 【默认浮点类型，最常用】例：double pi = 3.1415926;
// 3. 字符类型：char 占 2 字节 存储单个字符，必须用单引号包裹 例：char ch = 'A'; char ch2 = '中';
// 4. 布尔类型（判断真假）：boolean 占 1 字节 只有两个值：true（真）、false（假）【判断语句核心】

② 引用数据类型

字符串、数组、类、接口等，最常用的就是字符串类型 String，用双引号包裹：

String name = "张三";
String address = "北京市朝阳区";

变量的定义格式（固定写法）

// 格式：数据类型 变量名 = 赋值;
int age = 18; // 定义整型变量 age，赋值 18
double score = 95.5; // 定义浮点型变量 score，赋值 95.5
char sex = '男'; // 定义字符型变量 sex，赋值男
boolean flag = true; // 定义布尔型变量 flag，赋值真
String username = "Java 学习者"; // 定义字符串变量

变量命名规范：首字母小写，后面单词首字母大写（驼峰命名），例：studentName、phoneNumber，不能用中文/数字开头。

5.2 运算符（运算的核心，常用）

Java 的运算符和数学中的运算逻辑基本一致，分为几大类，都是高频使用：

算术运算符（加减乘除）

+ - * / % 其中 % 是取模（求余数），例：7%2 = 1、10%3 = 1

int a = 10;
int b = 3;
System.out.println(a + b); // 13
System.out.println(a / b); // 3 （整数相除，只取整数部分）
System.out.println(a % b); // 1 （取余数）

特别：+ 对字符串是「拼接」作用，例：System.out.println("年龄：" + 18); 输出：年龄：18

赋值运算符

= += -= *= /= 最常用的是 =，例：int num = 5;

比较运算符（判断大小，结果是布尔值）

> < >= <= == != 所有比较运算符的结果，只有 true 或 false，是 if 判断、循环的核心

int x = 10;
int y = 20;
System.out.println(x > y); // false
System.out.println(x == y); // false
System.out.println(x != y); // true

逻辑运算符（多条件判断）

&&（与）、||（或）、!（非）

• &&：多个条件同时满足，结果才是 true
• ||：多个条件满足一个，结果就是 true
• !：取反，true 变 false，false 变 true

5.3 流程控制语句（程序的执行逻辑，重中之重）

程序的执行逻辑默认是「顺序执行」：从上到下一行一行执行。而流程控制语句可以改变执行顺序，分为分支语句和循环语句，是所有编程逻辑的核心！

一、分支语句（条件判断，满足条件才执行对应代码）

1. if 语句（最常用，单条件判断）

// 格式 1：单 if
if (条件表达式) {
    条件为 true 时，执行的代码;
}
// 格式 2：if-else 二选一执行
if (条件表达式) {
    条件为 true 时执行的代码;
} else {
    条件为 false 时执行的代码;
}
// 案例：判断年龄是否成年
int age = 20;
if (age >= 18) {
    System.out.println("你已成年");
} else {
    System.out.println("你未成年");
}

2. switch 语句（多值匹配，固定值判断）

适合判断一个变量的多个固定值，比如：判断星期几、判断月份。

二、循环语句（重复执行一段代码，解放双手）

当需要重复执行某段代码时（比如：打印 100 遍 HelloWorld、计算 1-100 的和），用循环语句，三大循环：for、while、do-while，其中 for 循环最常用！

1. for 循环（固定次数循环，首选）

// 格式：for(初始化变量; 循环条件; 变量自增/自减) { 循环体 }
// 案例 1：打印 1-5 的数字
for (int i = 1; i <= 5; i++) {
    System.out.println(i);
}
// 案例 2：计算 1+2+3+...+100 的和
int sum = 0;
for (int i = 1; i <= 100; i++) {
    sum += i; // 等价于 sum = sum + i
}
System.out.println("1-100 的和：" + sum); // 结果：5050

2. while 循环（未知次数循环）

// 格式：while(循环条件) { 循环体 }
// 案例：打印 1-5 的数字
int i = 1;
while (i <= 5) {
    System.out.println(i);
    i++;
}

循环核心：必须有「循环终止条件」，否则会变成死循环，程序一直运行直到崩溃！

5.4 数组（存储多个同类型数据的容器）

数组是 Java 中最基础的引用数据类型，作用是：一次性存储多个相同数据类型的变量，比如：存储一个班级的所有学生成绩、存储 10 个整数。

数组的定义格式（两种常用格式）

// 格式 1：推荐，可读性强 数据类型 [] 数组名 =new 数据类型 [数组长度];
// 格式 2：兼容 C 语言写法，不推荐 数据类型 数组名[]=new 数据类型 [数组长度];
// 案例：定义一个长度为 5 的整型数组，存储 5 个学生的成绩
int[] scores = new int[5];

数组的赋值与访问

数组的索引（下标）从 0 开始，比如长度为 5 的数组，索引是 0、1、2、3、4，通过 数组名 [索引] 访问元素：

int[] scores = new int[5];
scores[0] = 90; // 给第 1 个元素赋值 90
scores[1] = 85; // 给第 2 个元素赋值 85
System.out.println(scores[0]); // 访问第 1 个元素，输出 90
// 简化写法：定义数组时直接赋值（最常用）
int[] nums = {1, 2, 3, 4, 5}; // 长度自动为 5
// 遍历数组：用 for 循环打印所有元素
for (int i = 0; i < nums.length; i++) {
    System.out.println(nums[i]);
}

数组名.length 可以获取数组的长度，是固定写法。

六、Java 面向对象核心（OOP，Java 的灵魂）

Java 是纯面向对象编程语言，万物皆对象，面向对象是 Java 的核心思想，也是 Java 区别于 C 语言（面向过程）的本质，必须理解！

面向过程：关注「步骤」，比如：做饭要先买菜→洗菜→切菜→炒菜，一步一步执行。 面向对象：关注「对象」，比如：找一个「厨师对象」，让厨师去做饭，你只需要调用厨师的「做饭方法」即可，不用关心步骤。

6.1 面向对象的三大核心特征

1. 封装

把对象的属性和行为封装在一起，隐藏内部实现细节，只对外暴露访问接口，提高代码安全性。

例：定义一个「学生类」，属性是姓名、年龄、成绩，行为是学习、考试，这些属性和方法都封装在类中。

2. 继承

子类可以继承父类的属性和方法，减少代码重复，提高代码复用性。

例：「学生类」和「老师类」都继承自「人类」，人类的属性（姓名、年龄）和方法（吃饭、睡觉），学生和老师都可以直接使用。

3. 多态

同一个行为，对于不同的对象，有不同的表现形式，提高代码的扩展性。

例：同样是「吃饭」这个行为，学生吃饭是在食堂，老师吃饭是在教师餐厅，小狗吃饭是啃骨头。

6.2 类与对象（最基础的 OOP 概念，必懂）

核心关系：类是对象的模板，对象是类的实例

• 类：是对一类事物的抽象描述，比如：人类、学生类、手机类，包含「属性（特征）」和「方法（行为）」。
  • 属性：事物的特征，比如：学生的姓名、年龄、成绩。
  • 方法：事物的行为，比如：学生的学习 ()、考试 ()、跑步 ()。
• 对象：是类的具体实例，比如：张三是「学生类」的一个对象，李四也是「学生类」的一个对象。

类的定义与对象的创建（固定写法，必写）

// 1. 定义一个学生类（模板）
public class Student {
    // 1.1 定义属性（成员变量）
    String name; // 姓名
    int age; // 年龄
    double score; // 成绩
    // 1.2 定义方法（成员方法）
    public void study() {
        System.out.println(name + "正在学习 Java！");
    }
    public void exam() {
        System.out.println(name + "正在考试，成绩是：" + score);
    }
}
// 2. 创建对象并使用（main 方法中执行）
public class Test {
    public static void main(String[] args) {
        // 格式：类名 对象名 = new 类名 ();
        Student stu1 = new Student();
        // 给对象的属性赋值
        stu1.name = "张三";
        stu1.age = 18;
        stu1.score = 98.5;
        // 调用对象的方法
        stu1.study(); // 输出：张三正在学习 Java！
        stu1.exam(); // 输出：张三正在考试，成绩是：98.5
    }
}

这就是 Java 面向对象的基础，所有 Java 项目的代码，都是由一个个「类」和「对象」组成的！

七、Java 入门必做的小实战案例（巩固知识点）

学完基础语法后，一定要做实战案例，只有动手写，才能真正掌握，以下案例由浅入深，全部是入门级必做，覆盖所有核心基础：

1. 计算圆的面积和周长（使用浮点类型、变量、公式）
2. 判断一个数是奇数还是偶数（使用 if 语句、取模运算符）
3. 打印九九乘法表（使用双层 for 循环，经典入门题）
4. 找出数组中的最大值和最小值（数组 + 循环 + 判断）
5. 定义一个「手机类」，包含品牌、价格属性，打电话、发短信方法，创建对象调用（面向对象入门）

八、Java 学习路线规划（零基础→入门→进阶，清晰指引）

阶段一：基础入门（你当前的阶段，1-2 周）

完成以上所有内容：环境搭建 → HelloWorld → 基础语法（变量、运算符、流程控制、数组）→ 面向对象基础（类、对象、三大特征），能独立写简单的案例程序。

阶段二：Java 核心进阶（2-3 周）

面向对象深入（构造方法、封装、继承、多态、抽象类、接口）→ 常用 API（字符串 String、集合框架 ArrayList）→ 异常处理 → IO 流（文件读写），这个阶段是 Java 的核心，学完能写中小型 Java 项目。

阶段三：Java 后端开发（就业方向，重点）

MySQL 数据库 → JDBC 连接数据库 → Web 开发（HTML/CSS/JS、Servlet、SSM 框架）→ 微服务（SpringBoot、SpringCloud），这是 Java 最主流的就业方向，市场需求大、薪资高。

总结

这份 Java 教程是零基础专属完整版，核心知识点总结如下：

1. Java 的核心优势是「跨平台、面向对象、安全稳定」，JVM 是跨平台的核心。
2. 开发 Java 必须安装 JDK，第一个程序 HelloWorld 的编译命令 javac，运行命令 java，必须掌握。
3. Java 是强类型语言，8 种基本数据类型是基础，流程控制（if/for）是编程逻辑核心。
4. Java 的灵魂是「面向对象」，类和对象是基础，三大特征（封装、继承、多态）是核心。
5. 学习 Java 的核心法则：多看、多写、多练，语法背会没用，只有动手敲代码，才能真正掌握！