一、Java变量声明与使用

（一）变量声明语法规则

在 Java 中，声明变量时需要遵循特定的语法规则。

1. 数据类型与变量名

• 变量类型：Java 有多种数据类型，如整数类型（int、long 等）、浮点类型（float、double）、字符类型（char）、布尔类型（boolean）等。每种数据类型都有其特定的存储大小和取值范围。例如，int 类型通常占用 4 个字节，可以存储整数范围为 -2147483648 到 2147483647。

• 变量名称：变量的命名必须符合 Java 标识符的规则，可以由字母、数字、“-”和“$”符组成；首字符不能以数字开头；Java 大小写敏感；不能使用 Java 的关键字或者保留字，但可以将关键字或保留字作为名称的一部分；中文名可以作为变量名，因为 Java 使用的是 Unicode 字符编码，不过强烈不推荐使用中文名作为变量名。

2. 合法与非法变量命名示例

• 以下这些命名都是错误的，编译器会提示错误：

• int123；

• char123a；

• boolean+s；

• char String。

• 正确的命名如下：

• int a；

• char test1；

• boolean b$；

• double d_1。

• 推荐的命名采用驼峰命名法，即变量的名称由多个单词组成，除第一个单词首字母小写外，其余单词的首字母大写。例如：

• int salary；

• int score；

• boolean isOdd；

• String personName。

（二）变量初始化方式

在 Java 中，变量的初始化主要有两种常见方式：在声明时初始化和使用之前初始化。

1. 在声明时初始化

• 对于不同类型的变量，可以在声明的同时进行初始化。例如，对于整型变量int salary = 0；对于布尔型变量boolean man = false；对于双精度浮点型变量double distance = 0.0；对于字符串变量String personName = "Alan Swolk"；对于字符串变量也可以初始化为null，如String message = null。

2. 使用之前初始化

• 可以先声明变量，在使用之前进行初始化。例如，先声明一个双精度浮点型变量double startPoint；然后在使用该变量之前进行初始化，如startPoint = 0.0。也可以先声明变量同时初始化另一个变量，如int index = 0，之后再使用之前声明的变量进行初始化操作，如double distance = startPoint。

通过具体的代码示例，可以清晰地看到这两种变量初始化方式在不同类型变量上的语法运用，有助于更好地理解和掌握 Java 中变量的初始化过程。

（三）变量的使用场景

在 Java 中，声明且初始化后的变量可以在程序中进行存储和读取操作。以下通过简单的数值计算、赋值等操作实例，来展现变量使用时的语法特点。

一、变量的存储和读取操作

变量在程序中就像是一个容器，可以用来存储各种数据类型的值。一旦变量被声明并初始化后，就可以通过变量名来读取存储在其中的值，也可以对其进行修改，即存储新的值。

例如，声明一个整型变量int score = 90，这里score变量存储了整数值 90。可以通过变量名来读取这个值，比如可以将其赋值给另一个变量int totalScore = score，此时totalScore也得到了值 90。同时，也可以修改score的值，如score = 80，或者进行更复杂的操作，如score = score + 10，先读取score的旧值，进行加法运算后再存储新的值。

二、数值计算实例

1. 简单的加法运算

• 假设我们有两个变量int num1 = 10和int num2 = 20，可以声明一个新的变量来存储它们的和，如int sum = num1 + num2。

2. 减法运算

• 同样，对于减法运算，如int difference = num2 - num1。

3. 乘法和除法运算

• 以乘法为例，int product = num1 * num2；除法可以用int quotient = num2 / num1（注意这里如果是整数除法，结果会向下取整）。

三、赋值操作实例

1. 直接赋值

• 如前面提到的int score = 90就是直接给变量赋值的例子。

2. 变量间赋值

• 可以将一个变量的值赋给另一个变量，如int num3 = num1。

通过这些实例，可以看出在 Java 中变量的使用非常灵活，可以满足各种不同的编程需求。同时，也体现了变量在程序中的重要性，它们使得数据的存储和操作更加方便和高效。

二、Java数据类型剖析

（一）基本数据类型详解

Java中有八种基本数据类型，分别是 byte、short、int、long、float、double、char、boolean。下面将分别阐述这些基本数据类型的语法表示、取值范围以及适用场景，并辅以代码中对应类型变量的声明与使用示例。

1. byte 类型

• 语法表示：使用 byte 关键字声明变量。例如：byte myByte;。

• 取值范围：byte 类型是一个 8 位的有符号整数，取值范围是 -128 到 127。可以用以下代码来验证 byte 类型的取值范围：byte minValue = Byte.MIN_VALUE; byte maxValue = Byte.MAX_VALUE; System.out.println("Byte 的最小值：" + minValue); System.out.println("Byte 的最大值：" + maxValue);。

• 适用场景：当处理的数据范围不大时，或者在需要大量数据存储时，为了节省内存空间，可以选择使用 byte 类型。例如，在处理像素值（通常范围是 0 - 255）时，使用 byte 类型会比使用 int 类型更加高效。

以下是一个使用 byte 类型的示例：

public class ByteExample {
    public static void main(String[] args) {
        byte myByte = 10;
        System.out.println("myByte 的值是：" + myByte);
    }
}

2. short 类型

• 语法表示：使用 short 关键字声明变量。例如：short myShort;。

• 取值范围：short 类型是一个 16 位的有符号整数，取值范围是 -32768 到 32767。

• 适用场景：由于 short 类型的取值范围较小，它适用于那些不需要很大数值范围的场合。例如，在某些数学计算中，如果确定结果不会超过 short 类型的范围，那么使用 short 类型可以减少内存的使用。此外，在处理来自某些设备或文件格式的数据时，如果已知数据的范围不会超过 16 位整数的范围，也可以使用 short 类型来存储这些数据。

以下是一个使用 short 类型的示例：

public class ShortExample {
    public static void main(String[] args) {
        short myShort = 200;
        System.out.println("myShort 的值是：" + myShort);
    }
}

3. int 类型

• 语法表示：使用 int 关键字声明变量。例如：int myInt;。

• 取值范围：int 类型是一个 32 位的有符号整数，取值范围大约是 -2147483648 到 2147483647。

• 适用场景：int 类型通常用于表示整数值，如计数、索引等。在大多数情况下，它是整型变量的默认类型。

以下是一个使用 int 类型的示例：

public class IntExample {
    public static void main(String[] args) {
        int myInt = 10000;
        System.out.println("myInt 的值是：" + myInt);
    }
}

4. long 类型

• 语法表示：使用 long 关键字声明变量。例如：long myLong;。在给 long 类型变量赋值时，为了避免与整数常量混淆，需要在数值后面加上大写字母“L”或小写字母“l”作为标识。

• 取值范围：long 类型是一个 64 位的有符号整数，取值范围大约是 -9223372036854775808 到 9223372036854775807。

• 适用场景：当需要处理的整数值超过了 int 类型的范围时，应当使用 long 类型。例如，在处理大型数据集、高精度计算或者需要存储比 int 类型更大范围的整数值时，long 类型是更好的选择。

以下是一个使用 long 类型的示例：

public class LongExample {
    public static void main(String[] args) {
        long myLong = 10000000000L;
        System.out.println("myLong 的值是：" + myLong);
    }
}

5. float 类型

• 语法表示：使用 float 关键字声明变量。例如：float myFloat;。在给 float 类型变量赋值时，需要在数值后面加上字母“f”或“F”作为后缀，以区分整数字面量。

• 取值范围：float 类型是一个 32 位单精度浮点数，取值范围大约在 1.4E - 45 到 3.4028235E + 38 之间。

• 适用场景：当需要表示的数值超出了整数类型的范围，或者需要进行浮点运算时，应使用 float 类型。例如，在处理涉及小数的计算或科学计算中，float 类型是较为合适的选择。

以下是一个使用 float 类型的示例：

public class FloatExample {
    public static void main(String[] args) {
        float myFloat = 3.14f;
        System.out.println("myFloat 的值是：" + myFloat);
    }
}

6. double 类型

• 语法表示：使用 double 关键字声明变量。例如：double myDouble;。

• 取值范围：double 类型是一个 64 位双精度浮点数，取值范围大约在 4.9E - 324 到 1.7976931348623157E + 308 之间。

• 适用场景：当需要处理的浮点数超出了 float 类型的范围或者需要更高的计算精度时，应当使用 double 类型。例如，在科学计算、工程模拟或者金融计算中，double 类型是更合适的选择。

以下是一个使用 double 类型的示例：

public class DoubleExample {
    public static void main(String[] args) {
        double myDouble = 3.141592653589793;
        System.out.println("myDouble 的值是：" + myDouble);
    }
}

7. char 类型

• 语法表示：使用 char 关键字声明变量。例如：char myChar;。可以直接将字符用单引号括起来赋给变量，如 char letter = 'A';。

• 取值范围：char 类型使用 16 位（即 2 个字节）来存储字符，它的取值范围从最小的 '\u0000'（即 0）到最大的 '\uffff'（即 65535）。这个范围覆盖了 Unicode 字符集中的所有字符，包括常见的 ASCII 字符集。

• 适用场景：当需要处理单个字符时，应使用 char 类型。例如，在文本处理、字符串操作或需要读取用户输入的单个字符时，char 类型是合适的选择。

以下是一个使用 char 类型的示例：

public class CharExample {
    public static void main(String[] args) {
        char myChar = 'A';
        System.out.println("myChar 的值是：" + myChar);
    }
}

8. boolean 类型

• 语法表示：使用 boolean 关键字声明变量。例如：boolean myBoolean;。

• 取值范围：boolean 类型只有两个可能的值，即 true（真）和 false（假）。

• 适用场景：在 Java 编程中，boolean 类型通常用于条件测试，如 if 语句、while 循环、for 循环等逻辑控制结构中。

以下是一个使用 boolean 类型的示例：

public class BooleanExample {
    public static void main(String[] args) {
        boolean isTrue = true;
        System.out.println("isTrue 的值是：" + isTrue);
        boolean isFalse = false;
        System.out.println("isFalse 的值是：" + isFalse);
    }
}

（二）引用数据类型介绍

在 Java 中，引用数据类型主要包括类、接口和数组等。这些类型在程序中有着广泛的应用，下面将分别介绍它们的语法定义形式以及在程序中的运用。

一、类的创建与使用

在 Java 中，类是一种自定义的引用数据类型。类的定义格式如下：

public class 类名 {
    数据类型 属性名称1；
    数据类型 属性名称2；
   ...
}

例如，定义一个手机类：

public class Phone {
    /** 属性*/
    String brand;// 品牌型号
    String color;// 颜色
    double size; // 尺寸大小
}

类的使用格式如下：

1. 导包：如果将所有的类放到同一个文件夹下，可以避免导包。

2. 创建对象：数据类型 变量名 = new 数据类型();

3. 调用方法：目前自定义类不涉及方法，只是属性。

4. 访问属性：变量名.属性。

以下是使用手机类的示例：

public class Test {
    public static void main(String[] args) {
        //定义了一个 Phone 类型的变量 p
        Phone p = new Phone();
        /** 通过 p,使用 Phone 中的属性*/
        //访问 p 中的 brand 品牌属性
        p.brand = "苹果 6s";
        //访问 p 中的 color 颜色属性
        p.color = "白色";
        //访问 p 中的 size 尺寸大小属性
        p.size = 5.5;
        System.out.println("手机品牌为" + p.brand);
        System.out.println("手机颜色为" + p.color);
        System.out.println("手机尺寸大小为" + p.size);
    }
}

二、接口的实现与使用

接口是一种特殊的引用数据类型，它定义了一组抽象方法和常量。接口的定义格式如下：

public interface 接口名称 {
    //接口内容
}

例如：

public interface MyInterfaceAbstract {
    //抽象方法
    public abstract void methodAbs();
    abstract void methodAbs2();
    public void methodAbs3();
    void methodAbs4();
}

接口的使用步骤如下：

1. 一个类使用implements关键字来实现接口，格式为public class 实现类名称 implements 接口名称{...}。

2. 接口的实现类必须覆盖重写（实现）接口中所有的抽象方法，如果没有全部重写，实现类自身必须是抽象类。覆盖重写格式为去掉abstract关键字，补全方法体大括号。

3. 创建实现类的对象，通过对象来使用接口。

以下是接口使用的示例：

public class MyInterfaceAbstractImpl implements MyInterfaceAbstract {
    @Override
    public void methodAbs() {
        System.out.println("这是第一个方法");
    }
    @Override
    public void methodAbs2() {}
    @Override
    public void methodAbs3() {}
    @Override
    public void methodAbs4() {}
}

public class Demo01Interface {
    public static void main(String[] args) {
        //错误写法，不能直接 new 接口对象使用
        //MyInterfaceAbstract inter = new MyInterfaceAbstract();
        //创建实现类的对象使用
        MyInterfaceAbstractImpl impl = new MyInterfaceAbstractImpl();
        impl.methodAbs();
        impl.methodAbs2();
    }
}

三、数组的声明与使用

1. 数组的定义

• 数组是一个数据类型，它可以存储多个相同类型的数据；数据中存储的数据，我们称为元素。定义数组的语法：int[] a = new int[长度];。例如：int[] a = new int[5];。

• 访问数组：通过数组的下标(索引)来访问数组元素，数组的下标从 0 开始，最大下标值是长度 - 1。例如：int[] a = new int[5]; a[0]=78; a[1]=77; a[2]=90; int i = a[0];。

2. 数组的使用

• 定义一个数组，必须先开辟空间才能使用；（new 数据类型[长度]）。

• 数组的长度一旦定义，就不能改变。

• 通过下标可以访问数组中的元素，下标的取值范围是 0 - 长度 - 1；如果超过这个范围，在运行时出错。

• 数组中的元素如果不赋值，Java 会为每种数据类型赋一个默认值。

3. 数组初始化

• 数组初始化指初次给数据中的元素赋值，分为两种：

• 动态初始化：int[] a = new int[5]; a[0]=xxx; a[1]=xxx。

• 静态初始化：int[] a = {5,6,8,9,0,98}; int[] a = new int[]{4,6,78,8,90}。

4. 数组的长度属性

• 每个数组都有一个属性来获得当前数组的长度，属性名是length。用法：数组名.length。

5. 不同类型的数组

• 例如：String[] s = {"张飞","李逵","杨喜超"};。

6. 不一样的数组的遍历方法(增强的 for 循环，foreach)

• for(数据类型变量名 :数组名){}。增强的 for 循环只能用于遍历集合，是 JDK1.5 版本之后的新特性。

通过以上对类、接口和数组等引用数据类型的介绍，可以看出它们在 Java 程序中具有重要的地位，能够帮助我们更好地组织和管理数据，提高程序的可读性和可维护性。

简述：顺序控制结构是 Java 程序中最基本的控制结构之一，其特点是代码按照语句先后顺序依次执行。在没有分支和循环等特殊控制的情况下，代码的执行顺序遵循从上到下、从左到右的语法规则。

例如以下代码：

public class SequenceExample {
    public static void main(String[] args) {
        int num1 = 10;
        int num2 = 20;
        int sum = num1 + num2;
        System.out.println("两数之和为：" + sum);
    }
}

在这个例子中，首先声明并初始化了两个变量num1和num2，然后按照顺序执行加法运算并将结果存储在sum变量中，最后输出结果。整个过程中代码严格按照从上到下的顺序依次执行，没有任何分支或循环结构来改变执行路径。这体现了顺序控制结构的基本特点，即代码按照书写的先后顺序依次执行，是程序执行的最基本方式。

（二）分支控制结构

1. if语句

简述：Java中的if语句提供了条件判断的功能，包括单分支、双分支和多分支结构，在不同的场景下可以灵活运用。

一、单分支if语句

单分支if语句的语法格式为：if(条件表达式){语句体;}。当条件表达式为true时，执行语句体中的代码；如果为false，则不执行。例如，可以用单分支if语句判断一个数是否为正数：

int num = 10;
if(num > 0){
    System.out.println(num + "是正数");
}

二、双分支if-else语句

if-else语句的语法格式为：if(关系表达式) {语句体1;}else {语句体2;}。当关系表达式为true时，执行语句体1；为false时，执行语句体2。比如判断成绩是否及格：

int score = 75;
if(score >= 60){
    System.out.println("及格");
}else{
    System.out.println("不及格");
}

三、多分支if-else if-else语句

多分支结构的语法格式为：if (条件表达式1){执行代码块1;}else if (条件表达式2){执行代码块2;}...else{执行代码块n;}。首先判断条件表达式1，如果成立执行代码块1；如果不成立，继续判断条件表达式2，以此类推。若所有表达式都不成立，则执行else后的代码块。例如根据不同分数区间输出对应等级：

int score = 85;
if (score >= 90){
    System.out.println("A");
}else if (score >= 80){
    System.out.println("B");
}else if (score >= 70){
    System.out.println("C");
}else if (score >= 60){
    System.out.println("D");
}else{
    System.out.println("F");
}

2. switch语句

简述：switch语句根据表达式的值匹配不同的case情况，具有简洁高效的特点。

一、switch语句语法规则

switch语句的语法格式为：switch(表达式){case 常量1:语句块1;break;case 常量2:语句块2;break;...default:default语句块;break;}。首先计算表达式的值，然后与各个case后的常量进行匹配。如果匹配成功，就执行相应的语句块，直到遇到break语句跳出switch；如果没有匹配成功，则执行default后的语句块。

二、switch语句的适用类型

在Java中，switch语句的表达式可以是byte、short、char、int以及jdk7后支持的String类型。对于枚举类型（从Java 1.5开始支持），也可以在switch语句中使用。例如，当输入为字符类型时：

char grade = 'B';
switch(grade){
    case 'A':
        System.out.println("优秀");
        break;
    case 'B':
        System.out.println("良好");
        break;
    case 'C':
        System.out.println("及格");
        break;
    case 'D':
        System.out.println("再接再厉");
        break;
    case 'E':
        System.out.println("挂科");
        break;
    default:
        System.out.println("未知等级");
}

当输入为String类型时（jdk7及以上版本）：

String weekday = "周日";
switch (weekday) {
    case "周一":
        System.out.println("上学啦！");
        break;
    case "周二":
        System.out.println("还是上学~");
        break;
    case "周三":
        System.out.println("什么时候周末啊~");
        break;
    case "周四":
        System.out.println("要放假咯~");
        break;
    case "周五":
        System.out.println("今晚吃鸡！");
        break;
    case "周六":
        System.out.println("今晚继续吃鸡！");
        break;
    case "周日":
        System.out.println("emotional，又要上课了……");
        break;
}

三、switch语句的特点及案例展示

switch语句具有简洁清晰的特点，适用于值匹配的分支选择。例如，根据星期几输出对应活动安排：

char dayOfWeek = 'T';
switch(dayOfWeek){
    case 'M':
        System.out.println("周一，工作学习日");
        break;
    case 'T':
        System.out.println("周二，继续努力");
        break;
    case 'W':
        System.out.println("周三，坚持就是胜利");
        break;
    case 'R':
        System.out.println("周四，胜利在望");
        break;
    case 'F':
        System.out.println("周五，期待周末");
        break;
    case 'S':
        System.out.println("周六，放松一下");
        break;
    case 'U':
        System.out.println("周日，享受休闲时光");
        break;
    default:
        System.out.println("输入错误");
}

（三）循环控制结构

1. while循环

简述：while循环先判断条件再执行循环体，其语法特点在于条件判断在前，循环体执行在后。例如计算1到100偶数和，代码如下：

int sum = 0;
int i = 1;
while (i <= 100) {
    if (i % 2 == 0) {
        sum += i;
    }
    i++;
}
System.out.println("1到100偶数和为：" + sum);

在这个例子中，首先定义了一个变量sum用于存储偶数和，初始值为0。然后定义变量i作为循环条件变量，初始值为1。在循环中，判断i是否小于等于100，如果满足条件，则进入循环体。在循环体中，判断i是否为偶数，如果是偶数，则将其累加到sum中。最后，i自增1，继续下一次循环判断。循环条件、循环体以及改变循环条件语句的语法运用清晰可见，通过这样的方式实现了特定的计算需求。

2. do-while循环

简述：do-while循环先执行循环体再判断条件，其语法特性决定了循环体至少会被执行一次。例如打印数字序列：

int num = 1;
do {
    System.out.println(num);
    num++;
} while (num <= 10);

在这个例子中，首先执行循环体，输出num的值，然后num自增1。接着判断num是否小于等于10，如果满足条件，则继续执行循环体；否则，结束循环。这种先执行后判断的特性，使得即使初始条件不满足，循环体也至少会执行一次。

3. for循环

简述：for循环将循环三要素（初始化、判断条件、迭代因子）集中在括号内管理，具有语法优势，使得代码更加简洁清晰。例如循环打印特定范围数字：

for (int i = 1; i <= 10; i++) {
    System.out.println(i);
}

在这个例子中，在for循环的括号内，首先初始化变量i为1，然后判断i是否小于等于10，如果满足条件，则执行循环体，输出i的值。最后，在每次循环结束后，执行迭代因子i++，使i自增1。再如遍历数组：

int[] arr = {1, 2, 3, 4, 5};
for (int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
}

这里通过for循环遍历数组arr，利用数组的长度属性arr.length作为循环的判断条件，确保循环在数组范围内进行。在循环体中，通过下标访问数组元素并输出。

4. 循环控制语句（break和continue）

简述：break语句用于跳出循环，continue语句用于结束本次循环继续下一次循环。例如在多层循环中控制跳出层数：

for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 3; j++) {
        if (j == 2) {
            break;
        }
        System.out.println("i=" + i + ", j=" + j);
    }
}

在这个例子中，有两层嵌套的for循环。当内层循环中的j等于2时，执行break语句，跳出内层循环，继续执行外层循环的下一次迭代。

再如跳过特定条件循环体内容：

for (int i = 0; i < 10; i++) {
    if (i % 2 == 0) {
        continue;
    }
    System.out.println(i);
}

在这个例子中，当i是偶数时，执行continue语句，结束本次循环，直接进入下一次循环，不执行输出i的语句。只有当i是奇数时，才输出i的值。这样就实现了跳过特定条件的循环体内容。

（一）方法定义语法要点

在 Java 中，方法是完成特定功能的代码块。方法的定义包括修饰符、返回类型、方法名、参数列表和方法体等部分。

1. 修饰符

• Java 中的方法修饰符有多种，如 public、private、protected、static、final 等。不同的修饰符决定了方法的访问权限和特性。

• public 修饰的方法可以在任何地方被访问；private 修饰的方法只能在当前类中被访问；protected 修饰的方法可以在同一包内或子类中被访问。

• static 修饰的方法是静态方法，可以通过类名直接调用，而不需要创建对象。

• final 修饰的方法不能被重写。

2. 返回类型

• 返回类型指定了方法执行后返回的值的类型。可以是基本数据类型，如 int、double、char 等，也可以是引用数据类型，如类、接口、数组等。

• 如果方法不需要返回值，则返回类型为 void。

3. 方法名

• 方法名是方法的标识符，遵循 Java 标识符的命名规则。方法名应该具有描述性，能够清晰地表达方法的功能。

• 例如，一个用于计算两个整数之和的方法可以命名为 add。

4. 参数列表

• 参数列表是方法接收的输入参数的列表。参数可以有零个或多个，每个参数都有特定的数据类型和名称。

• 参数列表的语法为：(参数类型1 参数名1, 参数类型2 参数名2,...)。

• 例如，一个接收两个整数参数的方法可以定义为：public int add(int a, int b)。

5. 方法体

• 方法体是方法的具体实现，包含了完成方法功能的代码。方法体用花括号括起来。

• 例如，上面的 add 方法的方法体可以是：return a + b;，表示返回两个参数的和。

下面以简单的数学计算和字符串处理方法为例，展示方法定义的语法细节。

数学计算方法示例

public class MethodExample {
    // 计算两个整数之和的方法
    public int add(int num1, int num2) {
        return num1 + num2;
    }
    // 计算两个浮点数之积的方法
    public double multiply(double num1, double num2) {
        return num1 * num2;
    }
    // 计算一个整数的平方的方法
    public int square(int num) {
        return num * num;
    }
}

字符串处理方法示例

public class StringMethodExample {
    // 连接两个字符串的方法
    public String concatStrings(String str1, String str2) {
        return str1 + str2;
    }
    // 判断一个字符串是否包含另一个字符串的方法
    public boolean containsString(String str1, String str2) {
        return str1.contains(str2);
    }
    // 获取一个字符串的长度的方法
    public int stringLength(String str) {
        return str.length();
    }
}

通过这些示例，可以清楚地看到方法定义中各个部分的语法要求和作用。不同的修饰符、返回类型、方法名、参数列表和方法体的组合，可以实现各种不同的功能。

（二）方法的调用方式

Java中的方法调用方式主要有直接调用、赋值调用、输出语句调用等。这些调用方式在不同的场景下有着不同的语法运用及区别。

一、直接调用

直接调用是在同一个类中，通过方法名加括号的方式调用方法。例如：

public class MethodCallExample {
    public static void main(String[] args) {
        addNumbers(10, 20);
    }
    public static int addNumbers(int a, int b) {
        return a + b;
    }
}

在这个例子中，addNumbers(10, 20)就是直接调用方法addNumbers，将参数 10 和 20 传递给该方法进行加法运算。

二、赋值调用

赋值调用是将方法的返回值赋给一个变量。例如：

public class MethodCallExample {
    public static void main(String[] args) {
        int sum = addNumbers(10, 20);
        System.out.println("两数之和为：" + sum);
    }
    public static int addNumbers(int a, int b) {
        return a + b;
    }
}

这里先调用方法addNumbers，并将其返回值赋给变量sum，然后输出sum的值。

三、输出语句调用

输出语句调用是将方法的调用放在输出语句中，直接打印方法的返回值。例如：

public class MethodCallExample {
    public static void main(String[] args) {
        System.out.println("两数之和为：" + addNumbers(10, 20));
    }
    public static int addNumbers(int a, int b) {
        return a + b;
    }
}

在输出语句中调用方法addNumbers，并将其返回值与字符串拼接后输出。

通过在主函数中调用不同功能方法并获取返回值或执行操作的代码示例，可以清楚地看到各种调用方式的语法运用及区别。直接调用简单直接地执行方法，不获取返回值；赋值调用将方法的返回值存储在变量中，方便后续使用；输出语句调用则可以直接在输出中显示方法的返回值，适用于需要快速查看结果的情况。

（三）方法重载机制

在 Java 中，方法重载是一种允许在同一个类中定义多个同名方法的机制。这些方法具有相同的名称，但参数列表不同，即参数的个数、类型或顺序不同。这种机制使得程序员可以根据不同的参数输入执行相似功能的多个同名方法。

例如，可以定义不同参数个数的求和方法。以下是代码示例：

public class MethodOverloadExample {
    // 两个参数的求和方法
    public int sum(int a, int b) {
        return a + b;
    }
    // 三个参数的求和方法
    public int sum(int a, int b, int c) {
        return a + b + c;
    }
}

在这个例子中，我们定义了两个同名方法sum，但它们的参数列表不同。一个方法接收两个整数参数，另一个方法接收三个整数参数。通过这种方式，我们可以根据不同的参数输入执行相似的求和功能。

方法重载的语法特点主要体现在以下几个方面：

1. 方法名必须相同：这是方法重载的基本要求，多个方法共享同一个名称。
2. 参数列表必须不同：参数列表的不同可以体现在参数的个数、类型或顺序上。例如，可以有不同数量的参数，或者参数的类型不同，或者参数的顺序不同。
3. 与方法的返回值类型无关：方法的返回值类型不是方法重载的决定因素。即使两个方法的返回值类型不同，但如果方法名和参数列表相同，它们也不能构成重载。

方法重载的应用场景非常广泛。在实际编程中，当我们需要执行类似的功能，但输入参数的类型或数量不同时，可以使用方法重载。例如，在一个图形绘制程序中，可能有一个绘制圆形的方法，它可以接收不同的参数，如圆心坐标和半径、或者圆心坐标和直径等。通过方法重载，我们可以根据不同的参数输入来绘制不同类型的圆形。

总之，方法重载是 Java 语言中一种非常有用的机制，它可以提高代码的可读性和可维护性，同时也使得代码更加灵活和高效。