Três formatos de chamada e sobrecarga de método de métodos Java

Três formatos de chamada de métodos

Depois de definido o método, ele não será executado, se quiser executá-lo deve-se chamá-lo: chamada separada, chamada de impressão, chamada de atribuição.

1. Chamada separada: nome do método (parâmetro);
2. Chamada de impressão: System.out.println (nome do método (parâmetro));
3. Chamada de atribuição: nome da variável do tipo de dados = nome do método (parâmetro);

Nota: O método cujo tipo de valor de retorno é fixo como void não tem valor de retorno e só pode ser chamado individualmente e não pode ser usado para chamadas de impressão ou chamadas de atribuição.

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 da operação:

Sobrecarga de método

Sobrecarga de método (Sobrecarga): vários métodos têm o mesmo nome, mas a lista de parâmetros é diferente.
Benefício: você só precisa se lembrar do único nome do método para obter várias funções semelhantes.

A sobrecarga do método está relacionada aos seguintes fatores:

1. O número de parâmetros é diferente
2. Diferentes tipos de parâmetros
3. A ordem dos vários tipos de parâmetros é diferente

A sobrecarga do método não tem nada a ver com os seguintes fatores:

1. Não tem nada a ver com o nome do parâmetro
2. Não tem nada a ver com o tipo de valor de retorno do 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 da operação:

Experimente ----- determine se a seguinte sobrecarga de método está correta:

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

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

3. static void sum (int a, int b) {} // Erro de código: conflito com a linha 8

4. public static void sum (double a, int b) {} // 正确

5. public static void sum (int a, double b) {} // Erro de código: conflito com a linha 6

6. public void sum (int i, double d) {} ​​// Erro de código: conflito com a linha 5

7. public static void SUM () {} // O código está correto e não relatará um erro, mas não é uma sobrecarga válida

8. public static void sum (int i, int j) {} // Erro de código: conflito com a linha 3