Java中的方法定义与调用

1.方法：
将具有独立功能的代码块组织成为一个整体，使其成为具有特殊功能的代码集。

2.方法必须先创建才可以使用，该过程称为方法定义。

方法必须先定义后调用，否则程序会报错。

3.方法创建后并不是直接运行的，需要手动使用后才可执行，该过程称为方法调用。

4.方法定义

1）不带参数的方法定义格式：

public static void 方法名(){
//方法体，根据实际需求编写的代码块
}

2）带参数的方法定义格式：

public static void 方法名(参数1,参数2,....){//参数的一般格式：数据类型 变量名
//方法体
}

方法定义时，参数中的 数据类型 和变量名 都不可以省略，缺少其中任意一个，程序将报错。多个参数之间用逗号进行分割。

5.方法调用
1）不带参数的方法调用格式：

方法名();

2）带参数的方法调用格式：

方法名(参数);//参数为变量名或常量值，多个参数之间用逗号分割

方法调用要在main()方法中调用，因为这是程序的入口。

当方法调用出现以后，会进入到相应的方法中，程序从上到下开始执行。

方法调用时的参数的数量与类型，必须与方法 定义中的设置相匹配，否则程序报错。

6.形参：方法定义中的参数，等同于变量定义的格式：数据类型 变量名;。

7.实参：方法调用中的参数，等同于直接使用变量或常量。

8.练习：输入一个数，判断它是否为偶数

import java.util.Scanner;

public class Demo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int x = sc.nextInt();
        isEvenNumber(x);
    }
        public static void isEvenNumber(int x){

            if (x%2==0)
                System.out.println(x+"是偶数");
            else
                System.out.println(x+"不是偶数");
        }

}

9.练习：输入两个数，输出其中的最大值

import java.util.Scanner;

public class Test {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int x = sc.nextInt();
        int y = sc.nextInt();
        isMax(x,y);

    }
    public static void isMax(int x,int y){
        int max;
        max = x>y?x:y;
        System.out.println("两个数中的最大值为："+max);

    }
}

10.带返回值方法的定义：

//格式
public static 数据类型 方法名(参数){
return 数据;//return后面的返回值与方法定义上的数据类型要匹配
}

11.带返回值方法的调用：

//格式1：
方法名(参数);//参数为常量或变量

//格式2：
数据类型 变量名 = 方法名(参数);

方法的返回值通常使用变量进行接收。

方法调用时：
Ⅰ、void类型的方法，直接调用即可。
Ⅱ、非void类型的方法，一般用变量接收调用。

12.方法是平阶关系，不能嵌套定义。

13.void 表示无返回值，可以省略 return ，也可以单独书写 return ，后面不加任何数据。

14.方法定义的通用格式：

public static 返回值类型(参数){//明确返回值类型，如果方法操作完毕之后有数据返回，就写对应的数据类型。如果没有，就写void。还要明确参数的类型和数量。
方法体;
return 数据;
}
/* public static 是修饰符。

返回值类型：方法操作完毕之后，返回的数据的类型。

如果方法操作完毕没有数据返回，返回值类型写void，而且方法体中一般不写return。

方法名：调用方法时使用的标识。

参数：由数据类型和变量名组成，多个参数之间用逗号隔开。

方法体：完成功能的代码块。

return ：如果方法操作完毕有数据返回，用于把数据返回给调用者。*/

15.方法重载：同一个类中定义的多个方法之间的关系，满足一定条件的多个方法相互构成重载。

条件：
Ⅰ、多个方法在同一个类中。
Ⅱ、多个方法具有相同的方法名。
Ⅲ、多个方法的参数不相同（数据类型不同或数量不同）。

16.方法重载的特点：

1）重载仅针对方法的定义而言，与方法的调用无关。

2）重载仅针对同一个类中方法的名称与参数进行识别，与返回值无关。

不能够通过返回值来判定两个方法是否相互构成重载。

在调用的时候，JVM会通过参数的不同来区分同名的方法。

17.练习：使用方法重载的思想，设计比较两个整数是否具有相同的方法，兼容全整数类型（byte ，short ，int ，long）。

public class Compare {
    public static void main(String[] args){
    	System .out.println(compare(10,20));
        System .out.println(compare((byte)10,(byte)20);
        System .out.println(compare((short)10,(short)20);
        System .out.println(compare(10L,20L);
    }
    public static boolean compare(int a,int b){
        System .out.println("int");
        return a==b;
    }
    public static boolean compare(long a,long b){
        System .out.println("long");
        return a==b;
    }
    public static boolean compare(byte a,byte b){
        System .out.println("byte");
        return a==b;
    }
    public static boolean compare(short a,short b){
        System .out.println("short");
        return a==b;
    }

}

Ⅰ、如果只在方法调用时输入整数作为参数，可以看出仅仅只调用了一个方法：
public static boolean compare(int a,int b){ System .out.println("int"); return a==b;
因为 在Java中，整数默认是int类型。

Ⅱ、 要想调用其他类型的方法，需要在方法调用时的参数对其进行数据的强制转换。
Ⅲ、转换为long类型的时候，只需要在整数后面加上L。

18.方法的参数传递：

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

2）练习：

public class Test1 {
    public static void main(String[] args){
        int n=1;
        System.out.println("调用前："+n);
		change(n);
        System.out.println("调用后："+n);
    }
    public static int change(int n){
        n=2;
        return n;
    }
    /*程序的执行流程：
    Ⅰ、程序一开始会把main()方法加载到栈内存。此时在main()方法中int n =1; 
    Ⅱ、然后输出main()方法中n的值为1，所以在控制台首次输出的n的值为1。
    Ⅲ、然后调用了change()方法，这个方法会被加载到栈内存，
    Ⅳ、在运行change()方法的时候，会在栈内存中输入形参 int n;而且，n的初始值是由main()方法中的实参给的，所以此时的n的初值为1。
    Ⅴ、进入了change方法之后，修改n的值为2。
    Ⅵ、修改完毕之后，change()方法中n的值为2，但是main()方法中n的值仍然为1。
    Ⅶ、接着往下执行，change()方法调用完毕，从栈内存消失。
    Ⅷ、回到main()方法，再次输出n。
    Ⅸ、继续往下执行，当main()方法执行完毕之后，也会从栈内存消失。*/

}

19.引用类型的方法参数传递：

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

2）练习：

public class Test1 {
    public static void main(String[] args){
        int[] arr={1,2,3};
        System.out.println("调用前："+arr[1]);

        System.out.println("调用后："+change(arr));
    }
    public static int change(int[] arr){
        arr[1]=6;
        return arr[1];
    }
}
/*程序的执行流程：
Ⅰ、程序的开始从main()方法开始，
Ⅱ、进入main()方法之后，定义了一个整型的数组，并对其进行了初始化处理。
Ⅲ、此时栈内存中存放的是：方法main()和int[] arr，而该数组的元素值和对应的索引会存放在堆内存中。还会把堆内存中的地址值赋值给栈内存的arr。
Ⅳ、继续往下执行，在控制台输出arr数组索引下标为1的值。
Ⅴ、然后调用change()方法，加载到栈内存中，形参int[] arr也会被加载到栈内存中。此时的形参必须是引用类型，而数组属于引用类型。
Ⅵ、接着往下执行，执行完change()方法之后，change()方法会在栈内存中消失。
Ⅶ、再回到main()方法中，输出arr[1]的值，此时，该值已经被修改，所以在控制台输出的是2。
Ⅷ、执行完main()方法，main()方法也会在栈内存中消失。
*/