Java SE （二）面向过程编程

前面我们已经认识了Java语言的相关特性，并且已经成功配置好了开发环境，从这节课开始，我们就可以正式进入到Java语言的学习当中了。Java语言是一门面向对象的语言，但是在面向对象之前，我们还得先学会如何面向过程编程。

一、JavaSE 中面向过程编程的关键元素

给大家实例一个代码：

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}

这段代码要实现的功能很简单，就是将 Hello World 输出到控制台就行。

1.主方法（ main 方法）

主方法是 Java 程序的入口点，所有 Java 应用程序都从 main 方法开始执行。它的标准格式为：

public static void main(String[] args) {
    // 程序执行的起始代码
}

这里的 public 表示该方法是公共的，能被外部访问；static 表示该方法是静态的，不需要创建类的实例就可以调用；void 表示方法没有返回值；main 是方法名；String[] args 是主方法的参数，用于接收命令行传递的参数。

2.变量与数据类型

变量，指可以变的量。变量以非数字的符号来表达，一般用拉丁字母。变量的用处在于能一般化描述指令的方式。结果只能使用真实的值，指令只能应用于某些情况下。变量能够作为某特定种类的值中任何一个的保留器。

要声明一个变量，我们需要使用以下格式：

【数据类型】【变量名称】;

基本数据类型：Java 有 8 种基本数据类型，用于存储简单的数据。
整数类型：byte（1 字节）、short（2 字节）、int（4 字节，最常用）、long（8 字节，声明时需加 L 或 l，如 long num = 100L;）。
浮点类型：float（4 字节，声明时需加 F 或 f，如 float score = 95.5F;）、double（8 字节，最常用）。
字符类型：char（2 字节，用于存储单个字符，用单引号括起来，如 char ch = 'A';）。
布尔类型：boolean（只有 true 和 false 两个值，用于表示逻辑判断结果）。
引用数据类型：包括类、接口、数组等，用于存储对象的引用。在面向过程编程中，虽然主要以基本数据类型和简单的逻辑为主，但也会涉及到数组等引用数据类型。例如，定义一个整数数组：int[] arr = {1, 2, 3, 4, 5};。

书写规范：

标识符可以由大小写字母、数字、下划线(_)和美元符号(\$)组成，但是不能以数字开头。
变量不能重复定义，大小写敏感，比如A和a就是两个不同的变量。
不能有空格、@、#、+、-、/ 等符号。
应该使用有意义的名称，达到见名知意的目的（一般我们采用英文单词），最好以小写字母开头。
不可以是 true 和 false。
不能与Java语言的关键字或是基本数据类型重名。

比如现在我们想要定义一个变量a，那么就可以这样编写：

public class Main {
    public static void main(String[] args) {
        int a;    //声明一个整数类型变量a
    }
}

但是这个变量一开始没有任何值，比如现在我们要让这个变量表示1，那么就可以将1赋值给这个变量:

public static void main(String[] args) {
    int a = 1;   //直接在定义变量后面添加 = 1

或者我们可以在使用时再对其进行赋值：

public static void main(String[] args) {
    int a;
    a = 1;   //使用时再赋值也可以
}

我们也可以一次性定义多个变量，比如现在我们想定义两个int类型的变量：

public static void main(String[] args) {
    int a, b;   //定义变量a和变量b，中间使用逗号隔开就行了
}

变量的值也可以在中途进行修改：

public static void main(String[] args) {
    int a = 1;
    a = 2;
    System.out.println(a);   //这里打印得到的值就是2了
}

变量的值也可以直接指定为其他变量的值：

public static void main(String[] args) {
    int a = 1;
    int b = a;   //直接让b等于a，那么a的值就会给到b
    System.out.println(b);   //这里输出的就是1了
}

隐式类型转换：但是转换也有限制，只能从存储范围小的类型转换到存储范围大的类型：

public static void main(String[] args) {
    short a = 10;
    int b = a;   //小的类型可以直接传递给表示范围更大的类型
    System.out.println(b);
}

3.运算符

算术运算符：用于进行基本的数学运算，如 +（加法）、-（减法）、*（乘法）、/（除法，整数相除结果为整数，如 5 / 2 = 2；浮点数相除结果为浮点数，如 5.0 / 2 = 2.5）、%（取余，如 5 % 2 = 1）、++（自增）、--（自减）。
赋值运算符：= 是基本的赋值运算符，还有复合赋值运算符，如 +=（a += b 等价于 a = a + b）、-=、*=、/= 等。
关系运算符：用于比较两个值的关系，结果为 boolean 类型，包括 ==（等于）、!=（不等于）、>（大于）、<（小于）、>=（大于等于）、<=（小于等于）。
逻辑运算符：用于进行逻辑运算，结果为 boolean 类型。&&（逻辑与，短路与，当第一个操作数为 false 时，第二个操作数不再执行）、||（逻辑或，短路或，当第一个操作数为 true 时，第二个操作数不再执行）、!（逻辑非）。
位运算符：对整数的二进制位进行操作，如 &（按位与）、|（按位或）、^（按位异或）、~（按位取反）、<<（左移）、>>（右移）、>>>（无符号右移）。在面向过程编程中，位运算符使用相对较少，但在一些底层操作或性能要求高的场景下会用到。
三元运算符：condition ? expression1 : expression2，如果 condition 为 true，则结果为 expression1，否则为 expression2。例如：int max = a > b ? a : b;，用于获取 a 和 b 中的较大值。

4.注释

大家在写代码时可能有时需要标记一下这段代码是干什么的，但是如果直接写上去会报错，因为这段文字被认为是代码一部分了。所以我们就要告诉编译器这段文字是我们的注释并不是代码。

双斜杠：添加双斜杠之后（自动变成了灰色），后续的文本内容只要没有发生换行，那么都会被认为是一段注释，并不属于程序，在编译时会被直接忽略，之后这段注释也不会存在于程序中。
多行注释标记：如果注释很多，一行写不完，我们想要编写很多行的注释呢？我们可以使用多行注释标记，多行可以使用/*和*/的组合来囊括需要编写的注释内容。

5.流程控制语句

顺序结构：程序按照代码的书写顺序依次执行，这是最基本的流程结构。
分支结构

if - else 语句：根据条件判断执行不同的代码块。语法：

if (condition) {
    // condition 为 true 时执行的代码
} else {
    // condition 为 false 时执行的代码
}

也可以有多重 if - else if - else 结构，用于多条件判断。 * switch - case语句：根据表达式的值，匹配不同的 case 执行相应的代码。语法：

switch (expression) {
    case value1:
        // expression 等于 value1 时执行的代码
        break;
    case value2:
        // expression 等于 value2 时执行的代码
        break;
    // 更多 case
    default:
        // 当 expression 与所有 case 都不匹配时执行的代码
}

* 其中 expression 只能是 byte、short、int、char、String（JDK 7 及以上）类型。break 用于跳出 switch 结构，若没有 break，会继续执行下一个 case 的代码（穿透现象）。 * 循环结构

for 循环：语法为 for (初始化表达式; 条件表达式; 更新表达式) { 循环体代码 }。执行流程是先执行初始化表达式，然后判断条件表达式，若为 true，执行循环体代码，再执行更新表达式，重复这个过程，直到条件表达式为 false。例如，打印 1 到 10 的数字：
```
for (int i = 1; i <= 10; i++) {
    System.out.println(i);
}
```
* while 循环：语法为 while (条件表达式) { 循环体代码 }。先判断条件表达式，若为 true，执行循环体代码，然后再次判断条件表达式，直到条件表达式为 false。例如，同样打印 1 到 10 的数字：
```
int i = 1;
while (i <= 10) {
    System.out.println(i);
    i++;
}
```
* do - while 循环：语法为 do { 循环体代码 } while (条件表达式);。先执行一次循环体代码，然后判断条件表达式，若为 true，继续执行循环体代码，直到条件表达式为 false。它至少会执行一次循环体。例如：
```
int i = 1;
do {
    System.out.println(i);
    i++;
} while (i <= 10);
```

6.方法（函数）

方法是一段具有特定功能的代码块，用于封装重复的操作，提高代码的复用性。在面向过程编程中，方法是核心元素之一，通过将不同的功能分解到不同的方法中，然后按顺序调用这些方法来完成任务。
方法的定义格式：

[修饰符] 返回值类型 方法名(参数列表) {
    // 方法体代码
    [return 返回值;]
}

* 修饰符：如 public、private、static 等，static 修饰的方法为静态方法，可以通过类名直接调用（类名.方法名(参数)）。 * 返回值类型：如果方法有返回值，指定返回值的类型；如果没有返回值，用void。 * 参数列表：方法可以有零个或多个参数，参数用于接收外部传递给方法的值。

例如，定义一个计算两个整数和的方法：

public static int add(int a, int b) {
    return a + b;
}

然后再 main 方法中调用：

public static void main(String[] args) {
    int result = add(3, 5);
    System.out.println("3 + 5 = " + result);
}

二、面向过程编程实例

下面通过一个计算学生成绩相关示例来展示面向过程编程的应用：

public class StudentScoreDemo {
    public static void main(String[] args) {
        // 定义学生成绩数组
        int[] scores = {85, 92, 78, 95, 88};

        // 调用方法计算总分
        int totalScore = calculateTotalScore(scores);
        System.out.println("学生的总分为：" + totalScore);

        // 调用方法计算平均分
        double averageScore = calculateAverageScore(scores);
        System.out.println("学生的平均分为：" + averageScore);

        // 调用方法找出最高分
        int maxScore = findMaxScore(scores);
        System.out.println("学生的最高分为：" + maxScore);
    }

    // 计算总分的方法
    public static int calculateTotalScore(int[] scores) {
        int total = 0;
        for (int score : scores) {
            total += score;
        }
        return total;
    }

    // 计算平均分的方法
    public static double calculateAverageScore(int[] scores) {
        int total = calculateTotalScore(scores);
        return (double) total / scores.length;
    }

    // 找出最高分的方法
    public static int findMaxScore(int[] scores) {
        int max = scores[0];
        for (int i = 1; i < scores.length; i++) {
            if (scores[i] > max) {
                max = scores[i];
            }
        }
        return max;
    }
}

在这个示例中，我们把计算总分、平均分、找出最高分这些功能分别封装到不同的方法中，然后在 main 方法中按顺序调用这些方法，这就是典型的面向过程编程思想，即按照解决问题的步骤，一步步调用相关方法来完成任务。

三、面向过程编程的优缺点

1.优点

逻辑清晰，流程明确，适合解决简单的、线性的问题。
代码执行效率相对较高，因为没有面向对象中的一些额外开销（如对象的创建、方法的多态调用等）。
学习门槛较低，容易理解和上手，是编程入门的良好途径。

2.缺点

代码的复用性相对较低，当需要修改某个功能时，可能需要在多个地方进行修改，维护成本较高。
对于复杂的大型项目，代码的组织和管理会变得非常困难，因为所有的逻辑都以过程为中心，缺乏良好的封装和抽象。
难以应对需求的变化，当项目需求发生较大改变时，往往需要对整个代码结构进行较大的调整。

四、与面向对象编程的关系

面向过程编程是面向对象编程的基础，面向对象编程（Object - Oriented Programming，简称 OOP）是在面向过程编程的基础上发展而来的，它更加注重 “谁来做”，通过将数据和操作数据的方法封装到对象中，以对象为中心来组织代码。在 Java 中，我们通常会先学习面向过程编程，掌握基本的语法和逻辑，然后再学习面向对象编程，利用面向对象的思想来开发更复杂、更易维护的应用程序。