Java中方法的定义、重载与递归

一丶方法的基本知识

1.什么是方法？

在Java中方法就是完成特定功能的代码，类似于C语言中函数概念。

2.方法的定义

// 方法定义 
修饰符 返回值类型 方法名(参数类型 参数名 1，参数类型 参数名 2…) { 
   函数体;    
   return 返回值;
} 
//方法调用 
返回值变量 = 方法名称(实参...);

3.方法举例

比如计算两个整数相加：

• 不用方法写

public static void main(String[] args) {
	int a = 10;        
	int b = 20; 
	int ret=a+b;
	System.out.println("ret = " + ret);   
}
/*执行结果
ret=30

• 用方法来写

class Test {
	public static void main(String[] args) {        
		int a = 10;        
		int b = 20;        
		System.out.println("第一次调用方法之前");        
		int ret = add(a, b);        
		System.out.println("第一次调用方法之后");        
		System.out.println("ret = " + ret);
        	System.out.println("第二次调用方法之前");        
        	ret = add(30, 50);        
        	System.out.println("第二次调用方法之后");        
        	System.out.println("ret = " + ret);   
        }
	public static int add(int x, int y) {        
		System.out.println("调用方法中 x = " + x + " y = " + y);        
		return x + y;    
	} 
}
/* 执行结果 
第一次调用方法之前 
调用方法中 x = 10 y = 20 
第一次调用方法之后 
ret = 30 
第二次调用方法之前 
调用方法中 x = 30 y = 50 
第二次调用方法之后 
ret = 80
*/

4.方法的注意事项

1. 定义方法的时候, 不会执行方法的代码，只有调用的时候才会执行.
2. 方法与方法是平级关系，不能嵌套定义
3. 方法定义的时候参数之间用逗号隔开
4. 方法调用的时候不用在传递数据类型
5. 如果方法有明确的返回值，一定要有return带回一个值
6. 当方法执行完毕之后(遇到 return 语句), 就执行完毕, 回到方法调用位置继续往下执行

5.方法存在的意义

1. 是能够模块化的组织代码(当代码规模比较复杂的时候).
2. 做到代码被重复使用, 一份代码可以在多个位置使用.
3. 让代码更好理解更简单.
4. 直接调用现有方法开发, 不必重复造轮子

二丶 方法的重载

1.什么是方法的重载？

在Java里，同一个类中的多个方法可以有相同的方法名称，但是有不同的参数列表，这就称为方法重载（method overloading）。

2.重载的规则

1. 方法名称必须相同。
2. 参数列表必须不同。参数列表的不同包括：个数不同、顺序不同、类型不同。
3. 方法的返回类型可以相同也可以不相同。
4. 仅仅返回类型不同不足以称为方法的重载。

3.重载举例

class Test {
	public static void main(String[] args) {
		int a = 10;   
		int b = 20;   
		int ret = add(a, b);   
		System.out.println("ret = " + ret); 
		double a2 = 10.5;   
		double b2 = 20.5;   
		double ret2 = add(a2, b2);   
		System.out.println("ret2 = " + ret2); 
 		double a3 = 10.5;   
 		double b3 = 10.5;   
 		double c3 = 20.5;   
 		double ret3 = add(a3, b3, c3);   
 		System.out.println("ret3 = " + ret3);  
 	} 
 	public static int add(int x, int y) {
 		return x + y;  
 	} 
	public static double add(double x, double y) {
		return x + y;  
	} 
	public static double add(double x, double y, double z) {
		return x + y + z;
	} 
} 

方法的名字都叫 add. 但是有的 add 是计算 int 相加, 有的是 double 相加; 有的计算两个数字相加, 有的是计算三个数 字相加. 同一个方法名字, 提供不同版本的实现, 这就是方法重载。

4.重载的实现

方法名称相同时，编译器会根据调用方法的参数个数、参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错，这叫做重载分辨。

5 .重载和重写的区别？

1. 什么是重写
   在Java中，子类可继承父类中的方法，而不需要重新编写相同的方法。但有时子类并不想原封不动地继承父类的方法，而是想作一定的修改，这就需要采用方法的重写。方法重写又称方法覆盖。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 。参数列表必须完全与被重写的方法相同，否则不能称其为重写；返回类型必须一直与被重写的方法相同，否则不能称其为重写(Overriding)。
2. 二者区别
   方法的重写和重载是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了，而且如果子类的方法名和参数类型和个数都和父类相同，那么子类的返回值类型必须和父类的相同；如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载。重载是可以改变返回值的类型。也就是说，重载的返回值类型可以相同也可以不同。总的来说：
   **(1)**重载主要发生在同一个类的多个同名方法之间
   **(2)**重写发生在子类和父类的同名方法之间
   把重载和重写放到一起比较本身没有太大的意义。他们除了方法名相同之外，没有太大相似之处。此外，子类和父类之间也会发生重载。如果子类定义了一个与父类相同名字的方法，但是参数列表不同的方法，那么就会形成子类方法和父类方法的重载

三丶方法的递归

1.什么是递归？

简单来说就是一个方法在执行过程中调用自身, 就把这个过程称为 “递归”。

2.递归需满足的条件

1. 调用自己本身；
2. 有一个趋近于终止的条件。（什么意思呢？递归分为递和归，如果没有一个趋近于终止的条件来结束递的过程，将会一直调用函数，不仅递归会失去意义，还会挤爆栈，所以必须有一个趋近于终止的条件）

3.递归的经典实例

1. 求斐波那契数列的第n项

• 递归实现

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

• 非递归实现

 public static int fib(int n){
       int f1=1;
       int f2=1;
       int f3=0;
       if(n<=2) {
           return 1;
       }
       for (int i = 3; i <=n ; i++) {
           f3=f1+f2;
           f1=f2;
           f2=f3;
       }
       return f3;
   }

可以看到用递归实现，两行代码就完成了，从编程角度来说非常简洁，而且理论上完全没问题。但是，计算一下F(10)，要前反复调用94次F(n)，嵌套8层，最糟糕的是F(2)被重复计算了31次，F(3)被重复计算了21次，F(4)被重复计算了13次。在面对更大的n时，即使不考虑栈被挤爆的情况，计算速度也是非常慢的。
换言之虽然非递归的形式略微繁琐了一点，但是相对于递归形式实现来说，在次问题上其效率提高了几十万倍不止！所以，递归有递归的好处，在一些特殊问题求解上会非常方便，但也有他的坏处，在资源有限的处理器上运行时，应谨慎使用！

4.递归的优缺点

1. 优点：
   递归会大大减少代码行数，使之更简洁清晰，可读性更好。
2. 缺点：
   (1) 递归调用函数,浪费空间；
   (2)递归太深容易造成堆栈的溢出；
   (3)可能会产生过多的冗余计算，浪费计算资源（比如递归实现斐波那契）