JAVA 方法（四）

方法（四）

方法：封装某种功能，提高代码的复用性和可维护性，方法是程序中最小的执行单元。
在面向过程中，称方法为函数；在面向对象中，称为方法。
方法定义:将一些代码打包在一起，该过程为方法定义。
方法调用:方法定义后不是直接运行的，需要手动调用才能执行，该过程名为方法调用。
平时用的main也是一个方法，main方法可以被jvm识别。
格式：

权限修饰符 其他修饰符 返回值类型 方法名(参数列表){
    方法体;
    return 返回值;
}

返回值类型

void表无返回值，有返回值则使用数据类型（基本数据类型+引用数据类型）。
return关键字：

• 方法无返回值：return可以省略不写，如果要写return，后面不能跟具体数据,表示结束方法。
• 方法有返回值：必须要写return，表结束方法和返回结果

无返回值的例子：

public class Test{
    public static void p(){
        System.out.println("方法");
    }
    public static void main(String[] args){//void表示无返回值
        //第一次调用方法
        p();
        //第二次调用方法
        p();
    }
}
/*
方法
方法
*/

有返回值的例子：

//调用方法，返回1-10的总和
public class Test{
    public static int s(){//返回值为整型
        int sum=0;
        for(int i=1;i<=10;i++){
            sum+=i;
        }
        return sum;
    }
    public static void main(String[] args){
        //直接打印
        System.out.println(s());
        //也可以将方法返回值用整型变量接收
        //例如:
        int i=s();
        System.out.println(i);
    }
}
/*
55
55
*/

参数列表

参数：

• 实际参数：实际参加运算的值。基本数据类型是值，引用数据类型是地址值。
• 形式参数：定义方法时，参数列表的参数

例如：

//调用方法计算两个值的和，并返回
public class Test{
    //x，y为形参,实际调用方时传入的值为方法的实参
    public static int sum(int x,int y){
        return x+y;
    }
    public static void main(String[] args){
        int s1=sum(10,30);
        System.out.println("传入的两个数值和为:"+s1);
        int s2=sum(30,40);
        System.out.println("传入的两个数值和为:"+s2);
    }

}
/*
传入的两个数值和为:40
传入的两个数值和为:70
*/

方法的调用

调用格式:
方法名(实参列表);
实参列表的注意事项：实参列表的参数个数，类型，顺序需与形参完全相同。
例:

public class Test{
    public static int s1(int x,int y){
        return x+y;
    }
    public static String s2(int x,String s){
        return x+s;
    }
    public static void main(String[] args){
        System.out.println(s1(10,20));//调用s1
        System.out.println(s2(10,"ljsblog"));//调用s2
    }
}
/*
30
10ljsblog
*/

方法的重载

定义：同一个类中出现多个方法名相同，参数列表不同的多个方法，这种现象称为方法重载（overloading）
参数列表:

• 参数个数不同
• 参数类型不同
• 不同类型的参数顺序不同（不建议）

注：方法的重载与访问权限修饰符和返回值类型无关。

public class Test {
    public static int add(int a) {
        return a;
    }

    //参数个数不同
    public static int add(int a, int b) {
        return a + b;
    }

    //参数类型不同
    public static int add(double a, int b) {
        return (int) a + b;
    }
    //不同类型参数顺序不同

    public static int add(int a, double b) {
        return a + (int) b;
    }

    public static void main(String[] args) {
        System.out.println(add(10));//调用add(int a)
        System.out.println(add(10, 20));//调用add(int a,int b)
        System.out.println(add(20.5, 30));//调用add(double a,int b)
        System.out.println(add(30, 15.5));//调用add(int a,double b)
    }
}
/*
10
30
50
45
*/

方法的递归

方法调用自身称为递归，使用递归时要设置终止条件。
递归条件：存在限制条件，当满足这个限制条件时，递归不再继续，每次递归调用后越来越接近这个限制条件。
例:

import java.util.Scanner;
//输入一个数，计算其阶乘
public class Test{
    public static int f(int num){
        if(num==1){
            return 1;
        }
        return num*f(num-1);
    }
    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        int n=scanner.nextInt();
        System.out.println(n+"的阶乘为"+f(n));
    }
}
/*
5
5的阶乘为120
*/

方法范例

求数组最大值

public class Test{
    public static void main(String[] args){
        int[] arr={45,47,57,16,44,78};
        int max=getMax(arr);
        System.out.println("最大值为"+max);
    }
    public static int getMax(int[] arr){
        int max=arr[0];
        for(int i=1;i<arr.length;i++){
            if(n<arr[i]){
                n=arr[i];
            }
        }
        return max;
    }
}

判断是否存在

//定义一个方法判断数组中某个数是否存在
public class Test{
    public static void main(String[] args){
        int[] arr={45,47,57,16,44,78};
        boolean flag=f(arr,57);
        if(flag==true){
            System.out.println("存在");
        }else{
            System.out.println("不存在");
        }
    }
    public static boolean f(int[] arr,int num){
        for(int i=0;i<arr.length;i++){
            if(arr[i]==num){
                return true;
            }
        }
        return false;
    }
}
/*
存在
*/

拷贝数组

//将数组下标from到to(不包括to)的数据拷贝到arr2，并返回打印
public class Test{
    public static void main(String[] args){
        int[] arr1={1,2,3,4,5,6,7,8,9,10};
        int[] arr2=copy(arr1,2,5);
        for(int i=0;i<arr2.length;i++){
            System.out.println(arr2[i]);
        }
    }
    public static int[] copy(int[] arr1,int from,int to){
        int[] arr2=new int[to-from];
        for(int i=from,j=0;i<to;i++,j++){
            arr2[j]=arr1[i];
        }
        return arr2;
    }
}
/*
3
4
5
*/

方法的内存

方法被调用后就会进栈执行，先进后出。

• 基本数据类型
  • 数据值存储在自己的空间中，赋值给其他变量，赋的真实的值。
  • 方法传递基本数据类型时，传递的是真实的数据，形参改变不影响实际参数的值
• 引用数据类型
  • 数据值存储在其他的空间中，自己空间存储的是地址值，赋值给其他变量，赋的是地址值
  • 方法传递引用数据类型时，传递的是地址值，形参改变，影响实际参数的值

方法没有被调用时，在方法区中的字节码文件中存放。
方法被调用时，需要进入到栈内存中运行。