Tres formatos de llamada y sobrecarga de métodos de los métodos Java

Tres formatos de llamada de métodos

Una vez definido el método, no se ejecutará. Si desea ejecutarlo, debe llamarlo: llamada separada, llamada de impresión, llamada de asignación.

1. Llamada separada: nombre del método (parámetro);
2. Imprimir llamada: System.out.println (nombre del método (parámetro));
3. Llamada de asignación: tipo de datos nombre de variable = nombre de método (parámetro);

Nota: El método cuyo tipo de valor de retorno se fija como nulo no tiene valor de retorno y solo se puede llamar individualmente y no se puede utilizar para imprimir llamadas o asignaciones.

public class MethodDefine {
    
    

    public static void main(String[] args) {
    
    
        // 单独调用
        sum(10, 20);
        System.out.println("===========");

        // 打印调用
        System.out.println(sum(10, 20)); // 30
        System.out.println("===========");

        // 赋值调用
        int number = sum(15, 25);
        number += 100;
        System.out.println("变量的值：" + number); // 140
    }

    public static int sum(int a, int b) {
    
    
        System.out.println("方法执行啦！");
        int result = a + b;
        return result;
    }

}

resultado de la operación:

Sobrecarga de métodos

Sobrecarga de métodos (sobrecarga): varios métodos tienen el mismo nombre, pero la lista de parámetros es diferente.
Beneficio: solo necesita recordar el único nombre del método para lograr múltiples funciones similares.

La sobrecarga de métodos está relacionada con los siguientes factores:

1. El número de parámetros es diferente
2. Diferentes tipos de parámetros
3. El orden de varios tipos de parámetros es diferente

La sobrecarga de métodos no tiene nada que ver con los siguientes factores:

1. No tiene nada que ver con el nombre del parámetro.
2. No tiene nada que ver con el tipo de valor de retorno del método.

public class Demo01MethodOverload {
    
    

    public static void main(String[] args) {
    
    
        /*System.out.println(sumTwo(10, 20)); // 30
        System.out.println(sumThree(10, 20, 30)); // 60
        System.out.println(sumFour(10, 20, 30, 40)); // 100*/

        System.out.println(sum(10, 20)); // 两个参数的方法默认int
        System.out.println(sum(10d, 20)); // 两个参数的方法10d与(double)10相同
        System.out.println(sum(10, 20, 30)); // 三个参数的方法
        System.out.println(sum(10, 20, 30, 40)); // 四个参数的方法
//        System.out.println(sum(10, 20, 30, 40, 50)); // 找不到任何方法来匹配，所以错误！

        sum(10, 20);
    }

    public static int sum(int a, double b) {
    
    

        System.out.println("有2个参数的方法执行1！");
        return (int) (a + b);
    }

    public static int sum(double a, int b) {
    
    
        System.out.println("有2个参数的方法执行2！");
        return (int) (a + b);
    }

    public static int sum(int a, int b) {
    
    
        System.out.println("有2个参数的方法执行3！");
        return a + b;
    }

    // 错误写法！与方法的返回值类型无关
//    public static double sum(int a, int b) {
    
    
//        return a + b + 0.0;
//    }

    // 错误写法！与参数的名称无关
//    public static int sum(int x, int y) {
    
    
//        return x + y;
//    }

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

    public static int sum(int a, int b, int c) {
    
    
        System.out.println("有3个参数的方法执行！");
        return a + b + c;
    }

    public static int sum(int a, int b, int c, int d) {
    
    
        System.out.println("有4个参数的方法执行！");
        return a + b + c + d;
    }

}

resultado de la operación:

Pruébelo ----- determine si la siguiente sobrecarga del método es correcta:

1. public static void sum () {} // correcto

2. public static void sum (int a) {} // correcto

3. static void sum (int a, int b) {} // Error de código: conflicto con la línea 8

4. suma vacía estática pública (doble a, int b) {} // 正确

5. public static void sum (int a, double b) {} // Error de código: conflicto con la línea 6

6. public void sum (int i, double d) {} ​​// Error de código: conflicto con la línea 5

7. public static void SUM () {} // El código es correcto y no informará un error, pero no es una sobrecarga válida

8. public static void sum (int i, int j) {} // Error de código: conflicto con la línea 3