day_09 方法

1. 解读方法

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

方法的注意事项：
	方法必须先定义 后使用；
	我们可以使用的方法的来源：
			（1）JDK提供的方法或者第三方提供的方法
			（2）自定义方法：
	public static void main(String[] args){
	
	}
		public static :方法的访问修饰符
		void ：称为方法的返回值类型
		main：称为方法的名称	标识符（命名的时候需要符合标识符的规则并且使用小驼峰命名法）
		(String[] args)：成为方法的参数
		{}：方法体，方法具体功能的实现代码

2.方法的分类

2.1 根据返回值类型

有返回值，无返回值

2.2 根据参数分类

有参，无参

3. 方法的定义

目前阶段，我们定义方法：
	public static 返回值类型 方法名称 ([参数列表]) {方法体}
方法的定义需要明确两点：
	1. 方法是否有返回值；
		如果有返回值，则需要明确返回值的类型；
		如果没有返回值，则统一为void
	2. 方法是否有参数：
		有参：首先要确定有几个参数，其次要明确知道每个参数的类型；
		无参：什么都不写;
方法的使用：
	当定义了方法之后，方法不能自己执行，需要在main方法或其他已经被main方法调用的方法中手动的进行调用。
	方法只有调用才会执行 不调用则不会被执行
	在一个类中，可以有多个方法
	方法之间的关系是平行的

4. 方法返回值的确定

需求：计算两个整数的和 并 输出

ublic class MethodDemo_01 {
    // 需要一个方法 计算两个整数的和并输出
    public static void sum(){
        int a = 5;
        int b = 3;
        System.out.println(a + b);

    }
    
    // 需求 计算两个整数的和
    public static int sum1(){
        int a = 5;
        int b = 3;
        /*
         * return 表示该方法返回的结果 当方法执行过程中遇到return，
         * 则将return后边的值或者表达式的结果返回给方法的调用者
         * 当return之后，则return语句后变得语句将不再执行
         */
        return a + b;
    }
    public static void main(String[] args) {
        // 无返回值方法的调用
        sum();

        /*
         * 有返回值方法的调用
         * 一般情况下我们都需要使用和返回值类型相同的变量来接受(保存)
         * 方法返回的结果
         * 好处就是可以在后续代码中，达到结果的一个复用
         */
        int s = sum1();
        System.out.println(s);
        // 没有保存返回的结果
        System.out.println(sum1());
        
    }
}

5. 方法参数的确定

public static void sum(int a , int b){
//        int a = 5;
//        int b = 3;
        System.out.println(a + b);
    }

调用

// 此时参数5和6就称为实际参数，简称实参
sum(5,6);   // 无返回值方法的调用

// 需求 计算两个整数的和
    public static int sum1(int a , int b){
//        int a = 5;
//        int b = 3;
        /*
         * return 表示该方法返回的结果 当方法执行过程中遇到return，
         * 则将return后边的值或者表达式的结果返回给方法的调用者
         * 当return之后，则return语句后的语句将不再执行
         */
        return a + b;
    }

调用

int s = sum1(8,9);
System.out.println(s);

 // 求两个整数中的较大者
    public static int getMax(int a ,int b){
//        int a = 8;
//        int b = 10;
        return a > b ? a : b;
    }

调用

int max = getMax(20,50);
System.out.println(max);

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

注意问题：
	1. 对于方法的返回值
		如果方法有返回值，则在方法的实现中，使用关键字return来做方法的返回
			在有返回值的方法中，则return后边跟的是返回的值或者是一个表达式结果
		如果方法没有返回值，则return后可以什么都不写

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

6.方法的执行的内存分析

7.方法的重载

public class MethodDemo_02 {
    // 需求，计算两个整数的和
    public static int sum(int a , int b){
        // return a + b
        int s = a + b;
        return s;
    }

    // 需求 计算三个整数的和
    public static int sum(int a ,int b ,int c) {
        return a + b + c;
    }

    // 计算两个整数和一个浮点数的和
    public static double sum(int a,int b ,double d){
        return a + b + d;
    }

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

    public static void main(String[] args) {
        int s =sum(5,6);
        System.out.println(s);
        int s1 = sum(5,6,7);
        System.out.println(s1);
        double s2 = sum(5,6,5.6);
        System.out.println(s2);
        double s3 = sum(5.6,5,6);
        System.out.println(s3);
    }
}

以上代码中的sum方法之间就构成了方法的重载
	特点：
		1. 必须是同一个类中的方法
		2. 方法名称相同
		3. 参数列表不同
	方法重载的判断依据：
		1. 所有方法的定义是否在一个类中；
		2. 方法名称相同
		3. 参数列表不同：
			个数不同
			类型不同
			对于多个类型不同的参数，顺序不同 也是重载。
	方法的返回值不同，不能作为方法重载的判断依据；
	对于重载的方法，在调用时，由jvm自动根据 传入参数的情况 来自动调用相匹配的方法；

8.参数传递

public class MethodDemo_03 {

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

    /**
     * 交换数组中的两个元素的位置
     * */
    public static void change(int[] arr , int index1 ,int index2){
        int temp = arr[index1];
        arr[index1] = arr[index2];
        arr[index2] = temp;
        for(int i :arr){
            System.out.println(i);
        }
    }

    public static void main(String[] args) {
        int x = 8;
        int y = 9;
        change(x,y);
        System.out.println(x + "=======" + y);

        int[] arr = {3,1,5,7,8,3,2,9};
        change(arr,1,7);
        System.out.println("------------");
        for (int i :arr){
            System.out.println(i);
        }
    }

}

交换两个整数的过程

交换两个元素的过程

参数的传递有两种：
	值传递：对于基本类型的数据，传递的都是值
	引用传递：引用数据类型传递的都是地址
值传递与引用传递的区别：
	值传递：传递的是值的本身，所以对于传递过去的值的修改，不会影响原来的值的本身
	引用传递：由于传递的是地址，传递之后的两个引用指向的是同一个地址，所以任何的操作，对引用的地址内容的修改，都将影响到地址中的内容

数组遍历（应用）

需求：设计一个方法用于数组遍历，要求遍历的结果是在一行上的。
例如：[11, 22, 33, 44, 55]

数组最大值（应用）

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

如何从已实现的方法中提炼除方法：提炼过程 称为 代码的重构。

public class SelectSort {
    // 选择排序  当前得实现只能针对 一个 数组进行排序
    public static void main(String[] args) {
        int[] arr =  {21,35,12,20,65,5,56};
        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);
        }
    }
}

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