Java方法

什么是方法？

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

内容梗概：
　　方法的声明和调用

　　方法的重载

　　　　

 　　　　

1. 无参无返回值的方法

package com.vip.method;

public class MethodDemo {
//    public static void main(String[] args) {
//        //不使用方法输出
//        System.out.println("***************");
//        System.out.println("hello world!");
//        System.out.println("***************");
//    }


    //用方法输出一行星号
    public void printStar(){
        System.out.println("*************");
    }

    public static void main(String[] args) {
        //类的实例化||||创建对象
        MethodDemo myMethod = new MethodDemo();
        myMethod.printStar();    //调用方法
        System.out.println("hello world!");
        myMethod.printStar();    //调用方法
    }
}

2.无参带返回值的方法

package com.vip.method;

public class Recrangle {

    //求矩形面积的方法
    public int area(){
        int length = 10;   //定义长
        int width = 5;    //定义宽
        int getArea = length * width;   //面积
        return getArea;   //返回语句中的变量类型要跟方法定义的值一样
    }


    public static void main(String[] args) {
        Recrangle r = new Recrangle();
        System.out.println("矩形面积为："+r.area());

    }
}

3.带参无返回值的方法

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

package com.vip.method;

public class MaxDemo {

    //求最大值的放大
    public void max(float a,float b){
        float max;
        if(a>b){
            max = a;
        }
        else{
            max = b;
        }
        System.out.println("两个数的最大值为："+ max);
    }

    public static void main(String[] args) {
        MaxDemo md = new MaxDemo();
        md.max(1111,21);   //调用方法并传参
    }
}

4.带参有返回值的方法

　　定义一个求n!（阶乘）的方法，然后再求1！+2！+3！+4！+5！

package com.vip.method;

public class FacDemo {

    //求阶乘的方法
    public int fac(int n){
        int s = 1;
        for(int i=1;i<=n;i++){
            s = s*i;
        }
        return s;
    }

    public static void main(String[] args) {
        FacDemo fc = new FacDemo();

        int sum = 0;
        //求5以内的整数阶乘之和
        for(int i=1;i<=5;i++){
            int fac = fc.fac(i);   //调用方法
            sum = sum+fac;
        }
        System.out.println(sum);
    }
}

5. 数组作为方法参数

package com.vip.method;

public class ArrayMethod {
    //打印输出数组元素的值
    public void printArry(int[] arr){
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        int[] arr = {10,2,30,4,50,6};
        ArrayMethod am = new ArrayMethod();
        am.printArry(arr);
    }
}

package com.vip.method;

import java.util.Scanner;

public class ArrayMethod2 {

    //查找数组元素值的方法
    public boolean search(int n, int[] arr){
        boolean flag = false;
        for(int i=0;i<arr.length;i++){
            if(n == arr[i]){
                flag = true;
//                System.out.println("找到了");
                break;
            }
        }
        return flag;
    }

    public static void main(String[] args) {
        int[] arr = {11,22,33,44,55,66};
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入要查找的数据：");
        int n = sc.nextInt();

        ArrayMethod2 am2 = new ArrayMethod2();
        boolean flag = am2.search(n,arr);
        if(flag){
            System.out.println("找到了");
        }
        else{
            System.out.println("未找到");
        }
    }
}

6. 方法重载

什么是方法重载：

　　方法名相同，参数列表不同（当调用方法时给与不同传参，会自行调用相应的重载方法）

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

package com.vip.method;

public class MathDemo {
    //求两个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) {
        MathDemo md = new MathDemo();
        int m=5,n=10;
        int[] arr = {1,3,5,7,9,11};
        System.out.println("int类型和："+md.plus(m,n));
        System.out.println("数组元素累加和："+ md.plus(arr));
        System.out.println("double类型和："+ md.plus(m,1.1));
    }
}

 7. 方法传值

　　基本数据类型传值，在主方法中调用，值不会影响

　　引用数据类型（对象和数组都属于引用数据类型）传值，在主方法中调用，值会受影响

不受影响的基本数据类型举例

package com.vip.method;

public class ExchangeDemo {
    //交换方法
    public void swap(int a,int b){
        int temp;
        System.out.println("交换前：a="+a+",b="+b);
        temp = a;
        a = b;
        b = temp;
        System.out.println("交换后：a="+a+",b="+b);
    }

    public static void main(String[] args) {
        int m=4,n=5;
        ExchangeDemo ed = new ExchangeDemo();
        System.out.println("主方法交换前：m="+m+",n="+n);
        ed.swap(m,n);
        System.out.println("主方法交换前：m="+m+",n="+n);
    }
}

运行结果是：

主方法===方法调用前数组a1的元素为：
1 2 3 4 5 
数组a的元素为：
1 2 3 12 5 
主方法==方法调用后数组a1的元素为：
1 2 3 12 5 
Process finished with exit code 0

受影响的引用数据类型举例（数组）

package com.vip.method;

public class ArrayDemo {
    //定义一个用于修改某个数组元素值的放大
    public void updateArray(int[] a){
        a[3] = 12;
        System.out.println("数组a的元素为：");
        for(int n:a){
            System.out.print(n+ " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        ArrayDemo ad = new ArrayDemo();
        int[] a1 = {1,2,3,4,5};
        System.out.println("主方法===方法调用前数组a1的元素为：");
        for(int n:a1){System.out.print(n +  " ");}
        System.out.println();
        ad.updateArray(a1);
        System.out.println("主方法==方法调用后数组a1的元素为：");
        for(int n:a1){System.out.print(n +  " ");}

    }
}

运行结果为：

主方法===方法调用前数组a1的元素为：
1 2 3 4 5 
数组a的元素为：
1 2 3 12 5 
主方法==方法调用后数组a1的元素为：
1 2 3 12 5 
Process finished with exit code 0

8. 可变参数列表（传参的数量不确定，可以发生变化）

　　一个参数列表中只能存在一个可变参数列表

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

　　注意：数组可以作为可变参数的传值，当定义的方法参数为可变参数时，可以直接传入数组调用

　　　　反之可变参数不能作为数组的传值，当定义的方法参数为数组时，不可以直接传入可变参数调用

package com.vip.method;

public class ArgsDemo1 {

    //查找
    // 如果参数列表中有两个以上参数，可变参数一定是在最后的！
    public void search(int n,int... a){
        boolean flag = false;
        for(int a1:a){
            if(a1==n){
                flag = true;
                break;
            }
        }
        if(flag){
            System.out.println("找到了"+n);
        }
        else{
            System.out.println("没找到"+n);
        }
    }

    public static void main(String[] args) {
        ArgsDemo1 ad1 = new ArgsDemo1();
        ad1.search(3,1,2,3,4,5);
        int[] b = {1,2,3,4,5,6};
        ad1.search(4,b);   //数组可以作为可变参数列表的传参

    }

}

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

package com.vip.method;

/**
 * 文档注释(可以生成帮助文档)
 * 关于可变参数列表的重载问题
 * @author xxxxxxx
 * @version 1.0
 * 
 */

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

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

    public static void main(String[] args) {
        ArgsDemo3 ad3 = new ArgsDemo3();
        System.out.println(ad3.plus(1,2));   //可变参数列表所在的方法是最后被访问的，只要有其他方法，就优先调用其他的
    }
}