Java基础（六）方法

什么是方法

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

通过把这些有序代码封装成方法，我们就可以很方便地通过方法的名字，在其他地方直接调用，而不需要写重复的代码，减少了代码冗余。

方法声明

       语法格式：

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

              方法体

       }

       例子：

    public static void main(String[] args) {

        System.out.println("Hello, world!");

    }

 

方法分类

根据方法是否带参数、是否返回值，可分为四类：

      - 无参无返回值方法

      - 无参带返回值方法

      - 带参无返回值方法

      - 带参带返回值方法

 

无参无返回值方法

无参无返回值方法是指方法没有返回值，返回类型使用void关键字，并且参数列表为空。

public class MethodDemo1 {

    //方法功能：打印星号

    public void printStar(){

        System.out.println("*******************************");

    }


    public static void main(String[] args) {

        MethodDemo1 methodDemo1 = new MethodDemo1();
        //方法调用
        methodDemo1.printStar();

        System.out.println("欢迎来到Java的世界");

        //方法调用
        methodDemo1.printStar();

    }

}

 

无参带返回值方法

无参带返回值方法是指方法有返回值，参数列表为空。

public class MethodDemo2 {

    //方法功能：计算正方形面积

    public int area() {

        return 4*4;

    }


    public static void main(String[] args) {

        MethodDemo2 methodDemo2 = new MethodDemo2();
        //方法调用
        int area = methodDemo2.area();

        System.out.println("边长为4的正方形的面积为：" + area);

    }

}

 

带参无返回值方法

带参无返回值方法是指方法没有返回值，返回类型使用void关键字，至少有一个参数。

public class MethodDemo3 {

    //方法功能：获取两个数字的最大值

    public void max(int a, int b) {

        int max = a > b ? a : b;

        System.out.println("最大值为："+ max);

    }

    public static void main(String[] args) {

        int a = 5;

        int b = 6;

        MethodDemo3 methodDemo3 = new MethodDemo3();
        //方法调用
        methodDemo3.max(a, b);

    }

}

 

带参带返回值方法

带参带返回值方法是指方法至少有一个参数，且有返回值。

public class MethodDemo4 {

    //方法功能：求阶乘
    public int fac(int n) {
        int res = 1;

        for (int i = 1; i<=n; i++) {
            res *= i;
        }

        return res;
    }


    //方法不能嵌套定义
    public static void main(String[] args) {
        int sum = 0;
        MethodDemo4 methodDemo4 = new MethodDemo4();

        for(int i=1; i <= 5; i++) {
            //方法调用
            sum += methodDemo4.fac(i);
        }

        System.out.println("1!+2!+3!+4!+5!="+sum);

    }
}

 

参数列表

关于方法的参数列表中的参数，参数的数据类型可以是普通数据类型，如Integer、Float、String等，也可以使用数组、HashMap等。参数列表的长度可以是固定的，也可以是变化的。

数组作为方法参数

public class MethodDemo5 {
    //打印输出数组元素值的方法
    public void printArr(int[] arr) {
        for(int i : arr) {
            System.out.print(i + "  ");
        }

        System.out.println();

    }

    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6};

        MethodDemo5 methodDemo5 = new MethodDemo5();

        methodDemo5.printArr(arr);
    }

}

 

方法重载

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

参数的传递问题

       1）基本类型作为方法参数的传值问题

      方法中对参数的修改，不会对主方法中传来的参数产生影响（基本数据类型传值）。

public class MethodDemo6 {
    //交换
    public void swap(int a, int b) {
        int tmp;

        System.out.println("交换前：a="+a+",b="+b);

        tmp = a;
        a = b;
        b = tmp;

        System.out.println("交换后：a="+a+",b="+b);

    }


    public static void main(String[] args) {
        int m=4,n=8;
        MethodDemo6 methodDemo6 = new MethodDemo6();

        System.out.println("交换前：m="+m+",n="+n);
        methodDemo6.swap(m, n);
        System.out.println("交换后：m="+m+",n="+n);
    }
}


/**

交换前：m=4,n=8

交换前：a=4,b=8

交换后：a=8,b=4

交换后：m=4,n=8

*/

 

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

      方法中对数组的改变，会影响主方法中传来的数组（引用数据类型传值）。

public class MethodDemo7 {
    //定义一个用于修改某个数组第一个元素值的方法
    public void updateArr(int[] arr) {
        System.out.println("修改前数组的值为：");

        for(int i : arr) {

            System.out.print(i+ "  ");

        }

        System.out.println();
        arr[0] = 100;
        System.out.println("修改后数组的值为：");

        for(int i : arr) {

            System.out.print(i+ "  ");

        }

        System.out.println();

    }

    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        MethodDemo7 methodDemo7 = new MethodDemo7();

        methodDemo7.updateArr(arr);
        System.out.println("main方法中修改后数组的值为：");

        for(int i : arr) {
            System.out.print(i+ "  ");
        }
    }
}

/**
修改前数组的值为：
1  2  3  4  5  
修改后数组的值为：
100  2  3  4  5  
main方法中修改后数组的值为：
100  2  3  4  5  
*/

 

可变参数列表

格式：

public void sum(int... n)  {      }

public class ArgsDemo {
    //求和
    public void sum(int... n) {
        int sum = 0;

        for(int i : n) {
            sum += i;
        }

        System.out.print("可变参数列表求和："+sum);

    }

    public static void main(String[] args) {
        ArgsDemo argsDemo = new ArgsDemo();
        argsDemo.sum(1,2);
        argsDemo.sum(1,2,3,4);
        argsDemo.sum(1,2,3,4,5);
    }
}

注意：

1、参数列表中如果有两个以上的参数，可变参数一定是在最后的；

2、一个方法中只能有一个可变参数；

3、 可以将数组传递给可变参数列表；

4、数组作为方法参数时，不能将多个值传递给数组。

public class ArgsDemo1 {
    //查找
    public void search(int n, int... a) {
        boolean flag = false;

        for(int i: a){
            if (i == n) {
                flag = true;
                break;
            }
        }

        if (flag) {
            System.out.println("找到了！"+n);
        } else {
            System.out.println("没找到了！"+n);
        }
    }

    //在方法定义中，会认为当前的两个search方法重复定义，而不是重载
    /*    public void search(int n, int[] a) {
 

    }*/


    public static void main(String[] args) {
        ArgsDemo1 argsDemo1 = new ArgsDemo1();
        argsDemo1.search(1, 1,2,3,4,5);
        argsDemo1.search(6, 1,2,3);
        System.out.println("====================");
        int[] a = {1,2,3,4,5,6,7};
        argsDemo1.search(1,a);
    }
}

/**
找到了！1
没找到了！6
====================
找到了！1
*/

 

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

在重载方法中，可变参数列表所在的方法是最后被选中的。

public class ArgsDemo2 {
    public int plus(int a, int b) {
        System.out.println("不带可变参数的方法被调用了！");
        return a+b;
    }

    public int plus(int... params) {
        System.out.println("带可变参数的方法被调用了！");
        int sum = 0;
        for(int i: params) {
            sum +=i;
        }

        return sum;

    }

    public static void main(String[] args) {
        ArgsDemo2 argsDemo2 = new ArgsDemo2();
        argsDemo2.plus(1,2);  // 输出  不带可变参数的方法被调用了！  
    }
}