八、方法及其应用

1 解读方法

方法：是一个具有特定功能的代码块/代码片段的一个集合

注：
方法必须先定义后使用
我们可以使用的方法的来源：
		1.jdk提供的方法或第三方提供的方法
		2.自定义方法

public static void main(String[] args){
	方法体；
}

• public static 方法的访问修饰符
• void 称为方法的返回值类型
• main 称为方法的名称，标识符（命名的时候要符合标识符的命名规则，并且使用小驼峰命名法）
• （String[] args) 称为方法的参数
• { } 方法体，方法的具体功能的实现

2 方法的分类

• 根据返回值类型：有返回值、无返回值
• 根据参数：有参、无参

3 方法的定义

public static 返回值类型  方法名称([参数列表])  { 
		方法体; 
}

• 方法的定义需要明确两点：

1. 方法是否有返回值：
   如果有返回值，则需要明确返回值的类型
   如果没有返回值，则统一为void
2. 方法是否有参：
   如果有参，确定方法首先有几个参数，其次要明确每个参数的类型
   如果没有参数，则什么也不写

• 方法的使用
  定义了方法之后，方法不能自己执行，需要在main方法或其他已经被main调用的方法中手动的进行调用
  方法只有调用才会执行，不调用则不会执行
  在一个类中可以有多个方法
  方法之间的关系是平行的

4 方法的返回值与参数的确定

//没有返回值、无参
public class SumTwo {
    public static void main(String[] args) {
        sum();  //方法的调用
    }
    //需要一个方法，计算两个整数的和并输出
    public static void sum() {
        int a = 2;
        int b = 3;
        System.out.println(a + b);
    }
}

5

//有返回值、无参
public class SumTwo {
    public static void main(String[] args) {
        int s = sum();  //方法的调用
        System.out.println("sum = " + s);
    }
    //需要一个方法，计算两个整数的和并输出
    public static int sum() {
        int a = 2;
        int b = 3;
        return a + b;  //返回两个数的和
    }
}

sum = 5

//有返回值、有参
//有返回值的方法的调用
//一般情况下 我们都需要使用和返回值类型相同类型的变量来接收（保存）
//方法返回的结果好处就是可以在后续的代码中，来达到结果的一个复用

public class SumTwo {
    public static void main(String[] args) {
        int x = 4;
        int y = 5;
        int s = sum(x,y);  //方法的调用
        System.out.println("sum = " + s);
    }
    //需要一个方法，计算两个整数的和并输出
    public static int sum(int a , int b) {
        return a + b;  //返回两个数的和
    }
}

• 通过以上代码 我们就能得出 这样的结论

1. 方法是否有返回值根据方法的功能来具体确定
2. 方法的参数根据方法的功能来具体确定
3. 方法具有通用性是用来解决一类问题的这样的一个代码片段

• 形参和实参的区别和联系

1. 形参变量只有在函数被调用时才会分配内存，调用结束后，立刻释放内存，所以形参变量只有在函数内部有效，不能在函数外部使用。
2. 实参可以是常量、变量、表达式、函数等，无论实参是何种类型的数据，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参，所以应该提前用赋值、输入等办法使实参获得确定值。
3. 实参和形参在数量上、类型上、顺序上必须严格一致，否则会发生“类型不匹配”的错误。当然，如果能够进行自动类型转换，或者进行了强制类型转换，那么实参类型也可以不同于形参类型。
4. 函数调用中发生的数据传递是单向的，只能把实参的值传递给形参，而不能把形参的值反向地传递给实参；换句话说，一旦完成数据的传递，实参和形参就再也没有瓜葛了，所以，在函数调用过程中，形参的值发生改变并不会影响实参。

5 方法的执行的内存分析

• 首先main方法入栈
• 然后sum方法入栈，在栈中开辟出一片区域，赋值a = 5，b = 6，执行sum（a，b）
• 当sum方法执行结束后，该方法出栈
• 之后程序均按照此过程，不同之处是sum1方法中在main方法中定义了变量s

6 方法的重载

public class SumTwo {
    //方法的重载
    //计算两个整数的和
    public static int sum(int a , int b){
        int s = a + b;
        return s;
    }
    //计算三个整数的和
    public static int sum(int a , int b , int c){
        int s = a + b + c;
        return s;
    }
    //计算一个浮点数与两个整数的和
    public static double sum(double a , int b ,int c){
        double s = a + b + c;
        return s;
    }

    public static void main(String[] args) {
        int s = sum(1,2);
        System.out.println(s);
        int s1 = sum(1,2,3);
        System.out.println(s1);
        double s2 = sum(1.5,5,9);
        System.out.println(s2);
    }
}

以上代码中的sum方法之间就构成了方法的重载

• 方法重载特点：

1. 必须是同一个类中的方法
2. 方法名称相同
3. 参数列表不同

• 方法重载的判断依据：

1. 所有的方法的定义是否在同一个类中
2. 方法名称相同
3. 参数列表不同：
   个数不同
   类型不同
   对于多个类型不同的参数，顺序不同也是重载

• 注：方法的返回值不同，不能作为方法重载的判断依据
  对于重载的方法，在调用时，是由jvm自动根据传入的参数的情况来自动调用相匹配的方法

7 参数传递

//交换两个整数的值
public class SumTwo {
    public static void change(int a , int b){
        int temp = a;
        a = b;
        b = temp;
        System.out.println("a = " + a +"  " + "b = " + b);
    }

    public static void main(String[] args) {
        int x1 = 4;
        int x2 = 5;
        change(x1,x2);
    }
}

a = 5  b = 4

交换两个整数的过程

//交换数组中两个元素的位置
public class SumTwo {
    public static void change(int[] arr,int index1,int index2) {
        int temp = arr[index1];
        arr[index1] = arr[index2];
        arr[index2] = temp;
        for (int s : arr) {
            System.out.print(s + " ");
        }
    }
    public static void main(String[] args) {
        int[] arr1 = {1,2,3,4,5,6,7};
        //交换数组arr1中元素下标为2与3的元素
        change(arr1,2,3);
    }
}

1 2 4 3 5 6 7 

• 参数的传递有两种：

1. 值传递：基本类型的数据传递的都是值
2. 引用传递：引用数据类型传递的都是地址

• 值传递和引用传递的区别：

1. 值传递传递的是值的本身，所以对于传递过去的值的修改不会影响原来的值本身
2. 引用传递由于传递的是地址，传递之后的两个引用指向的是同一个地址 ，所以任何的操作对引用的地址内容的修改，都将影响到地址中的内容
   

8 方法的应用（数组最大值）

需求：设计一个方法用于获取数组中元素的最大值
思路：
① 定义一个数组，用静态初始化完成数组元素初始化
② 定义一个方法，用来获取数组中的最大值，最值的认知和讲解我们在数组中已经讲解过了
③ 调用获取最大值方法，用变量接收返回结果
④ 把结果输出在控制台

public class SumTwo {
    // 选择排序  当前得实现只能针对一个数组进行排序
    public static void main(String[] args) {
        int[] arr =  {12,34,22,57,41,2,98,4};
        selectSort(arr);
        printArr(arr);
    }
    // 将选择 排序提炼出一个方法  可以对任何数组进行排序
    public  static  int[]  selectSort(int[] arr){
        for(int j = 0 ; j < arr.length -1;j++){
            int min = j; // min来记录当前最小的元素所在的位置
            for (int i = j ; i < arr.length;i++){
                if(arr[i] < arr[min]){
                    min = i;
                }
            }
            swap(arr,min,j);
        }
        return  arr;
    }

    public static void swap(int[] arr ,int  index1,int index2){
        int  temp = arr[index1];
        arr[index1] = arr[index2];
        arr[index2]= temp;
    }

    //数组得遍历
    public static void  printArr(int[] arr){
        // 遍历数组
        for(int x : arr){
            System.out.println(x);
        }
    }
}

2
4
12
22
34
41
57
98

在编写方法的时候注意：
1. 方法之间是平行关系
2. 方法不能嵌套方法
3. 方法只能调用方法
4. 方法可以被多次调用