【Java入门】方法及方法重载_java方法重载

方法及方法重载

方法的定义、调用及其注意事项

方法：是将具有独立功能的代码块组织成为一个整体，使其具有特殊功能的代码集
1、定义格式:
修饰符 返回值类型 方法名(参数){
方法体;
返回值;
}

参数的种类:形式参数和实际参数
形参:方法声明的不具有数值的参数

实参:方法体中的有实际值的参数

方法定义中的参数是形参，方法调用中的参数是实参。

2、调用
在主方法内直接调用,利用方法名调用

3、注意事项
1.方法体内不能嵌套方法即方法不能定义在另一个方法里面

 public static void main(String[] args) {
        //方法的调用
        methodName();
        //接收返回值以及输出j
        int j = methodInt();
        System.out.println(j);
        int q1 = 50, p1 = 60;//实际参数具有值
        int sum = methodInt1(q1, p1);
        System.out.println(sum);
    }


    //方法的定义
    public static void methodName() {
        //括号内为方法体
        System.out.println("这是个方法");
        return;
    }

    public static int methodInt() {
        int i;
        i = 10 + 20;
        //返回整型变量i
        return i;
    }

    //带形式参数的方法
    public static int methodInt1(int q, int p) {
        int sum = p + q;
        return sum;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

方法的重载:

多个方法要在同一个类中
多个方法的方法名相同,参数列表不同

参数个数不同
参数类型不同
参数类型顺序不同

无关:
返回值类型无关
参数变量名无关

public static void main(String[] args) {

        Int(1);
        Int(1, 2);
        Int(1.0, 2.0);

    }

    public static int Int(int a) {
        int sum = a;
        System.out.println("函数重载" + sum);
        return sum;
    }

    public static int Int(int a, int b) {
        int sum = a + b;
        System.out.println("函数重载" + sum);
        return sum;
    }

    public static double Int(double a, double b) {
        double sum = a + b;
        System.out.println("函数重载" + sum);
        return sum;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

方法参数传递（基本类型）

对于基本数据类型的参数，形参的改变不影响实参的值

public class Main {

    public static void main(String[] args) {
        int a = 10;
        System.out.println("未调用Change方法前" + a);//10
        Change(a);
        System.out.println("未调用Change方法后" + a);//10

    }

    public static void Change(int num) {
        num = 20;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

方法参数传递（引用类型）

对于引用类型的参数，形式参数的改变，影响实际参数的值。

public class Main {

    public static void main(String[] args) {
        int[] arr=new int []{1,2,3};
        System.out.println("未调用Change方法前" + arr[1]);//2
        Change(arr);
        System.out.println("未调用Change方法后" + arr[1]);//10

    }
    //其堆内存中的数组存储空间内存储单元里的内容发生改变
    public static void Change(int arr[]) {
        arr[1] = 10;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

方法参数传递是指在调用一个方法时，将数据从一个对象传递给该方法的过程。Java中的方法参数传递有两种类型：基本类型和引用类型。

1. 基本类型：基本类型是值类型，包括byte、short、int、long、float和double等。当一个基本类型的变量作为方法的参数传递时，实际上是将该变量的值复制到方法的参数中。这意味着在方法内部对参数进行修改不会影响原始变量的值。例如：

public static void printNumber(int num) {
    System.out.println("The number is: " + num);
}

public static void main(String[] args) {
    int myNum = 10;
    printNumber(myNum); // The number is: 10
}


1
2
3
4
5
6
7
8
9
10
11

在这个例子中，我们定义了一个名为printNumber的方法，它接受一个整数类型的参数num。在main方法中，我们定义了一个整数类型的变量myNum,并将其传递给printNumber方法。由于num是基本类型，因此在方法内部对其进行修改不会影响原始变量的值。

1. 引用类型：引用类型是值类型的一种特殊情况，它可以存储另一个对象的引用。当一个引用类型的变量作为方法的参数传递时，实际上是将该变量所指向的对象的引用传递给方法。这意味着在方法内部对参数所指向的对象进行修改会影响原始变量所指向的对象的值。例如：

public static void printArray(int[] arr) {
    for (int i = 0; i < arr.length; i++) {
        System.out.println("Element at index " + i + " is: " + arr[i]);
    }
}

public static void main(String[] args) {
    int[] myArr = {10, 20, 30};
    printArray(myArr); // Element at index 0 is: 10
    arr[0] = 40; // This changes the value of myArr in main method as well!
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14

在这个例子中，我们定义了一个名为printArray的方法，它接受一个整数数组类型的参数arr。在main方法中，我们定义了一个整数数组类型的变量myArr,并将其传递给printArray方法。由于arr是一个引用类型，因此在方法内部对其所指向的对象进行修改会影响原始变量所指向的对象的值。

方法重载的优点
可以提高代码的可读性和可维护性。如果一个类中有多个同名的方法，那么它们可能会被混淆，导致代码难以理解和维护。而通过方法重载，可以将不同的方法定义为不同的名称，从而使代码更加清晰易懂。

下面是一个使用方法重载的例子：

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;
    }
    
    public double add(double a, double b, double c) {
        return a + b + c;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

在这个例子中，我们定义了一个名为Calculator的类，其中包含了两个名为add的方法。第一个方法接受两个整数类型的参数并返回一个整数类型的结果，第二个方法接受两个双精度浮点数类型的参数并返回一个双精度浮点数类型的结果。另外，我们还定义了两个名为add的方法，它们接受三个整数或双精度浮点数类型的参数并返回一个整数或双精度浮点数类型的结果。这两个方法虽然名称相同，但是它们的参数列表不同，因此它们被视为不同的方法。

当我们调用这些方法时，根据传递的参数列表的不同，编译器会自动选择合适的方法进行调用。例如，当我们调用add(1,2)时，编译器会选择第一个名为add的方法进行调用。而当我们调用add(1.0,2.0)时，编译器会选择第二个名为add的方法进行调用。当我们调用add(1,2,3)时，编译器会选择第三个名为add的方法进行调用。当我们调用add(1.0,2.0,3.0)时，编译器会选择第四个名为add的方法进行调用。

总之，方法重载是一种非常有用的编程技巧。它可以提高代码的可读性和可维护性，并且可以让程序员更加灵活地编写代码。

注意

方法及方法重载是Java编程中非常重要的概念，它们可以提高代码的可读性和可维护性。但是在使用方法重载时，需要注意以下几点：

1. 参数列表必须不同：方法重载要求不同的方法具有不同的参数列表。如果两个方法的参数列表相同，那么它们被视为同一个方法的重载版本。因此，在定义方法重载时，需要确保每个方法的参数列表都不同。

2. 返回类型可以相同：虽然方法重载要求不同的方法具有不同的参数列表，但是它们的返回类型可以相同。这意味着一个方法可以有多个返回值，而另一个方法也可以有多个返回值。

3. 访问修饰符不能相同：方法重载要求不同的方法具有不同的访问修饰符。如果两个方法的访问修饰符相同，那么它们被视为同一个方法的重载版本。因此，在定义方法重载时，需要确保每个方法的访问修饰符都不同。

4. 名称必须唯一：虽然方法重载要求不同的方法具有不同的参数列表和访问修饰符，但是它们的名称必须唯一。如果两个方法的名称相同，那么它们被视为同一个方法的重载版本。因此，在定义方法重载时，需要确保每个方法的名称都不同。

总之，在使用方法重载时，需要注意以上几点，以确保代码的正确性和可读性。

书籍推荐

以下是一些比较经典的Java书籍推荐：

1. 《Effective Java》：这本书是Java程序员必读的一本书，它可以帮助你写出更好的Java代码。
2. 《Java核心技术卷 1+卷 2》：这两本书是非常适合有一定Java基础的人阅读的，它们介绍了Java的核心技术，包括语言特性、集合框架、IO流等等。
3. 《Head First Java》：这本书是一本非常有趣的Java入门书籍，它通过图像和生动的例子来帮助读者理解Java编程的概念。
4. 《深入理解Java虚拟机》：这本书介绍了JVM的内部结构和原理，对于想要深入了解Java的人来说是非常有用的。
5. 《Java并发编程实战》：这本书介绍了Java中多线程编程的相关知识，对于想要开发高性能应用程序的人来说是非常有用的。

希望对你有所帮助~