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

一文详解java中的方法

article 2025/2/28 20:13:10

1. 题记

本文详解java中的方法。

2. 方法的定义

在 Java 中，方法（Method）是一段可以被重复调用的代码块，用于执行特定的任务。

2.1 基本语法结构

方法的定义通常包含以下几个部分：

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

1. 修饰符： 用于控制方法的访问权限等特性，例如public（公共的，可以被任何类访问）、private（私有的，只能在本类内部访问）、protected（受保护的，可以被本类、同包类以及子类访问）等。还有其他修饰符如static（静态方法）等。
返回值类型：指定方法执行完毕后返回的数据类型，可以是基本数据类型（如int、double、boolean等），也可以是引用数据类型（如String、数组、自定义类等）。如果方法不返回任何值，则使用void作为返回值类型。

2. 方法名： 是一个标识符，用于唯一标识这个方法，遵循 Java 标识符的命名规则（以字母、美元符号或下划线开头，后面可以跟字母、数字、美元符号或下划线）。

3. 参数列表： 是可选的，用于向方法内部传递数据。参数可以是多个，多个参数之间用逗号分隔，每个参数由数据类型和参数名组成，例如(int num1, double num2)。

4. 方法体： 是方法的具体实现部分，包含了执行特定任务的代码语句。
返回值：如果方法的返回值类型不是void，则必须使用return关键字返回一个与返回值类型匹配的值。这个值将作为方法调用的结果返回给调用者。

5. 示例: 定义一个简单的方法来计算两个整数的和并返回结果：

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

这里public是修饰符，int是返回值类型，add是方法名，(int a, int b)是参数列表，{ int sum = a + b; return sum; }是方法体。

3. 方法的分类

1. 实例方法（Instance Method）： 依赖于类的实例，可以访问和修改实例变量。

2. 静态方法（Static Method）： 使用 static 关键字修饰，属于类本身，而不是类的实例。静态方法不能访问实例变量和实例方法（除非通过对象引用）。

3. 构造方法（Constructor）： 特殊的实例方法，用于初始化对象。构造方法的名称必须与类名相同，并且没有返回类型。

4. 抽象方法（Abstract Method）： 在抽象类中使用 abstract 关键字定义，没有方法体。必须在子类中实现。

5. 接口方法（Interface Method）： 在接口中定义的方法，默认是 public 和 abstract 的。实现接口的类必须提供这些方法的实现。

4. 方法的调用

4.1 同一类中调用方法

当在同一个类中调用方法时，可以直接使用方法名并传递相应的参数（如果有参数的话）。
例如，对于上面定义的add方法，在同一个类的其他方法中可以这样调用：

public class Main {
    public int add(int a, int b) {
        int sum = a + b;
        return sum;
    }
    public void anotherMethod() {
        int result = add(3, 5);
        System.out.println("The sum is: " + result);
    }
}

在anotherMethod中，通过add(3, 5)调用了add方法，并将返回的结果赋值给result变量。

4.2 不同类中调用方法

如果要在一个类中调用另一个类的方法，首先需要创建另一个类的对象（对于非静态方法），然后通过对象来调用方法。
假设我们有一个Calculator类，其中包含add方法，在Main类中调用它：

class Calculator {
    public int add(int a, int b) {
        int sum = a + b;
        return sum;
    }
}
class Main {
    public static void main(String[] args) {
        Calculator calculator = new Calculator();
        int result = calculator.add(2, 4);
        System.out.println("The sum is: " + result);
    }
}

这里在main方法中，先创建了Calculator类的对象calculator，然后通过calculator.add(2, 4)来调用Calculator类中的add方法。

5. 方法的重载（Overloading）

5.1 概念

方法重载是指在同一个类中，可以定义多个方法名相同，但参数列表不同（参数个数、参数类型或者参数顺序不同）的方法。方法重载与返回值类型无关。
当调用一个重载方法时，Java 会根据传递的实际参数的类型、个数和顺序来确定具体调用哪个重载方法。
例如：定义多个add方法的重载形式：

public class Calculator {
    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;
    }
}

这样，根据传递的参数类型和个数，可以调用不同的add方法，例如：

Calculator calculator = new Calculator();
int result1 = calculator.add(3, 5);
double result2 = calculator.add(3.5, 4.5);
int result3 = calculator.add(1, 2, 3);

6. 方法的重写（Override）

6.1 概念

方法重写（Override）发生在子类和父类之间。当子类继承父类时，子类可以重新定义父类中已有的方法，这个过程称为方法重写。重写后的方法具有与父类被重写方法相同的方法名、参数列表和返回值类型（或者是返回值类型为父类被重写方法返回值类型的子类型）。
方法重写的目的是让子类可以根据自己的需求来重新实现父类的方法，以提供更符合子类特点的行为。

6.2 规则

方法签名必须相同：
方法名和参数列表必须完全相同。例如，父类中有一个方法public void display(int num)，子类重写这个方法时也必须是public void display(int num)。
返回值类型规则：
子类重写方法的返回值类型要么与父类方法的返回值类型相同，要么是父类返回值类型的子类型。例如，父类方法返回Animal类型，子类重写方法可以返回Dog类型（Dog是Animal的子类）。
访问修饰符规则：
子类重写方法不能有比父类方法更严格的访问限制。也就是说，如果父类方法是public，子类重写方法可以是public或者protected，但不能是private。一般情况下，最好保持和父类相同的访问修饰符。
异常抛出规则：
子类重写方法抛出的异常类型不能比父类方法抛出的异常类型更宽泛，只能是父类抛出异常类型的子类型或者不抛出异常（如果父类方法抛出异常）。例如，如果父类方法抛出IOException，子类重写方法可以抛出FileNotFoundException（FileNotFoundException是IOException的子类）或者不抛出异常。

6.3 示例

定义一个父类Animal和一个子类Dog：

class Animal {
    public void makeSound() {
        System.out.println("Animal makes a sound");
    }
}
class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Dog barks");
    }
}

在这个例子中，Dog类继承了Animal类，并且重写了makeSound方法。当调用Dog对象的makeSound方法时，将执行Dog类中重写后的方法，而不是Animal类中的方法。

测试：

public class Main {
    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.makeSound();
        Dog dog = new Dog();
        dog.makeSound();
        Animal anotherDog = new Dog();
        anotherDog.makeSound();
    }
}

输出结果为：
Animal makes a sound
Dog barks
Dog barks
注意最后一行，虽然变量anotherDog的类型是Animal，但是它实际指向的是Dog对象，所以调用makeSound方法时执行的是Dog类中重写后的方法。这体现了多态性，根据对象的实际类型来决定调用哪个重写后的方法。

6.4 方法重写与方法重载的区别

发生位置：
方法重写发生在子类和父类之间，是对继承的方法进行重新定义。而方法重载发生在同一个类中，是定义多个同名但参数不同的方法。
方法签名：
重写要求方法签名（方法名和参数列表）必须相同，而重载要求方法名相同但参数列表不同（参数个数、参数类型或者参数顺序不同）。
返回值类型、访问修饰符和异常抛出规则：
重写有严格的返回值类型、访问修饰符和异常抛出规则，而重载主要关注参数列表的不同，与返回值类型、访问修饰符和异常抛出（只要符合方法本身的规则）没有像重写那样严格的关联。

7. 静态方法（Static Method）

7.1 概念

静态方法是使用static修饰符定义的方法。它属于类本身，而不是类的某个对象。这意味着可以在没有创建类对象的情况下调用静态方法。
静态方法可以访问类的静态成员（静态变量、静态方法），但不能直接访问非静态成员（非静态变量、非静态方法），因为非静态成员是与对象相关联的。

7.2 示例

定义一个静态方法来计算圆的面积：

class Circle {
    static final double PI = 3.14;
    public static double calculateArea(double radius) {
        return PI * radius * radius;
    }
}

可以这样调用静态方法：

double area = Circle.calculateArea(2.0);
不需要创建Circle类的对象，直接通过类名Circle就可以调用calculateArea静态方法。

8. 方法参数传递机制

8.1 基本数据类型参数传递

当传递基本数据类型（如int、double等）作为方法参数时，是值传递。这意味着方法内部对参数的修改不会影响到方法外部的原始变量。
例如：

public class Main {
    public static void increment(int num) {
        num++;
    }
    public static void main(String[] args) {
        int number = 5;
        increment(number);
        System.out.println("The value of number is: " + number);
    }
}

输出结果仍然是5，因为在increment方法中，只是修改了num这个局部变量（它是number的一个副本），而没有改变number本身。

8.2 引用数据类型参数传递

当传递引用数据类型（如数组、对象等）作为方法参数时，是引用传递。这意味着方法内部可以通过引用来修改对象的属性或者数组的元素。
例如：

class Person {
    int age;
    public Person(int age) {
        this.age = age;
    }
}
public class Main {
    public static void incrementAge(Person p) {
        p.age++;
    }
    public static void main(String[] args) {
        Person person = new Person(20);
        incrementAge(person);
        System.out.println("The age of person is: " + person.age);
    }
}

输出结果是21，因为在incrementAge方法中，通过引用p修改了Person对象的age属性，而这个对象与main方法中的person是同一个对象。