初识方法

Java中的方法类似于c语言中的函数

观察下面代码，体会方法的好处。

//求两个数的最大值
public static int maxTwoNum(int a,int b) {
    return a>b ? a : b;
}
//求三个数的最大值
public static int maxThreeNum(int a,int b,int c) {
    int max=maxTwoNum(a,b);
    return maxTwoNum(max,c);
}
public static void main(String[] args) {
    int a=10,b=23,c=4;
    System.out.println(maxThreeNum(a,b,c));

灵活使用方法，可以减少重复代码，使代码更简单。

实参、形参的关系

Java当中只有按值传递

分析如下代码：交换两个整型变量

public static void swap(int x,int y){
    int tmp=x;
    x=y;
    y=tmp;
}
public static void main5(String[] args) {
    //交换两个整型变量的错误演示
    int a=10;
    int b=20;
    swap(a,b);
    System.out.println(a);
    System.out.println(b);
}

输出结果为10 20，没有完成两数的交换。对于基础类型来说, 形参相当于实参的拷贝. 即 传值调用

public static void swap1(int[] arr){
    int tmp=arr[0];
    arr[0]=arr[1];
    arr[1]=tmp;
}
public static void main(String[] args) {
    //交换两个整数的正确方法
    int[] arr={10,20};
    swap1(arr);
    System.out.println(Arrays.toString(arr));
}

解决方案：传引用类型参数，如数组。

练习：求n个阶乘之和

public static int add(int n) {
    int j=1;
    int sum=0;
    for(j=1;j<=n;j++){
        sum += factor(j);
    }
    return sum;
}
public static int factor(int j){
    int i=1;
    int rst=1;
    for(i=1;i<=j;i++){
        rst *= i;
    }
    return rst;
}
public static void main(String[] args) {
    Scanner scan = new Scanner(System.in);
    int num=scan.nextInt();
    System.out.println(add(num));
}

方法的重载（overload）：

同一个方法名字, 提供不同版本的实现, 称为方法重载

方法名相同
返回值不做要求
参数列表不同（参数个数或参数类型不同）
同一个类当中

public static int sum(int a,int b) {
    return a+b;
}
public static double sum(double a,double b) {
    return a+b;
}
public static void main(String[] args) {
    System.out.println(sum(4,6));
}

面试题：重载和重写的区别

方法的递归

一个方法在执行过程中调用自身, 就称为 “递归”。

递归把大问题化解成小问题，求解递归问题，要找到终止条件和递归公式。

求n的阶乘

public static int factor(int n) {
    if(n==1){
        return 1;
    }else {
        return n * factor(n - 1);
    }
}
public static void main(String[] args) {
    System.out.println(factor(4));
}

求n个阶乘之和

public static int factor(int i){
    if(i==1){
        return 1;
    }else{
        return i*factor(i-1);
    }
}
public static void main(String[] args) {
    int sum=0;
    Scanner scan = new Scanner(System.in);
    int num=scan.nextInt();
    for (int i = 1; i < num; i++) {
        sum+= factor(i);
    }
    System.out.println(sum);
}

按顺序打印一个数字的每一位(例如 1234 打印出 1 2 3 4)

public static void func(int n) {
    if(n>9){
        func(n/10);
    }
    System.out.print(n%10+" ");
}
public static void main(String[] args) {
    func(123);
}

递归求 1 + 2 + 3 + … + 10

public static int sum(int n) {
    if (n==1) {
        return 1;
    } else {
        return n+sum(n-1);
    }
}
public static void main(String[] args) {
    System.out.println(sum(10));
}

写一个递归方法，输入一个非负整数，返回组成它的数字之和.

例如，输入 1729, 则应该返回1+7+2+9，它的和是19

public static int func(int n) {
    if(n>9){
        return n%10+func(n/10);
    }
    return n;
}
public static void main(String[] args) {
    System.out.println(func(5211));
}

求斐波那契数列的第N项：

public static int fib(int n) {
 if (n == 1 || n == 2) {
 return 1;
 }
 return fib(n - 1) + fib(n - 2);
}

不建议用递归实现斐波那契数列，建议用循环。

public static int func(int n) {
    int n1=1;
    int n2=1;
    int n3=1;
    for(int i=3;i<=n;i++) {
        n3=n1+n2;
        n1=n2;
        n2=n3;
    }
    return n3;
}
public static void main(String[] args) {
    System.out.println(func(1));
}