Java方法

1.方法的概述

方法是一种语法结构，它可以把一段代码封装成一个功能，以方便重复调用

使用方法的好处：

提高了代码的复用性；

让程序的逻辑更清晰

package com.creat;

public class MethoDomo1 {
    public static void main(String[] args) {
        int c1=sum(10,30);
        System.out.println(c1);
        
    }
    public static int sum(int a,int b)
    {
        int c=a+b;
        return c;
    }
}

2.方法的定义、调用

方法定义的完整格式：

修饰符 返回值类型 方法名(形参列表){

方法体代码(需要执行的功能代码)

return返回值;}

方法的调用格式：

方法必须调用才可以跑起来，调用格式: 方法名(...);

方法的修饰符:暂时都使用public static修饰。

方法申明了具体的返回值类型，内部必须使用return返回对应类型的数据。

形参列表可以有多个，甚至可以没有;如果有多个形参，多个形参必须用“，”隔开，且不能给初始化值。

方法的其他写法：

方法定义时:返回值类型、形参列表可以按照需求进行填写。

修饰符返回值类型方法名(形参列表){

方法体代码(需要执行的功能代码)

return返回值;}

例子

package com.creat;

public class MethoDomo1 {
    public static void main(String[] args) {
        //学会方法的定义其他格式
        print();
        System.out.println("----------------------");
        print();}
        public static void print(){
            for (int i = 0; i < 3; i++) {
                System.out.println("hello world");
            }
        }
    }

注意事项：

（1）如果方法不需要返回结果，返回值类型必须申明成void（无返回值)，此时方法内部不可以使用return返回数据

（2）方法如果没有参数，或者返回值类型申明为void可以称为无参数、无返回值的方法，依次类推。

3.方法使用的常见问题

（1）方法的编写顺序无所谓。

（2）方法与方法之间是平级关系，不能嵌套定义。

（3）方法的返回值类型为void(无返回值)，方法内则不能使用return返回数据，如果方法的返回值类型写了具体类型，方法内部则必须使用return返回对应类型的数据。

（4）return语句下面。不能编写代码。因为永远执行不到,属于无效的代码。

（5）方法不调用就不执行，调用时必须严格匹配方法的参数情况。

（6）有返回值的方法调用时可以选择定义变量接收结果，或者直接输出调用，甚至直接调用;无返回值方法的调用只能直接调用一下。

4.方法案例

定义方法的技巧：

修饰符:public static(暂时固定的)

方法名称:自己取名，有意义，英文小写，驼峰模式。(有意义的名字即可)

计算1-n的和返回：

需求:定义一个方法，方法中计算出1-n的和并返回。

1.根据格式编写方法---->因n不固定，故方法需要声明形参接收;要返回结果，还需申明返回值类型。

2.方法内部使用for循环计算出1-n的和并返回。

package com.creat;
public class MethodAttentionDemo {
    public static void main(String[] args) {
       System.out.println( sum(5) );
        System.out.println("-------------------");
        System.out.println(sum(100));

    }
    public static int sum(int n){
        int sum=0;
        for (int i = 1; i <=n; i++) {
            sum+=i;

        }
        return sum;
    }
}

数组求最值改方法实现：

把找出数组的最大值案例，改造成方法，可以支持返回任意整型数组的最大值数据。

分析：要返回最大值，需要申明返回值类型。

需要接收数组，需要申明形参列表。

package com.creat;
public class Test {
    public static void main(String[] args) {
        int ages[]={23,19,22,78,34};
        int max=getArrayMaxData(ages);
        System.out.println("最大数据是："+max);
    }
    public static int getArrayMaxData(int arr[]){
        //找出数组最大值
        int max=arr[0];
        //遍历数组每个元素 若较大则替换
        for (int i = 1; i <arr.length ; i++) {
            if(arr[i]>max){
                max=arr[i];
            }
        }
        return max;
    }
}

5.方法的调用

方法没有被调用的时候，在方法区中的字节码文件中存放方法；

被调用的时候，需要进入到栈内存中运行。

6.方法的参数传递机制

基本类型的参数传递机制：

Java的参数传递机制:值传递

在传输实参给方法的形参的时候，并不是传输实参变量本身，而是传输实参变量中存储的值，这就是值传递。

注意: 实参:如在方法内部定义的变量。

形参:如在定义方法时，“()”中所声明的参数。

package com.creat;

public class MethodDemo1 {
    public static void main(String[] args) {
        int a=10;
        change(a);
        System.out.println(a);//10

    }
    public static void change(int a){
        System.out.println(a);//10
        a=20;
        System.out.println(a);//20
    }
}

引用类型的参数传递：

package com.creat;

public class MethodDeo2 {
    public static void main(String[] args) {
        int arr[]={10,20,30};
        change(arr);
        System.out.println(arr[1]);//222
    }
    public static void change(int arr[]){
        System.out.println(arr[1]);//20
        arr[1]=222;
        System.out.println(arr[1]);//222
    }
}

7.方法的参数传递案例：

打印整型数组内容：

设计一个方法用于输出任意整型数组的内容，要求输出成如下格式:

“该数组内容为:[11,，22，33，44，55]"

分析：1、定义一个方法，要求该方法能够接收数组，并输出数组内容。---〉需要参数吗?需要返回值类型申明吗

2、定义一个静态初始化的数组，调用该方法，并传入该数组。

package com.creat;

public class Test01 {
    public static void main(String[] args) {
        int ages[] = {10, 20, 30, 40};
        printArray(ages);
        System.out.println("--------------");
        int number[] = {1, 6, 78, 75};
        printArray(number);
        System.out.println("--------------");
        int acc[]={};
        printArray(acc);
    }
    public static void printArray(int arr[]){
        System.out.print("{");
        if(arr!=null&&arr.length>0){
            for (int i = 0; i < arr.length ; i++) {
                //法一
                /*if(i==arr.length-1){
                    System.out.print(arr[i]);
                }else {
                    System.out.print(arr[i]+",");
                }*/
                //法二
                System.out.print(i== arr.length-1?arr[i]:arr[i]+",");
            }
        }
        System.out.println("}");
    }
}

从数组中查询元素的索引：

需求: 设计一个方法可以接收整型数组，和要查询的元素值;最终要返回元素在该数组中的索引，如果数组中不存在该元素则返回-1。

分析：1、定义方法，接收整型数组，查询的元素值，在方法体中完成元素查询的功能。--->是否需要参数、返回值类型?

2、定义数组，调用该方法，并指定要搜索的元素值，得到返回的结果输出。

package com.creat;

public class Test02 {
    public static void main(String[] args) {
        //3.定义数组 调用方法
        int arr[]={11,22,333,66,87,19};
        int index=search(arr,87);
        System.out.println("你查询的索引是："+index);

    }
    //定义一个方法  参数接收数组，要查询数据，返回值 整型
    public static int search(int[]arr,int data){
        //2.开始找出这个数据的索引
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]==data){
                return i;
            }
        }
        return -1;
    }
}

比较两个数组内容是否一样：

如果两个数组的类型，元素个数，元素顺序和内容是一样的我们就认为这2个数组是一模一样的。请使用方法完成:能够判断任意两个整型数组是否一样，并返回true或者false。

分析：1、定义方法，接收2个整型数组，---〉是否需要参数、返回值类型

2、在方法内部完成判断的逻辑，并返回布尔结果。

package com.creat;

public class Test03 {
    public static void main(String[] args) {
        int arr1[]={10,20,40,60};
        int arr2[]={10,20,40,60};
        System.out.println(compare(arr1,arr2));
        System.out.println("-------------------");
        int acc1[]={56,45,76};
        int acc2[]={59,75,30};
        System.out.println(compare(acc1,acc2));
    }
    //1.定义一个方法
    public static boolean compare(int arr1[],int arr2[]){
        //2.判断两个数组内容一样
        if (arr1.length== arr2.length){
            for (int i = 0; i < arr1.length; i++) {
                if (arr1[i]!=arr2[i]){
                    return false;
                }
            }
            return true;//一样的
        }else {
            return false;
        }
    }
}

8.方法重载

同一个类中，出现多个方法名称相同，但是形参列表是不同的，那么这些方法就是重载方法。

好处：对于相似功能的业务场景:可读性好，方法名称相同提示是同一类型的功能，通过形参不同实现功能差异化的选择，这是一种专业的代码设计。

方法重载的识别技巧：只要是同一个类中，方法名称相同、形参列表不同，那么他们就是重载的方法，其他都不管! (如:修饰符，返回值类型都无所谓)

形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。

9.单独使用return关键字

 return; --->可以立即跳出并结束当前方法的执行; return关键字单独使用可以放在任何方法中。