JAVA方法和变量

一、成员方法

1.1 什么是成员方法

在Java编程语言中，成员方法是定义在一个类中的一种方法，用于实现类的行为和功能。这种行为和功能代表了对象可以执行的操作或从对象中获取的信息。例如，成员方法可以描述一个"人类"能够"跑步"或者"说话"等行为。

成员方法具有以下的结构特点：

• 1、方法名称：每个成员方法都有一个唯一的名称，用于在程序中调用这个方法。
• 2、返回值类型：每个成员方法都有返回值类型，这表示了执行完这个方法后将向调用者返回何种类型的数据。如果一个成员方法不向调用者返回任何数据，那么它的返回值类型为void。
• 3、参数列表：参数是传递给成员方法的值。参数列表是在调用方法时传递给该方法的值的列表。参数可以是任何类型，包括基本数据类型和对象类型。多个参数之间用逗号分隔。
• 4、方法体：这是执行成员方法的实际代码。它包含了一系列的指令，用于完成特定的任务。

1.2 为什么使用成员方法

在Java编程语言中，成员方法是实现类的行为和功能的关键工具。它们代表了对象可以执行的操作或从对象中获取的信息，例如描述一个"人类"能够"跑步"或者"说话"等行为。成员方法将复杂的程序划分为多个具有独立功能的模块，这使得程序更易于管理和理解。

此外，成员方法提供了代码的封装和数据隐藏。通过使用成员方法，开发者可以控制对类的数据和方法的访问权限，仅允许特定的操作在类的内部发生，从而保护了数据的完整性和安全性。

再者，成员方法使得代码复用成为可能。如果在一个类中定义了一个方法，那么在其他类中也可以使用这个方法，而不需要重新编写相同的代码。这大大提高了编程效率并减少了错误的可能性。

最后，成员方法也支持多态性。这意味着在父类中定义的方法可以在子类中被重写，从而实现了同一种行为在不同对象上的不同表现形式。这是面向对象编程的一个重要特性，它增强了程序的灵活性和可扩展性。

二、无参方法

2.1 如何定义无参方法

在Java编程语言中，定义无参方法非常简单。只需要使用关键字void作为返回类型，并在括号内留空即可。

以下是一个简单的示例：

public class MyClass {
    // 定义一个无参方法
    void myMethod() {
        System.out.println("这是一个无参方法");
    }
}

在这个例子中，myMethod是一个无参方法，它没有参数，并且当被调用时不返回任何值。当你运行这个程序时，它将打印出"这是一个无参方法"。

2.2 无参方法的调用

在Java中，无参方法的调用非常简单。首先，你需要创建一个类，然后在该类中定义一个无参方法。接下来，你可以在主方法（main method）中创建该类的对象，并使用对象调用无参方法。以下是一个简单的示例：

public class MyClass {
    // 定义一个无参方法
    void myMethod() {
        System.out.println("这是一个无参方法");
    }

    public static void main(String[] args) {
        // 创建MyClass对象
        MyClass obj = new MyClass();

        // 调用无参方法
        obj.myMethod();
    }
}

输出结果：

这是一个无参方法

在这个示例中，我们创建了一个名为MyClass的类，并在其中定义了一个名为myMethod的无参方法。然后，在main方法中，我们创建了MyClass的一个对象obj，并使用该对象调用了myMethod方法。

2.3 同一个类方法互调

在同一个类中，方法之间可以通过创建对象来互相调用。以下是一个示例：

public class Test {
    public static void main(String[] args) {
        Test obj = new Test();
        obj.methodA();
        obj.methodB();
    }

    public void methodA() {
        System.out.println("这是方法A");
        methodB();
    }

    public void methodB() {
        System.out.println("这是方法B");
        methodA();
    }
}

在这个示例中，我们创建了一个名为Test的类，其中包含两个方法methodA和methodB。在main方法中，我们创建了一个Test类的对象obj，然后分别调用了methodA和methodB方法。这样，methodA和methodB就可以互相调用了。

2.4 不同类中方法互调

在Java中，不同类中的方法可以通过创建对象来互相调用。以下是一个示例：

假设有两个类：ClassA 和 ClassB。

// ClassA.java
public class ClassA {
    public void methodA() {
        System.out.println("这是ClassA中的methodA");
        ClassB obj = new ClassB();
        obj.methodB();
    }
}

// ClassB.java
public class ClassB {
    public void methodB() {
        System.out.println("这是ClassB中的methodB");
        ClassA obj = new ClassA();
        obj.methodA();
    }
}

在这个示例中，我们在 ClassA 的 methodA 方法中创建了一个 ClassB 的对象 obj，然后调用了它的 methodB 方法。同样，在 ClassB 的 methodB 方法中，我们创建了一个 ClassA 的对象 obj，然后调用了它的 methodA 方法。这样，我们就实现了不同类中方法的互相调用。

三、有参方法

3.1 为什么使用有参方法

在Java编程语言中，使用有参方法的原因多种多样。首先，有参方法允许我们将特定的值传递给方法，这些值被用来初始化方法内部的变量或对象的状态。这种传递参数的能力使得方法能够根据不同的输入执行不同的操作，增加了代码的灵活性和复用性。

例如，假设我们有一个名为calculateSum的方法，该方法需要两个参数num1和num2以计算它们的和。通过使用有参方法，我们可以将任何我们希望相加的两个数字作为参数传递给这个方法，从而使得这个方法更加通用和适用性强。

此外，有参方法也使得类的构造更加灵活。通过使用有参构造方法，我们可以在创建对象时传入特定的参数，以便根据参数对对象的状态进行初始化。这在需要根据特定条件来初始化对象的情况下非常有用。例如，一个表示矩形的类可能会有一个有参构造方法，该方法接受宽度和高度作为参数，以便在创建矩形对象时指定其大小。

总之，有参方法提供了一种强大的方式来增加代码的灵活性、复用性和可维护性。它们使得方法能够根据不同的输入执行不同的操作，并且使得类的构造过程更加灵活和可控。

3.2 有参方法的定义

在Java编程语言中，定义带参方法需要遵循特定的格式。首先，方法的访问修饰符指定了该方法允许被访问的权限方位，只能是public、protected或private。如果希望该方法可以被任何其他代码调用，我们通常使用public访问修饰符。

其次，我们需要为方法指定返回值类型。如果方法不返回任何值，我们应声明void类型。然后是方法名和参数列表。方法名应当是一个实际的名称，能够清晰地表达出方法的功能。参数列表是一系列用逗号分隔的参数，这些参数需要在括号内声明。每个参数包括参数类型和参数名两部分。

最后，我们在大括号{}中编写方法体，也就是方法的具体实现。例如：

public class MyClass {
    // 定义一个带参方法
    public int add(int num1, int num2) {
        int sum = num1 + num2;
        return sum;
    }
}

在这个示例中，add是方法名，num1和num2是参数，它们的类型都是int。这个方法将两个数相加并返回结果。当我们在其他类或位置需要执行加法操作时，就可以通过创建MyClass的对象，并调用其add方法来使用这个功能。

3.3 调用有参方法

在Java编程语言中，调用带参方法需要遵循特定的格式。首先，我们需要创建一个对象或引用该类，以便能够访问该方法。然后，我们使用点运算符（.）和对象名来调用该方法，并在括号内传递参数。

例如，假设我们有一个名为MyClass的类，其中包含一个名为add的带参方法，该方法接受两个整数参数并返回它们的和。我们可以按照以下方式调用该方法：

public class MyClass {
    // 定义一个带参方法
    public int add(int num1, int num2) {
        int sum = num1 + num2;
        return sum;
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建MyClass对象
        MyClass obj = new MyClass();

        // 调用add方法并传递参数
        int result = obj.add(3, 5);

        // 输出结果
        System.out.println("The sum is: " + result);
    }
}

在这个示例中，我们首先创建了一个名为obj的MyClass对象。然后，我们使用点运算符和对象名来调用add方法，并在括号内传递了两个整数参数3和5。最后，我们将返回的结果存储在变量result中，并将其打印到控制台上。

四、参数传递

4.1 值传递和引用传递

Java 参数传递可以分为两种分类：值传递和引用传递

• 1、值传递（Pass by Value）：在方法调用时，将实参的值复制一份传递给形参，形参和实参是两个不同的变量，它们之间没有任何关联。因此，对形参的修改不会影响到实参的值。

• 2、引用传递（Pass by Reference）：在方法调用时，将实参的引用（地址）传递给形参，形参和实参指向同一个对象。因此，对形参的修改会影响到实参所指向的对象。

4.2 参数是基本数据类型

当参数是基本数据类型时，Java 使用值传递。这意味着在方法调用时，实参的值会被复制一份传递给形参，形参和实参是两个不同的变量，它们之间没有任何关联。因此，对形参的修改不会影响到实参的值。

例如，以下代码展示了一个接受基本数据类型参数的方法：

public class Main {
    public static void main(String[] args) {
        int a = 10;
        changeValue(a);
        System.out.println("a: " + a); // 输出 a: 10
    }

    public static void changeValue(int num) {
        num = 20;
    }
}

在这个例子中，changeValue 方法接受一个整数参数 num，并将其值更改为 20。然而，当我们在 main 方法中打印 a 的值时，它仍然是原始值 10，因为 changeValue 方法中的 num 是一个局部变量，与 main 方法中的 a 无关。

4.3 当参数是引用数据类型

当参数是引用数据类型时，Java 使用引用传递。这意味着在方法调用时，实参的引用（地址）会被传递给形参，形参和实参指向同一个对象。因此，对形参的修改会影响到实参所指向的对象。

例如，以下代码展示了一个接受引用数据类型参数的方法：

public class Main {
    public static void main(String[] args) {
        String str = "Hello";
        changeValue(str);
        System.out.println("str: " + str); // 输出 str: Hello
    }

    public static void changeValue(String str) {
        str = "World";
    }
}

在这个例子中，changeValue 方法接受一个字符串参数 str，并将其值更改为 “World”。然而，当我们在 main 方法中打印 str 的值时，它仍然是原始值 “Hello”，因为 changeValue 方法中的 str 是一个局部变量，与 main 方法中的 str 无关。

五、递归

5.1 递归求和

要使用Java递归求和，可以创建一个方法，接受一个整数数组和一个索引作为参数。在方法中，首先检查索引是否超出了数组的范围，如果是，则返回0。否则，返回当前索引处的值加上对下一个索引的递归调用的结果。

以下是实现这个功能的Java代码：

public class SumRecursion {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        int sum = sum(arr, 0);
        System.out.println("数组之和为： " + sum);
    }

    public static int sum(int[] arr, int index) {
        if (index >= arr.length) {
            return 0;
        } else {
            return arr[index] + sum(arr, index + 1);
        }
    }
}

在这个例子中，我们创建了一个名为sum的方法，它接受一个整数数组arr和一个整数index作为参数。我们在main方法中调用这个方法，传入一个整数数组{1, 2, 3, 4, 5}和初始索引0。最后，我们打印出数组的和。

5.2 递归特点归纳

Java递归的特点归纳如下：

• 1、函数内部调用自身，形成递归调用。
• 2、递归调用必须有一个明确的结束条件，否则会导致无限循环。
• 3、递归调用的深度不能过大，否则会导致栈溢出。
• 4、递归算法通常比非递归算法更简洁、易懂。

六、返回值

Java中方法的返回值类型定义在方法名前，可以是任何数据类型，包括基本数据类型和引用数据类型。如果方法没有返回值，则返回值类型为void。
例如：

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

public void printHello() {
    System.out.println("Hello");
}

6.1 调用无返回值方法

在Java中，如果一个方法没有返回值（即void类型），那么在调用该方法时，不需要使用任何变量来接收返回值。直接调用即可。例如：

public class Test {
    public static void main(String[] args) {
        myMethod(); // 直接调用无返回值的方法
    }

    public static void myMethod() {
        System.out.println("这是一个无返回值的方法");
    }
}

6.2 return关键字

Java中的return关键字用于从方法中返回一个值。当执行到return语句时，方法会立即结束，并将指定的值返回给调用者。如果方法没有指定返回类型，则默认返回void。

public int add(int a, int b) {
    int sum = a + b;
    return sum; // 返回sum的值
}

public void printHello() {
    System.out.println("Hello");
    return; // 结束方法并返回void
}

6.3 调用有返回值方法

在Java中，调用有返回值的方法需要使用变量来接收返回值。以下是一个示例：

public class Main {
    public static void main(String[] args) {
        int result = add(1, 2);
        System.out.println("结果是： " + result);
    }

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

在这个示例中，我们定义了一个名为add的方法，它接受两个整数参数并返回它们的和。在main方法中，我们调用了add方法并将返回值存储在变量result中，然后打印结果

七、实例方法

7.1 什么是实例方法

Java中的实例方法是指定义在类中，并使用关键字void或返回值类型声明的方法。实例方法可以访问类的非静态成员变量和非静态成员方法，并且必须通过类的实例对象来调用。

以下是一个简单的Java实例方法的示例：

public class MyClass {
    // 非静态成员变量
    private int myVariable;

    // 构造方法
    public MyClass(int value) {
        myVariable = value;
    }

    // 实例方法
    public void printMyVariable() {
        System.out.println("myVariable的值为：" + myVariable);
    }
}

在上面的代码中，printMyVariable就是一个实例方法，它可以通过创建MyClass的对象来调用。例如：

public class Main {
    public static void main(String[] args) {
        // 创建MyClass对象
        MyClass obj = new MyClass(10);
        // 调用实例方法
        obj.printMyVariable(); // 输出：myVariable的值为：10
    }
}

7.2 实例方法的内涵及外延

Java中的实例方法是指定义在类中，并使用关键字void或返回值类型声明的方法。实例方法可以访问类的非静态成员变量和非静态成员方法，并且必须通过类的实例对象来调用。

内涵：

• 1、实例方法是定义在类中的，因此它们可以被该类的对象所共享。
• 2、实例方法可以访问类的非静态成员变量和非静态成员方法，这意味着它们可以访问和修改类的状态。
• 3、实例方法必须通过类的实例对象来调用，因为它们需要访问类的成员变量和方法。
• 4、实例方法可以使用关键字this来引用当前对象，这使得可以在方法内部访问当前对象的成员变量和方法。
• 5、实例方法可以有参数，这些参数可以是任何数据类型，包括基本数据类型、引用数据类型和数组等。
• 6、实例方法可以有返回值，这些返回值可以是任何数据类型，包括基本数据类型、引用数据类型和数组等。

外延：

• 1、实例方法是面向对象的编程思想的核心之一，它使得可以将数据和操作数据的方法封装在一个类中，从而实现了代码的复用和模块化。
• 2、实例方法是实现类的行为的主要手段，它们定义了类的功能和行为。
• 3、实例方法是实现继承和多态的基础，子类可以通过重写父类的实例方法来实现自己的功能和行为。
• 4、实例方法是实现接口的关键，接口只能定义抽象方法和常量，而实例方法必须由实现接口的类来实现。