当前位置：首页 > news >正文

Java笔记2——编程基础

news 来源：原创 2025/5/19 21:15:12

一、循环语句

在Java中，循环语句用于重复执行一段代码，直到满足某个条件为止。Java提供了三种主要的循环语句：for 循环、while 循环和 do-while 循环。以下是它们的详细介绍和示例。

1. `for` 循环

for 循环是最常用的循环语句，适用于已知循环次数的情况。

语法：

for (初始化; 条件判断; 更新) {
    // 循环体
}

特点：

初始化：在循环开始前执行一次，通常用于声明和初始化循环变量。

条件判断：每次循环前检查条件是否为 true，如果是则执行循环体，否则退出循环。

更新：每次循环结束后执行，通常用于更新循环变量。

示例：

for (int i = 0; i < 5; i++) {
    System.out.println("i = " + i);
}
// 输出：
// i = 0
// i = 1
// i = 2
// i = 3
// i = 4

2. `while` 循环

while 循环适用于循环次数未知，但可以明确循环条件的情况。

语法：

while (条件判断) {
    // 循环体
}

特点：

条件判断：在每次循环前检查条件是否为 true，如果是则执行循环体，否则退出循环。

如果条件一开始为 false，循环体一次也不会执行。

示例：

int i = 0;
while (i < 5) {
    System.out.println("i = " + i);
    i++;
}
// 输出：
// i = 0
// i = 1
// i = 2
// i = 3
// i = 4

3. `do-while` 循环

do-while 循环与 while 循环类似，但区别在于它会先执行循环体，然后再检查条件。

语法：

do {
    // 循环体
} while (条件判断);

特点：

无论条件是否为 true，循环体至少会执行一次。

条件判断在循环体执行后进行。

示例：

int i = 0;
do {
    System.out.println("i = " + i);
    i++;
} while (i < 5);
// 输出：
// i = 0
// i = 1
// i = 2
// i = 3
// i = 4

4. 嵌套循环

循环可以嵌套使用，即在一个循环体内包含另一个循环。嵌套循环常用于多维数据结构的处理。

示例：

for (int i = 1; i <= 3; i++) {
    for (int j = 1; j <= 3; j++) {
        System.out.println("i = " + i + ", j = " + j);
    }
}
// 输出：
// i = 1, j = 1
// i = 1, j = 2
// i = 1, j = 3
// i = 2, j = 1
// i = 2, j = 2
// i = 2, j = 3
// i = 3, j = 1
// i = 3, j = 2
// i = 3, j = 3

5. 循环控制语句

break：用于立即退出循环。

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

示例：

// 使用 break
for (int i = 0; i < 10; i++) {
    if (i == 5) {
        break; // 退出循环
    }
    System.out.println(i);
}
// 输出：0, 1, 2, 3, 4

// 使用 continue
for (int i = 0; i < 10; i++) {
    if (i % 2 == 0) {
        continue; // 跳过偶数
    }
    System.out.println(i);
}
// 输出：1, 3, 5, 7, 9

6、总结

for 循环：适用于已知循环次数的情况。

while 循环：适用于条件明确但循环次数未知的情况。

do-while 循环：确保循环体至少执行一次。

嵌套循环：用于处理多维数据结构。

break 和 continue：用于控制循环的执行流程。

二、方法

在Java中，方法（Method）是一种代码块，用于执行特定的任务或功能。方法是Java程序的基本构建块之一，通过方法可以实现代码的模块化和复用。以下是关于Java方法的详细介绍：

1. 方法的基本结构

方法由以下部分组成：

访问修饰符：决定方法的可见性（如public、private等）。

返回值类型：方法执行后返回的数据类型（如int、String、void等）。

方法名：方法的名称，遵循Java命名规则。

参数列表：方法接收的输入值，可以是零个或多个参数。

方法体：包含具体的代码逻辑，用大括号{}包裹。

访问修饰符 返回值类型 方法名(参数列表) {
    // 方法体
    return 返回值; // 如果返回值类型不是void
}

2. 方法的定义和调用

方法定义

定义一个方法的语法如下：

public class MyClass {
    // 定义一个方法
    public void myMethod() {
        System.out.println("Hello, World!");
    }
}

方法调用

通过对象调用方法：

public class Main {
    public static void main(String[] args) {
        MyClass obj = new MyClass();//创建方法对象
        obj.myMethod(); // 调用方法
    }
}

3. 方法的参数

方法可以接收参数，参数是方法的输入值。参数类型可以是基本数据类型或引用类型。

示例：

public class Calculator {
    // 定义一个带有参数的方法
    public int add(int a, int b) {
        return a + b;
    }
}

public class Main {
    public static void main(String[] args) {
        Calculator calc = new Calculator();
        int result = calc.add(5, 3); // 调用方法并传入参数
        System.out.println("Result: " + result); // 输出：Result: 8
    }
}

4. 方法的返回值

方法可以返回一个值，返回值的类型在方法定义时指定。如果方法没有返回值，则使用void。

示例：

public class Greeting {
    // 返回一个字符串
    public String sayHello(String name) {
        return "Hello, " + name + "!";
    }
}

public class Main {
    public static void main(String[] args) {
        Greeting greet = new Greeting();
        String message = greet.sayHello("Alice");
        System.out.println(message); // 输出：Hello, Alice!
    }
}

5. 方法的重载（Overloading）

方法重载是指在同一个类中，允许定义多个同名方法，但它们的参数列表不同（参数数量、类型或顺序不同）。

示例：

public class Calculator {
    // 重载add方法
    public int add(int a, int b) {
        return a + b;
    }

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

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

public class Main {
    public static void main(String[] args) {
        Calculator calc = new Calculator();
        System.out.println(calc.add(2, 3)); // 输出：5
        System.out.println(calc.add(2.5, 3.5)); // 输出：6.0
        System.out.println(calc.add(1, 2, 3)); // 输出：6
    }
}

6. 静态方法（Static Method）

静态方法属于类而不是对象，可以直接通过类名调用，而不需要创建对象。

示例：

public class MathUtils {
    // 静态方法
    public static int multiply(int a, int b) {
        return a * b;
    }
}

public class Main {
    public static void main(String[] args) {
        int result = MathUtils.multiply(4, 5); // 通过类名调用静态方法
        System.out.println("Result: " + result); // 输出：Result: 20
    }
}

7. 递归方法

递归方法是指方法调用自身来解决问题。递归需要有一个终止条件，否则会导致无限递归。

示例（计算阶乘）：

public class Factorial {
    // 递归方法计算阶乘
    public int factorial(int n) {
        if (n == 0) { // 终止条件
            return 1;
        } else {
            return n * factorial(n - 1); // 递归调用
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Factorial fact = new Factorial();
        System.out.println(fact.factorial(5)); // 输出：120
    }
}

8. 方法的参数传递

Java中的参数传递分为两种：

值传递（Pass by Value）：基本数据类型（如int、char）的值直接传递。
引用传递（Pass by Reference）：对象的引用传递，方法可以修改对象的状态。——有点难

示例：

public class ParameterPassing {
    // 值传递
    public void changeValue(int x) {
        x = 10;
    }

    // 引用传递
    public void changeObject(StringBuilder sb) {
        sb.append(" World");
    }
}

public class Main {
    public static void main(String[] args) {
        ParameterPassing obj = new ParameterPassing();

        // 值传递示例
        int num = 5;
        obj.changeValue(num);
        System.out.println(num); // 输出：5（值未改变）

        // 引用传递示例
        StringBuilder sb = new StringBuilder("Hello");
        obj.changeObject(sb);
        System.out.println(sb); // 输出：Hello World（对象状态被修改）
    }
}