初识方法
Java中的方法类似于c语言中的函数
观察下面代码，体会方法的好处。
1
2
3
4
5
6
7
8
9
10
11
12
|
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当中只有按值传递
分析如下代码：交换两个整型变量
1
2
3
4
5
6
7
8
9
10
11
12
13
| 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，没有完成两数的交换。对于基础类型来说, 形参相当于实参的拷贝. 即 传值调用
1
2
3
4
5
6
7
8
9
10
11
| 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个阶乘之和
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
| 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）：
同一个方法名字, 提供不同版本的实现, 称为方法重载
- 方法名相同
- 返回值不做要求
- 参数列表不同（参数个数或参数类型不同）
- 同一个类当中
1
2
3
4
5
6
7
8
9
| 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的阶乘
1
2
3
4
5
6
7
8
9
10
| 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个阶乘之和
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| 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)
1
2
3
4
5
6
7
8
9
| 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
1
2
3
4
5
6
7
8
9
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
1
2
3
4
5
6
7
8
9
| 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项：
1
2
3
4
5
6
7
| public static int fib(int n) {
if (n == 1 || n == 2) {
return 1;
}
return fib(n - 1) + fib(n - 2);
}
|
不建议用递归实现斐波那契数列，建议用循环。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| 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));
}
|
思考递归：横向思考，不要展开递归的代码
代码执行：纵向执行
