Java基础笔记（十二）——方法

方法：实现一个功能。

方法声明：

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

　　//方法体

}

访问修饰符：public、private、protect、default

返回类型：void——无返回值         任何数据类型：基本数据类型、String类

0,...,n个参数   （类型  名）

方法的定义有四种类型：

无参无返回值     void  方法名(){ }

无参带返回值     如：Scanner类提供的next()方法，返回值是String类型     public int area(){ return int 型值}

带参带返回值     public void max(float a,float b){ }

带参带返回值     public int fac(int n){ }

定义的方法，在类的内部，与主方法并列，主方法是程序的入口，主方法若需要调用其它方法，需要创建类的对象，使用对象名.方法名()去调用其它方法。除了主方法的其它方法之间可以直接互相调用，可以不创建对象去调用。  （因为一个类的成员属性和成员方法是属于实例化对象去拥有的。）

方法不能嵌套定义，不能把定义的方法写在主方法里。

数组作为方法参数

输出数组元素的值

public class ArrayMethod {
    public void printArray(int[] arr){   //输出数组元素的值
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]+" ");
        }
        System.out.println();
    }
    public static void main(String[] args){
       int[] arr={1,2,3,4,5};
       ArrayMethod a=new ArrayMethod();
       a.printArray(arr);
    }
}

查找数组元素的值                      ——方法参数为：数组，要查找的元素          ——返回值    boolean类型

import java.util.Scanner;

public class ArraySearch {
    //查找数组元素值的方法
    public boolean search(int n,int[] arr){
        boolean flag=true;  //默认是没找到
        for(int i=0;i<arr.length;i++){
            if(arr[i]==n){
                flag=true;  //找到了
                break;  //提高程序查询效率
            }
        }
        return flag;
    }
    public static void main(String[] args){
        int[] arr1={1,2,3,4,5};
        System.out.println("请输入要查找的数据:");
        Scanner sc=new Scanner(System.in);
        int n1=sc.nextInt();
        ArraySearch as=new ArraySearch();
        boolean flag=as.search(n1,arr1);
        if(flag)
            System.out.println("找到了");
        else
            System.out.println("没找到");
    }
}

方法重载

方法名相同，参数列表不同（个数、类型、顺序），与返回值类型无关。

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){
        int m=5,n=10;
        int[] arr={1,2,3,4,5};
        MathDemo mathDemo=new MathDemo();
        System.out.println("int类型的和:"+mathDemo.plus(m,n));
        System.out.println("double类型的和:"+mathDemo.plus(1.2,3.4));
        System.out.println("数组元素的和:"+mathDemo.plus(arr));
    }
}

参数的传值问题

Java中处理8种基本的数据类型用的是值传递，其它所有类型都用的是引用传递。8种基本数据类型的包装类型都是不可变量。

1.值传递

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);
    }
    public void swapTest(){
        int m=4,n=5;
        System.out.println("交换前:m="+m+"n="+n);
        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

主方法中调用方法必须要通过对象调用，与方法同类下的其它方法，无需创建对象，可直接调用。

2.引用传递（数组作为方法参数）

public class ArrayDemo {
    //定义一个用于修改某个数组元素值的方法
    public void updateArray(int[] a){
        a[3]=15;
        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); //数组传值，a1和a指向了同一块内存空间(即同一数组)形参的改变影响了实参的值
        System.out.println("方法调用后数组a1的元素为:");
        for(int n:a1){
            System.out.print(n+" ");
        }
    }
}

//运行结果
方法调用前数组a1的元素为:
1 2 3 4 5
数组a的元素为:
1 2 3 15 5
方法调用后数组a1的元素为:
1 2 3 15 5 

引用传递：传递的是地址，形参和实参指向同一块存储单元。

值传递：基本类型传递的是值，形参用实参的值初始化了一个临时的存储单元，值虽相同，但存储单元不同，因此形参的改变不影响实参的值。

即：基本数据类型变量传值无影响，引用数据类型（数组、对象）传值有影响。

public class Test {
    public static void changeStringBuffer(StringBuffer ss1,StringBuffer ss2){
        ss1.append("World");
        ss2=ss1;
    }
    public static void main(String[] args){
        Integer a=1;
        Integer b=a;  //(1)
        b++;
        System.out.println(a);
        System.out.println(b);
        StringBuffer s1=new StringBuffer("Hello");
        StringBuffer s2=new StringBuffer("Hello");
        changeStringBuffer(s1,s2);
        System.out.println(s1);
        System.out.println(s2);  //(2)
    }
}

（1）Integer类型是按引用传递，不是值传递，既然是引用传递，为什么b的改变没有带来a的改变？因为Integer是不可变类，创建一个新值为2的Integer赋值给b，b与a已经无关系。

（2）

可变参数列表

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 static void main(String[] args){
        ArgsDemo ad=new ArgsDemo();
        ad.sum(1);
        ad.sum(1,2);
        ad.sum(1,2,3);
    }
}

//运行结果
sum=1
sum=3
sum=6

1.参数列表中如果有两个以上的参数，可变参数一定是在最后的（前面的参数都匹配完了，剩下的都是可变参数类型，如果把可变参数放在前面，无法判断到底应用有几个参数）。

2.一个方法中只能有一个可变参数。

3.可以将数组传递给可变参数列表。但数组作为参数时，是不能将多个值传递给数组的。

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); //找到了!3
        int[] a={1,2,3,4,5};
        ad1.search(3,a);   //找到了!3
    }
    public void search(int n,int[] a){    //报错  

    }
}
//运行结果
找到了!3
找到了!3

上述最后一段代码报错原因：在方法定义中，认为当前的两个search方法重复定义，而不是重载。

数组作为参数时，是不能将多个值传递给数组的。

public void search(int n,int[ ] a){ }

ad1.search(3,1,2,3,4,5);  //报错

4.可变参数列表所在的方法是最后被访问的，只要有其它相关方法，它就不会被执行。

public class ArgsDemo2 {
    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){
        ArgsDemo2 ad=new ArgsDemo2();
        System.out.println("和为:"+ad.plus(1,2));
    }
}

//运行结果
不带可变参数的方法被调用
和为:3