05-方法_博客刘曦若-CSDN博客

本文链接：https://blog.csdn.net/weixin_45161115/article/details/119184123

本文详细介绍了Java中的方法，包括方法的定义、声明、访问修饰符、返回类型以及方法的四种类型：无参无返回值、无参有返回值、有参无返回值和有参有返回值。此外，还讲解了方法的参数传递（值传递）、方法的重载以及可变参数列表的使用。通过实例展示了如何在实际编程中应用这些概念。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

方法简介

什么是方法

所谓方法，就是用来解决一类问题的代码的有序组合，是一个功能模块。

我们列举一些之前我们遇到的一些方法：

（1）main（主方法）

特殊的方法，主方法是程序执行的入口。

（2）对象的方法，例如：Scanner对象

Scanner sc = new Scanner（System.in）;

sc.nextInt(); 接收整型数据，nextInt()就是Scanner对象的方法

sc.next(); 接收字符串数据，next()也是Scanner对象的方法

（3）输出方法

System.out.println();

方法的声明

语法格式：

访问修饰符返回类型方法名（参数列表）{

方法体

}

public static void main(String [ ] args){

System.out.println("Hello,java");

}

访问修饰符：访问修饰符代表了方法的访问权限，有public、protected、private
返回类型：返回类型可以是void或者任何数据类型，void表示无返回值
方法名：方法名的命名规则遵循标识符的命名规则

方法类型

方法根据返回值类型和参数列表分为四类方法

① 无参无返回值

② 无参有返回值

③ 有参无返回值

④ 有参有返回值

无参无返回值方法

例子：打印一串星号完成下面的效果

public class Demo01 {

    //自定义方法
    /**
     * 语法格式：
     *      访问修饰符  返回类型 方法名(参数列表){
     *          方法体
     *      }
     */
    //输出一行星号
    public static void printStarts(){
        System.out.println("*****************************");
    }
    public static void main(String [] args){
        //方式一：不使用我们自定义的方法去完成
        System.out.println("*****************************");
        System.out.println("欢迎来到Java的世界！");
        System.out.println("*****************************");

        System.out.println("------------------------------");
        //方式二：使用自定义的方法完成
        Demo01 d = new Demo01();//创建类对象
        d.printStarts();//通过对象调用方法
        System.out.println("欢迎来到Java的世界！");
        d.printStarts();
        
    }
}

注意：

① 方法定义在类的内部

② 在本类中自定义的方法，如果不想创建对象，可以将方法用static进行修饰成静态方法，然后在主方法中直接使用方法名(); 调用即可。

无参有返回值方法

例子：求长方形的面积

public class Recgantle{
    
    //定义求长方形面积的方法
    /*
        语法格式：
            访问修饰符  返回值类型  方法名(参数列表){
                方法体
            }
    */
    public int area(){
        //定义长和宽
        int length = 10;//定义长方形的长为10
        int width = 5;//定义长方形的宽为5
        int getArea = length*width;//计算面积
        //将结果返回，使用return关键字
        return getArea;//返回值的类型需要和方法定义时返回值类型相同
    }
    
    public static void main(String [] args){
        //创建类对象
        Recgantle rt = new Recgantle();
        int area = rt.area();//调用方法，由于方法具有返回值，因此我们需要定义变量去接收方法调用的结果
        System.out.println("长方形的面积为："+area);
    }
}

带参无返回值方法

例子：定义一个求两个float类型数据最大值的方法，在方法中将最大值打印出来

public class MaxDemo {

    //求两个float类型数据的最大值
    public void max(float a,float b){
        float max = 0;//定义一个变量来存储最大值
        //比较a和b的值
        if(a>b){
            max = a;
        }else{
            max = b;
        }
        System.out.println(a+"和"+b+"的最大值为："+max);
    }
    public static void main(String [ ] args){
        /*
            问题：定义的方法中a和b的值到底是多少？
            a和b的值取决于调用该方法时传入的参数值
            因此，在主方法中调用max方法时需要传入
            两个参数值给参数列表中的a和b进行赋值
        */
        MaxDemo m = new MaxDemo();//创建类对象
        m.max(10.4f, 13.6f);//调用max方法，并给参数列表中的a,b传入参数值
    }
}

带参有返回值方法

例子：定义一个求n!的方法，然后在求1!+2!+3!+4!+5!

public class FacDemo {

    //定义求阶乘的方法
    public int fac(int n){
        int getFac = 1;//保存阶乘
        for(int i=1;i<=n;i++){
            getFac = getFac*i;
        }
        return getFac;//返回某个数的阶乘
    }
    public static void main(String [] args){
        FacDemo fo = new FacDemo();
        int n = 5;//求1——5的阶乘
        int sum = 0;//计算1——5阶乘的累加和
        for(int i=1;i<=n;i++){
            sum=sum+fo.fac(i);
        }
        System.out.println("计算1——5阶乘的累加和："+sum);
    }
}

数组作为方法参数

例子：定义方法，打印输出数组元素的值。

public class MethodDemo{
    //定义方法，数组作为参数，输出数组中的元素
    public void print(int [] array){
        for(int i=0;i<array.length;i++){
            System.out.print(array[i]+"\t");
        }
        System.out.println();
    }
    public static void main(String [] args){
        //定义一个数组
        int [] array = {10,20,30,40,50};
        MethodDemo mo = new MethodDemo();//定义一个类对象
        mo.print(array);//传入数组
    }
}

例子：查找数组的值

import java.util.Scanner;
public class FindNum {

    //定义方法
    public boolean findNum(int [] arr,int n){
        //定义一个boolean类型的变量，存储结果，默认是false表示没找到
        boolean result = false;
        //遍历数组
        for(int i=0;i<arr.length;i++){
            if(arr[i]==n){
                //找到了
                result = true;
            }
        }
        return result;//将结果返回
    }
    public static void main(String [] args){
        //定义一个数组
        int [] arr = {1,2,3,4,5,6,7,8,9,10};
        //声明Scanner对象，从键盘接受数据
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入要查找的数：");
        int n = sc.nextInt();
        //创建类对象
        FindNum fm = new FindNum();
        boolean result = fm.findNum(arr, n);
        //判断结果
        if(result==true){
            System.out.println(n+"在数组中");
        }else{
            System.out.println(n+"不在数组中");
        }
    }
}

注意：

① 由于要查找数组元素中的值，因此方法的参数列表为（数组，要查找的数）

② 结果有两种：找到或者没有找到，因此返回值类型为boolean

方法重载

什么是方法的重载

方法名相同，而参数列表不同。

参数列表不同表现为：

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

判断下列哪些方法是①重载的方法

① public void hello(){}

② public int hello(){}

③ public void hello(String s){}

④ public void hello(int n){}

⑤ public void hello(float f1,float f2){}

⑥ public void hello1(){}

②方法的重载和返回值类型无关，因此②不是方法的重载

③是方法的重载，因为参数列表不同，有一个String类型的参数

④是方法的重载，与①相比参数列表不同；与③相比参数的数据类型不同

⑤是方法的重载，与①相比参数列表不同；与③和④相比参数的数据类型不同且参数的个数不同

⑥不是方法的重载，方法名不一致

例子：定义三个方法，实现int、double和数组类型和的问题

package method_reload;
public class MethodReload{
    
    //两个int类型的累加和
    public int plus(int m,int n){
        return m+n;
    }

    //两个double类型的累加和
    public double plus(double m,double n){
        return m+n;
    }

    //数组类型元素的累加和
    public int plus(int [] arr){
        int sum = 0;
        for(int i=0;i<arr.length;i++){
            sum = sum+arr[i];
        }
        return sum;
    }
    
    public static void main(String [] args){
        int m = 4, n =5;
        int [] arr = {1,2,3,4,5,6,7,8,9,10};
        MethodReload mr = new MethodReload();
        System.out.println("int类型和："+mr.plus(m,n));
        System.out.println("double类型和："+mr.plus(4.6,5.7));
        System.out.println("数组类型和："+mr.plus(arr));
    }
}

方法传值

基本数据类型的传值问题

例子：对两个变量的值进行交换并打印输出

//对两个变量的值进行交换并打印输出
public class ExchangeDemo{

    //交换方法
    public void swap(int a,int b){
        //设置中间变量
        int temp;
        System.out.println("交换前a="+a+",b="+b);
        //交换a和b的值
        temp=a;
        a = b;
        b = temp;
        System.out.println("交换后a="+a+",b="+b);
    }
    public static void main(String [] args){
        //创建类对象
        ExchangeDemo eDemo = new ExchangeDemo();
        //设置两个变量传值
        int m = 4,n=5;
        System.out.println("交换前m="+m+",n="+n);
        eDemo.swap(m, n);
        System.out.println("交换后m="+m+",n="+n);
    }
}

运行结果：

交换前m=4,n=5

交换前a=4,b=5

交换后a=5,b=4

交换后m=4,n=5

为什么程序运行了交换方法后，交换方法中的a和b的值进行了交换，而作为传值参数的m和n的值却没有发生交换，仍然是原来的值?

对象调用swap(int a,int b)方法时，虽然将m和n作为参数传入，但是传递的是m和n的值，并没有将m和n的地址传入，因此，a和b的值通过swap方法进行了交换，而m和n的值没有进行改变。

基本数据类型传值问题图文解释：

数组作为方法参数的传值问题

例子：修改数组其中一个元素的值，并分别展示数组元素修改前的值和数组元素修改后的值

public class ArrayDemo{
    //定义一个修改数组元素值的方法
    public void update(int [] arr){
        arr[3] = 15;
        System.out.println("数组arr的元素修改后：");
        for(int i:arr){
            System.out.print(i+"\t");
        }
        System.out.println();
    }
    public static void main(String [] args){
        int [] a = {1,2,3,4,5};
        System.out.println("调用方法前数组a的元素值为：");
        for(int i:a){
            System.out.print(i+"\t");
        }
        System.out.println();
        //生成类对象
        ArrayDemo ad = new ArrayDemo();
        ad.update(a);
        System.out.println("调用方法后数组a的元素值为：");
        for(int j:a){
            System.out.print(j+"\t");
        }
    }
}

运行结果：

调用方法前数组a的元素值为：

1 2 3 4 5

数组arr的元素修改后：

1 2 3 15 5

调用方法后数组a的元素值为：

1 2 3 15 5

为什么数组传值后和基本数据类型传值的结果不同？

注意：数组是引用数据类型，当数组a进行初始化后，被传入方法参数时，换传递自己的地址，因此数组arr和数组a指向同一块内存区域，所以对数组元素进行操作，两个数组的元素都会更改。

可变参数列表

什么是可变参数列表

语法格式：

例如：public void sum(int... n){...}

例子：自定义两个方法，参数为可变参数列表分别完成求和以及查找元素的功能

public class ArgsDemo {
    //可变参数列表求和
    public void sum(int... n){
        int sum = 0;
        for(int i:n){
            sum=sum+i;
        }
        System.out.println("sum="+sum);
    }

    //查找
    //当参数列表中有多个参数时，可变参数列表必须放在最后
    public void search(int m , int... n){
        boolean flag = false;
        for(int n1:n){
            if(n1==m){
                flag = true;
                break;
            }
        }
        if(flag){
            System.out.println(m+"找到了！");
        }else{
            System.out.println(m+"没找到！");
        }
    }
    public static void main(String [] args){
        //创建ArgsDemo对象
        ArgsDemo ad = new ArgsDemo();
        ad.sum(1);//传入1个值
        ad.sum(1,2);//传入2个值
        ad.sum(1,2,3,4,5);//传入5个值
        /*可变参数列表中可以传一个或多个值，多个值之间用 , 分隔 */

        System.out.println("-----------------------");
        ad.search(3, 1,2,3,4,5);
        int [] a = {1,3,5,7,9};
        ad.search(3, a);//数组也可以为可变参数列表传值
    }
}

注意：

可变参数列表可以传入1个或多个值，每个元素值之间用，分隔
当参数列表有多个参数时，可变参数列表必须放置最后一位，因为可变参数列表如果放在前面，那么其他参数都会被认为是可变参数，程序将会报错
数组可以为可变参数列表传值，但是可变参数列表无法为数组传值
方法中最多只能有一个可变参数列表

可变参数列表作为方法参数的重载问题

例子：定义两个求和方法，一个是不带可变参数列表的方法，一个是带可变参数列表的方法，运行两个方法查看结果

public class ArgsDemo {
    
    //定义一个不带参数列表的求和方法
    public void sum(int a,int b){
        System.out.println("不带可变参数列表的方法被调用了！");
        System.out.println("和为："+(a+b));
    }

    //定义一个带参数列表的求和方法
    public void sum(int... n){
        int sum = 0;
        for(int i:n){
            sum+=i;
        }
        System.out.println("带可变参数列表的方法被调用了！");
        System.out.println("和为："+sum);
    }
    //定义
    public static void main(String [] args){
        //创建ArgsDemo对象
        ArgsDemo ad = new ArgsDemo();
       //调用sum方法
       ad.sum(1,2);
    }
}

注意：当进行方法重载，可变参数列表作为方法参数时，在调用方法时，可变参数列表所在方法的调用顺序是最后的。