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

巴特西

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

最新文章

热门文章