代码收藏家技术教程 2025-02-11

【Java基础篇】——第2篇：Java语法基础

第2篇：Java语法基础

2.1 引言

在上一篇中，我们介绍了Java的基本概念、应用场景以及如何搭建开发环境。本篇将深入探讨Java的语法基础，涵盖变量与数据类型、运算符、控制结构、数组、方法、面向对象编程的进一步内容、异常处理以及常用的编程规范。通过本篇内容，读者将能够编写基本的Java程序，理解其核心语法结构。

2.2 Java的基本组成

Java程序由以下几个基本组成部分构成：

包（Package）：用于组织类和接口，类似于文件夹。
类（Class）：Java的基本构建单元，包含属性和方法。
方法（Method）：实现特定功能的代码块。
变量（Variable）：用于存储数据的命名空间。
语句（Statement）：执行特定操作的指令。

2.3 数据类型与变量

Java是一种强类型语言，这意味着每个变量在使用前必须声明其数据类型。Java的数据类型分为两大类：基本数据类型（Primitive Types）和引用数据类型（Reference Types）。

2.3.1 基本数据类型

Java有8种基本数据类型：

整数类型
byte：1字节，范围：-128 到 127
short：2字节，范围：-32,768 到 32,767
int：4字节，范围：-2,147,483,648 到 2,147,483,647
long：8字节，范围：-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807
浮点类型
float：4字节，单精度浮点数，需在数值后加f或F
double：8字节，双精度浮点数
字符类型
char：2字节，单个Unicode字符，例如 'A'、'中'
布尔类型
boolean：1字节，取值true或false

2.3.2 引用数据类型

引用数据类型包括类（Class）、接口（Interface）、数组（Array）等。它们存储的是对象的引用，而不是实际的值。

2.3.3 变量的声明与初始化

变量在使用前必须声明，可以在声明时初始化，也可以在后续赋值。

public class VariableExample {
    public static void main(String[] args) {
        // 声明并初始化变量
        int number = 10;
        double price = 19.99;
        char grade = 'A';
        boolean isJavaFun = true;

        // 声明变量后赋值
        int age;
        age = 25;

        // 输出变量的值
        System.out.println("Number: " + number);
        System.out.println("Price: " + price);
        System.out.println("Grade: " + grade);
        System.out.println("Is Java Fun? " + isJavaFun);
        System.out.println("Age: " + age);
    }
}

输出：

Number: 10
Price: 19.99
Grade: A
Is Java Fun? true
Age: 25

2.3.4 常量

使用final关键字可以声明常量，一旦赋值后无法修改。

public class ConstantExample {
    public static void main(String[] args) {
        final double PI = 3.14159;
        // PI = 3.14; // 编译错误：cannot assign a value to final variable PI
        System.out.println("PI: " + PI);
    }
}

2.4 运算符

Java提供了丰富的运算符，用于执行各种操作。主要包括以下几类：

2.4.1 算术运算符

用于执行基本的数学运算。

运算符	描述	示例	结果
`+`	加法	`5 + 3`	`8`
`-`	减法	`5 - 3`	`2`
`*`	乘法	`5 * 3`	`15`
`/`	除法	`6 / 3`	`2`
`%`	取模（取余）	`5 % 2`	`1`

示例：

public class ArithmeticOperatorExample {
    public static void main(String[] args) {
        int a = 10, b = 3;

        System.out.println("a + b = " + (a + b)); // 13
        System.out.println("a - b = " + (a - b)); // 7
        System.out.println("a * b = " + (a * b)); // 30
        System.out.println("a / b = " + (a / b)); // 3
        System.out.println("a % b = " + (a % b)); // 1
    }
}

2.4.2 关系运算符

用于比较两个变量或值。

运算符	描述	示例	结果
`==`	等于	`5 == 5`	`true`
`!=`	不等于	`5 != 3`	`true`
`>`	大于	`5 > 3`	`true`
`<`	小于	`5 < 3`	`false`
`>=`	大于等于	`5 >= 5`	`true`
`<=`	小于等于	`3 <= 5`	`true`

示例：

public class RelationalOperatorExample {
    public static void main(String[] args) {
        int a = 10, b = 20;

        System.out.println("a == b: " + (a == b)); // false
        System.out.println("a != b: " + (a != b)); // true
        System.out.println("a > b: " + (a > b));   // false
        System.out.println("a < b: " + (a < b));   // true
        System.out.println("a >= 10: " + (a >= 10)); // true
        System.out.println("b <= 20: " + (b <= 20)); // true
    }
}

2.4.3 逻辑运算符

用于组合多个条件。

运算符	描述	示例	结果
`&&`	逻辑与（AND）	`true && false`	`false`
`		`	逻辑或（OR）
`!`	逻辑非（NOT）	`!true`	`false`
`^`	逻辑异或（XOR）	`true ^ false`	`true`
`&`	位与（按位与，用于布尔也可以）	`true & false`	`false`
`	`	位或（按位或，用于布尔也可以）	`true

示例：

public class LogicalOperatorExample {
    public static void main(String[] args) {
        boolean x = true;
        boolean y = false;

        System.out.println("x && y: " + (x && y)); // false
        System.out.println("x || y: " + (x || y)); // true
        System.out.println("!x: " + (!x));         // false
        System.out.println("x ^ y: " + (x ^ y));   // true
        System.out.println("x & y: " + (x & y));   // false
        System.out.println("x | y: " + (x | y));   // true
    }
}

2.4.4 赋值运算符

用于给变量赋值。

运算符	描述	示例
`=`	简单赋值	`x = 10`
`+=`	加后赋值	`x += 5` 等同于 `x = x + 5`
`-=`	减后赋值	`x -= 5` 等同于 `x = x - 5`
`*=`	乘后赋值	`x = 5` 等同于 `x = x 5`
`/=`	除后赋值	`x /= 5` 等同于 `x = x / 5`
`%=`	取模后赋值	`x %= 5` 等同于 `x = x % 5`

示例：

public class AssignmentOperatorExample {
    public static void main(String[] args) {
        int x = 10;

        x += 5; // x = x + 5
        System.out.println("x += 5: " + x); // 15

        x -= 3; // x = x - 3
        System.out.println("x -= 3: " + x); // 12

        x *= 2; // x = x * 2
        System.out.println("x *= 2: " + x); // 24

        x /= 4; // x = x / 4
        System.out.println("x /= 4: " + x); // 6

        x %= 5; // x = x % 5
        System.out.println("x %= 5: " + x); // 1
    }
}

2.4.5 位运算符

用于对整数的位进行操作。

运算符	描述	示例
`<<`	左移位	`x << 2`
`>>`	带符号右移位	`x >> 2`
`>>>`	无符号右移位	`x >>> 2`
`&`	按位与	`x & y`
`	`	按位或
`^`	按位异或	`x ^ y`
`~`	按位取反	`~x`

示例：

public class BitwiseOperatorExample {
    public static void main(String[] args) {
        int a = 5;  // 二进制: 0101
        int b = 3;  // 二进制: 0011

        System.out.println("a & b: " + (a & b));   // 1 (0001)
        System.out.println("a | b: " + (a | b));   // 7 (0111)
        System.out.println("a ^ b: " + (a ^ b));   // 6 (0110)
        System.out.println("~a: " + (~a));         // -6 (补码表示)
        System.out.println("a << 1: " + (a << 1)); // 10 (1010)
        System.out.println("a >> 1: " + (a >> 1)); // 2 (0010)
        System.out.println("a >>> 1: " + (a >>> 1)); // 2 (0010)
    }
}

2.5 控制结构

控制结构用于控制程序的执行流程，包括条件判断和循环结构。

2.5.1 条件语句

2.5.1.1 `if` 语句

if语句用于根据条件执行不同的代码块。

public class IfExample {
    public static void main(String[] args) {
        int num = 10;

        if (num > 0) {
            System.out.println("正数");
        } else if (num < 0) {
            System.out.println("负数");
        } else {
            System.out.println("零");
        }
    }
}

输出：

正数

2.5.1.2 `switch` 语句

switch语句用于基于变量的不同值执行不同的代码块。

public class SwitchExample {
    public static void main(String[] args) {
        int day = 3;
        String dayName;

        switch (day) {
            case 1:
                dayName = "星期一";
                break;
            case 2:
                dayName = "星期二";
                break;
            case 3:
                dayName = "星期三";
                break;
            case 4:
                dayName = "星期四";
                break;
            case 5:
                dayName = "星期五";
                break;
            case 6:
                dayName = "星期六";
                break;
            case 7:
                dayName = "星期日";
                break;
            default:
                dayName = "无效的日期";
        }

        System.out.println("今天是: " + dayName);
    }
}

输出：

今天是: 星期三

2.5.2 循环语句

循环语句用于重复执行代码块，直到条件不满足为止。

2.5.2.1 `for` 循环

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

public class ForLoopExample {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {
            System.out.println("循环次数: " + i);
        }
    }
}

输出：

循环次数: 1
循环次数: 2
循环次数: 3
循环次数: 4
循环次数: 5

2.5.2.2 `while` 循环

while循环在满足条件时持续执行，适用于循环次数未知的场景。

public class WhileLoopExample {
    public static void main(String[] args) {
        int i = 1;
        while (i <= 5) {
            System.out.println("循环次数: " + i);
            i++;
        }
    }
}

输出：

循环次数: 1
循环次数: 2
循环次数: 3
循环次数: 4
循环次数: 5

2.5.2.3 `do-while` 循环

do-while循环至少执行一次，然后根据条件决定是否继续。

public class DoWhileLoopExample {
    public static void main(String[] args) {
        int i = 1;
        do {
            System.out.println("循环次数: " + i);
            i++;
        } while (i <= 5);
    }
}

输出：

循环次数: 1
循环次数: 2
循环次数: 3
循环次数: 4
循环次数: 5

2.5.3 跳转语句

跳转语句用于改变程序的执行流程。

break：终止当前循环或switch语句。

continue：跳过当前循环的剩余部分，进入下一次循环。

示例：使用 break 和 continue

public class JumpStatementExample {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {
            if (i == 3) {
                break; // 当i为3时，终止循环
            }
            System.out.println("i = " + i);
        }

        System.out.println("-------------");

        for (int i = 1; i <= 5; i++) {
            if (i == 3) {
                continue; // 当i为3时，跳过本次循环
            }
            System.out.println("i = " + i);
        }
    }
}

输出：

i = 1
i = 2
-------------
i = 1
i = 2
i = 4
i = 5

2.6 数组

数组是用于存储固定大小的同类型元素的容器。Java中的数组是对象，具有固定的长度，并且可以存储基本数据类型或引用数据类型的元素。

2.6.1 一维数组

声明与初始化：

public class SingleDimensionalArrayExample {
    public static void main(String[] args) {
        // 声明并初始化数组
        int[] numbers = {1, 2, 3, 4, 5};

        // 访问数组元素
        System.out.println("第一个元素: " + numbers[0]); // 输出 1

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

        // 使用增强型for循环
        System.out.println("使用增强型for循环:");
        for (int num : numbers) {
            System.out.println(num);
        }
    }
}

输出：

第一个元素: 1
数组元素:
1
2
3
4
5
使用增强型for循环:
1
2
3
4
5

2.6.2 多维数组

Java支持多维数组，最常用的是二维数组。

示例：二维数组

public class MultiDimensionalArrayExample {
    public static void main(String[] args) {
        // 声明并初始化二维数组
        int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };

        // 访问二维数组元素
        System.out.println("matrix[1][2] = " + matrix[1][2]); // 输出 6

        // 遍历二维数组
        System.out.println("二维数组元素:");
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[i].length; j++) {
                System.out.print(matrix[i][j] + " ");
            }
            System.out.println();
        }

        // 使用增强型for循环
        System.out.println("使用增强型for循环遍历二维数组:");
        for (int[] row : matrix) {
            for (int num : row) {
                System.out.print(num + " ");
            }
            System.out.println();
        }
    }
}

输出：

matrix[1][2] = 6
二维数组元素:
1 2 3 
4 5 6 
7 8 9 
使用增强型for循环遍历二维数组:
1 2 3 
4 5 6 
7 8 9

2.6.3 动态数组（ArrayList）

虽然Java中的数组长度固定，但Java提供了ArrayList类，允许动态调整数组大小。

示例：使用ArrayList

import java.util.ArrayList;

public class ArrayListExample {
    public static void main(String[] args) {
        // 创建一个ArrayList
        ArrayList<String> fruits = new ArrayList<>();

        // 添加元素
        fruits.add("苹果");
        fruits.add("香蕉");
        fruits.add("橙子");

        // 访问元素
        System.out.println("第一个水果: " + fruits.get(0)); // 输出 苹果

        // 遍历ArrayList
        System.out.println("所有水果:");
        for (String fruit : fruits) {
            System.out.println(fruit);
        }

        // 修改元素
        fruits.set(1, "草莓");
        System.out.println("修改后的水果列表:");
        for (String fruit : fruits) {
            System.out.println(fruit);
        }

        // 删除元素
        fruits.remove(0);
        System.out.println("删除后的水果列表:");
        for (String fruit : fruits) {
            System.out.println(fruit);
        }

        // 获取ArrayList的大小
        System.out.println("ArrayList的大小: " + fruits.size());
    }
}

输出：

第一个水果: 苹果
所有水果:
苹果
香蕉
橙子
修改后的水果列表:
苹果
草莓
橙子
删除后的水果列表:
草莓
橙子
ArrayList的大小: 2

2.7 方法

方法是Java程序中的功能模块，用于执行特定的任务。方法可以接受参数，并且可以返回一个值。

2.7.1 方法的声明与调用

示例：定义并调用方法

public class MethodExample {
    // 定义一个无返回值的方法
    public static void greet() {
        System.out.println("Hello, World!");
    }

    // 定义一个带参数的方法
    public static void greetWithName(String name) {
        System.out.println("Hello, " + name + "!");
    }

    // 定义一个有返回值的方法
    public static int add(int a, int b) {
        return a + b;
    }

    public static void main(String[] args) {
        // 调用无返回值的方法
        greet(); // 输出: Hello, World!

        // 调用带参数的方法
        greetWithName("Alice"); // 输出: Hello, Alice!

        // 调用有返回值的方法
        int sum = add(5, 7);
        System.out.println("5 + 7 = " + sum); // 输出: 5 + 7 = 12
    }
}

2.7.2 方法重载（Method Overloading）

方法重载是指在同一个类中，可以定义多个方法名相同但参数列表不同的方法。

示例：方法重载

public class OverloadedMethods {
    // 重载方法：无参数
    public void display() {
        System.out.println("Display without parameters");
    }

    // 重载方法：一个参数
    public void display(String message) {
        System.out.println("Display with message: " + message);
    }

    // 重载方法：两个参数
    public void display(String message, int number) {
        System.out.println("Display with message: " + message + " and number: " + number);
    }

    public static void main(String[] args) {
        OverloadedMethods om = new OverloadedMethods();

        om.display(); // 输出: Display without parameters
        om.display("Hello"); // 输出: Display with message: Hello
        om.display("Number", 10); // 输出: Display with message: Number and number: 10
    }
}

输出：

Display without parameters
Display with message: Hello
Display with message: Number and number: 10

2.8 面向对象编程（OOP）基础

在第一篇中，我们介绍了面向对象编程（OOP）的基本概念。本节将进一步探讨类与对象的细节，包括构造方法、this关键字、static关键字、访问修饰符等。

2.8.1 构造方法（Constructors）

构造方法是用于创建对象时初始化对象的特殊方法。其名称与类名相同，并且没有返回类型。

示例：定义构造方法

class Car {
    String model;
    int year;

    // 无参数的构造方法
    public Car() {
        this.model = "未知型号";
        this.year = 2020;
    }

    // 带参数的构造方法
    public Car(String model, int year) {
        this.model = model;
        this.year = year;
    }

    public void displayInfo() {
        System.out.println("型号: " + model + ", 年份: " + year);
    }
}

public class ConstructorExample {
    public static void main(String[] args) {
        // 使用无参数构造方法创建对象
        Car car1 = new Car();
        car1.displayInfo(); // 输出: 型号: 未知型号, 年份: 2020

        // 使用带参数构造方法创建对象
        Car car2 = new Car("Toyota", 2021);
        car2.displayInfo(); // 输出: 型号: Toyota, 年份: 2021
    }
}

输出：

型号: 未知型号, 年份: 2020
型号: Toyota, 年份: 2021

2.8.2 `this`关键字

this关键字指向当前对象的引用，用于区分类的属性与方法的参数或局部变量。

示例：使用this关键字

class Person {
    String name;
    int age;

    public Person(String name, int age) {
        this.name = name; // 区分属性和参数
        this.age = age;
    }

    public void displayInfo() {
        System.out.println("姓名: " + this.name + ", 年龄: " + this.age);
    }
}

public class ThisKeywordExample {
    public static void main(String[] args) {
        Person person = new Person("Alice", 30);
        person.displayInfo(); // 输出: 姓名: Alice, 年龄: 30
    }
}

2.8.3 `static`关键字

static关键字用于声明类级别的成员，即不依赖于对象实例。静态成员可以通过类名直接访问，无需创建对象。

示例：使用static关键字

class MathUtils {
    // 静态变量
    public static final double PI = 3.14159;

    // 静态方法
    public static int square(int num) {
        return num * num;
    }
}

public class StaticKeywordExample {
    public static void main(String[] args) {
        // 访问静态变量
        System.out.println("PI: " + MathUtils.PI); // 输出: PI: 3.14159

        // 调用静态方法
        int result = MathUtils.square(5);
        System.out.println("5的平方: " + result); // 输出: 5的平方: 25
    }
}

2.8.4 访问修饰符

访问修饰符用于控制类、方法和变量的可见性。Java主要有四种访问修饰符：

public：公开的，任何其他类都可以访问。
protected：受保护的，同一包内的类或子类可以访问。
默认（无修饰符）：包私有，同一包内的类可以访问。
private：私有的，仅在定义它的类内部可以访问。

示例：使用访问修饰符

class AccessModifierExample {
    public int publicVar = 1;
    protected int protectedVar = 2;
    int defaultVar = 3; // 默认访问级别
    private int privateVar = 4;

    public void displayVariables() {
        System.out.println("publicVar: " + publicVar);
        System.out.println("protectedVar: " + protectedVar);
        System.out.println("defaultVar: " + defaultVar);
        System.out.println("privateVar: " + privateVar);
    }
}

public class AccessModifierTest {
    public static void main(String[] args) {
        AccessModifierExample ame = new AccessModifierExample();
        System.out.println("publicVar: " + ame.publicVar);         // 可访问
        System.out.println("protectedVar: " + ame.protectedVar);   // 可访问
        System.out.println("defaultVar: " + ame.defaultVar);       // 可访问
        // System.out.println("privateVar: " + ame.privateVar);    // 编译错误：privateVar不可访问

        ame.displayVariables();
    }
}

输出：

publicVar: 1
protectedVar: 2
defaultVar: 3
publicVar: 1
protectedVar: 2
defaultVar: 3
privateVar: 4

2.9 异常处理

异常处理是Java程序中处理运行时错误的重要机制。通过使用try-catch块，程序可以在发生异常时捕获并处理错误，避免程序崩溃。

2.9.1 异常的分类

Java的异常分为两大类：

检查型异常（Checked Exceptions）：编译时必须处理的异常，如IOException、SQLException。
运行型异常（Unchecked Exceptions）：运行时异常，可以选择处理，如NullPointerException、ArithmeticException。

2.9.2 `try-catch`语句

示例：处理除零异常

public class ExceptionHandlingExample {
    public static void main(String[] args) {
        int a = 10;
        int b = 0;

        try {
            int result = a / b; // 可能抛出ArithmeticException
            System.out.println("结果: " + result);
        } catch (ArithmeticException e) {
            System.out.println("错误: 除以零是不允许的。");
        }

        System.out.println("程序继续运行...");
    }
}

输出：

错误: 除以零是不允许的。
程序继续运行...

2.9.3 `finally`块

finally块用于在try-catch语句后执行无论是否发生异常的代码，常用于资源的释放。

示例：使用finally块

public class FinallyExample {
    public static void main(String[] args) {
        try {
            System.out.println("尝试执行代码...");
            int result = 10 / 0; // 抛出ArithmeticException
            System.out.println("结果: " + result);
        } catch (ArithmeticException e) {
            System.out.println("捕获到异常: " + e.getMessage());
        } finally {
            System.out.println("这是finally块，无论异常是否发生都会执行。");
        }
    }
}

输出：

尝试执行代码...
捕获到异常: / by zero
这是finally块，无论异常是否发生都会执行。

2.9.4 抛出异常

使用throw关键字手动抛出异常，或使用throws关键字声明方法可能抛出的异常。

示例：抛出自定义异常

class InvalidAgeException extends Exception {
    public InvalidAgeException(String message) {
        super(message);
    }
}

public class ThrowExample {
    public static void checkAge(int age) throws InvalidAgeException {
        if (age < 18) {
            throw new InvalidAgeException("年龄必须至少18岁。");
        }
        System.out.println("年龄合法。");
    }

    public static void main(String[] args) {
        try {
            checkAge(16);
        } catch (InvalidAgeException e) {
            System.out.println("异常: " + e.getMessage());
        }

        try {
            checkAge(20);
        } catch (InvalidAgeException e) {
            System.out.println("异常: " + e.getMessage());
        }
    }
}

输出：

异常: 年龄必须至少18岁。
年龄合法。

2.10 注释

注释用于在代码中添加说明性文字，不会被编译器执行。Java支持三种注释类型：

单行注释：以//开头，用于注释单行代码。
多行注释：以/*开始，*/结束，用于注释多行代码。
文档注释：以/**开始，*/结束，用于生成Java文档。

示例：各种注释

public class CommentExample {
    public static void main(String[] args) {
        // 这是一个单行注释

        /*
         * 这是一个多行注释
         * 可以用于注释多行代码或文本
         */

        /**
         * 这是一个文档注释
         * 可以用于生成API文档
         */
        System.out.println("Hello, World!"); // 输出欢迎信息
    }
}

2.11 包与导入

包用于组织类和接口，避免命名冲突。import语句用于在类中引用其他包中的类和接口。

2.11.1 创建与使用包

示例：创建包

创建包：在项目中创建一个名为com.example.utils的包，并在其中创建一个工具类MathUtils.

// 文件: com/example/utils/MathUtils.java
package com.example.utils;

public class MathUtils {
    // 静态方法：计算两个数的最大值
    public static int max(int a, int b) {
        return (a > b) ? a : b;
    }

    // 静态方法：计算两个数的最小值
    public static int min(int a, int b) {
        return (a < b) ? a : b;
    }
}

使用包中的类

// 文件: com/example/Main.java
package com.example;

import com.example.utils.MathUtils; // 导入MathUtils类

public class Main {
    public static void main(String[] args) {
        int a = 10, b = 20;

        int maximum = MathUtils.max(a, b);
        int minimum = MathUtils.min(a, b);

        System.out.println("最大值: " + maximum); // 输出: 最大值: 20
        System.out.println("最小值: " + minimum); // 输出: 最小值: 10
    }
}

2.11.2 `import`语句

import语句用于引用其他包中的类或接口。可以使用特定类import com.example.utils.MathUtils;，也可以使用通配符import com.example.utils.*;导入包中所有的类。

注意：Java的import语句并不会影响代码执行，只是为了方便类的引用。

2.12 常用编程规范

良好的编程规范有助于提高代码的可读性和可维护性。以下是一些常见的Java编程规范：

命名规范
类名：使用大驼峰命名法（每个单词的首字母大写），例如MyClass。
方法名与变量名：使用小驼峰命名法（首字母小写，后续单词首字母大写），例如calculateSum、totalAmount。
常量名：使用全大写字母，单词间用下划线分隔，例如MAX_VALUE。
缩进与格式
使用一致的缩进风格（通常是4个空格）。
代码块使用大括号{}包裹，即使是单行代码。
注释
适当添加注释，解释复杂的逻辑或重要的代码段。
使用文档注释/** */为公共方法和类编写说明。
代码结构
类成员的顺序通常为：常量、变量、构造方法、方法。
每个类单独一个文件，文件名与类名相同。
异常处理
合理使用异常处理，避免捕获过于宽泛的异常。
提供有意义的异常消息，方便调试。
避免硬编码
将常用的值定义为常量，避免在代码中直接使用魔法数字或字符串。

示例：应用编程规范

package com.example.utils;

/**
 * MathUtils 提供常用的数学运算方法。
 */
public class MathUtils {
    // 常量
    public static final double PI = 3.14159;

    /**
     * 计算两个整数的最大值。
     *
     * @param a 第一个整数
     * @param b 第二个整数
     * @return 两个整数中的最大值
     */
    public static int max(int a, int b) {
        return (a > b) ? a : b;
    }

    /**
     * 计算两个整数的最小值。
     *
     * @param a 第一个整数
     * @param b 第二个整数
     * @return 两个整数中的最小值
     */
    public static int min(int a, int b) {
        return (a < b) ? a : b;
    }
}

package com.example;

import com.example.utils.MathUtils;

/**
 * Main 类是程序的入口点。
 */
public class Main {
    /**
     * 程序的主方法。
     *
     * @param args 命令行参数
     */
    public static void main(String[] args) {
        int a = 10;
        int b = 20;

        int maximum = MathUtils.max(a, b);
        int minimum = MathUtils.min(a, b);

        System.out.println("最大值: " + maximum);
        System.out.println("最小值: " + minimum);
    }
}

2.13 总结

本篇文章深入介绍了Java的语法基础，包括数据类型与变量、运算符、控制结构、数组、方法、面向对象编程的进一步内容、异常处理以及常用的编程规范。理解并掌握这些基础知识是编写高效、可维护Java程序的前提。接下来的篇章将进一步探讨更高级的Java特性，如面向对象编程的高级主题、集合框架、多线程编程、I/O操作、网络编程等内容。

通过不断练习和实践，您将逐步提升Java编程技能，能够应对更复杂的开发任务。

作者：猿享天开

物联沃分享整理
物联沃-IOTWORD物联网 » 【Java基础篇】——第2篇：Java语法基础

代码收藏家普通

分享到：

第2篇：Java语法基础

2.1 引言

2.2 Java的基本组成

2.3 数据类型与变量

2.3.1 基本数据类型

2.3.2 引用数据类型

2.3.3 变量的声明与初始化

2.3.4 常量

2.4 运算符

2.4.1 算术运算符

2.4.2 关系运算符

2.4.3 逻辑运算符

2.4.4 赋值运算符

2.4.5 位运算符

2.5 控制结构

2.5.1 条件语句

2.5.1.1 if 语句

2.5.1.2 switch 语句

2.5.2 循环语句

2.5.2.1 for 循环

2.5.2.2 while 循环

2.5.2.3 do-while 循环

2.5.3 跳转语句

2.6 数组

2.6.1 一维数组

2.6.2 多维数组

2.6.3 动态数组（ArrayList）

2.7 方法

2.7.1 方法的声明与调用

2.7.2 方法重载（Method Overloading）

2.8 面向对象编程（OOP）基础

2.8.1 构造方法（Constructors）

2.8.2 this关键字

2.8.3 static关键字

2.8.4 访问修饰符

2.9 异常处理

2.9.1 异常的分类

2.9.2 try-catch语句

2.9.3 finally块

2.9.4 抛出异常

2.10 注释

2.11 包与导入

2.11.1 创建与使用包

2.11.2 import语句

2.12 常用编程规范

2.13 总结

代码收藏家 普通

相关推荐

发表回复 取消回复

2.5.1.1 `if` 语句

2.5.1.2 `switch` 语句

2.5.2.1 `for` 循环

2.5.2.2 `while` 循环

2.5.2.3 `do-while` 循环

2.8.2 `this`关键字

2.8.3 `static`关键字

2.9.2 `try-catch`语句

2.9.3 `finally`块

2.11.2 `import`语句

代码收藏家普通

发表回复取消回复