java 递归算法_Java之方法以及递归

方法

首先，我们先思考一个问题，那就是什么是方法？概念：完成特定的功能且可以被重复使用的代码块称之为方法(Method),其他语言称为函数或是过程，针对不同人群概念也随着改变。

方法的形式

[修饰符]返回值类型 方法名称(形式参数1，形式参数2，...)｛

方法体

return 返回值

｝

注意：修饰符：决定了方法的工作范围

返回值的类型：如果没有返回值，须写void,方法只能返回一个值

方法名：遵循标识符命名规则，建议驼峰命名法

参数列表：可以0个，1个，多个，需要同时说明类型，也称为形式参数

方法体：完成具体功能，如果有返回值，必须有return语句；

如果没有返回值，默认最后一条语句是return,可以省略。return用于结束方法，把控制权交给方法调用处

例子：定义一个方法，求两个数的和

public class Test01{

// 需求:计算两个整数的和public static int add(int a,int b){

int c = a + b;

return c;

}

}

例子：输出n*n的乘法表

public static void mutipleTable(int n){

for(int i=1;i<=n;i++){

for(int j=1;j<=i;j++){

System.out.print(j+"x"+i+"="+(i*j)+"\t");

}

System.out.println();

}

// return;}

方法调用

public static void main(String[] args){

int m = 10;

int n = 20;

// 方法的调用int r = add(m,n);

System.out.println("r = " + r);

}在方法定义时的参数称为形式参数，简称形参

在方法调用时传入的参数称为实际参数，简称实参

其中，实参到形参的过程是值的传递

方法重载(overload)一个类中方法名称相同，参数列表不同的方法构成方法重载

方法重载的判断依据1.同一个类中

2.方法名相同

3.参数列表不同(类型，个数，参数类型的顺序不同)

这么说可能会有点抽象，那我再甩出一个栗子吧！

public class Test02{

public static int add(int a,int b){

System.out.println("add(int,int)");

int c = a + b;

return c;

}

// 类型不同public static float add(float a,float b){

System.out.println("add(float,float)");

float c = a+b;

return c;

}

// 个数不同public static int add(int a,int b,int c){

System.out.println("add(int,int,int)");

int c = a+b+c;

return c;

}

// 不构成重载/*public static float add(float b,float a){float c = a+b;return c;}*/

// 参数类型顺序不同public static float add(float a,int b){

System.out.println("add(float,int)");

float c = a+b;

return c;

}

public static float add(int a,float b){

System.out.println("add(int,float)");

float c = a+b;

return c;

}

public static void main(String[] args){

int m = 10;

int n = 20;

// 方法的调用int r = add(m,n);

System.out.println("r = " + r);

float r2 = add(10.1f,20.1f);

System.out.println("r2 = " + r2);

}

}

前方高能，请注意：方法重载和方法的返回值是没有任何关系滴。

方法的名称和其参数类型构成方法签名，用于标记一个唯一的方法。

方法重载就是在同一类中，方法名称相同但方法签名不同构成方法重载

方法重写在java和其他一些高级面向对象的编程语言中，子类可继承父类中的方法，而不需要重新编写相同的方法。但有时子类并不想原封不动地继承父类的方法，而是想作一定的修改，这就需要采用方法的重写。方法重写又称方法覆盖。

关于方法重写的一些特性：

1.发生方法重写的两个方法返回值、方法名、参数列表必须完全一致(子类重写父类的方法)

2.子类抛出的异常下不能超过父类相应方法抛出的异常(子类异常不能大于父类异常)

3.子类方法的访问级别不能低于父类相应方法的访问级别(子类访问级别不能低于父类访问级别)

根据2，3条可以确定第一条，子类重写父类方法的返回值类型不能大于父类方法的返回值类型，即是说子类方法的返回值必须和父类方法的返回值相同或是其子类。

注意事项：方法重写与方法重载不同，方法的重载是方法的参数个数或类型不同，方法名相同。

方法重写是要注意权限的问题，子类中的权限不能小于父类的权限，当父类的权限为private时，子类无法继承。也就无法产生所谓的重写。(修饰符高低：private < 默认修饰符 < public)

主要的区别如下：

方法的递归方法之间可以相互调用。在调用的过程中，有一类特殊情况，就是方法自身调用自身的情况称为方法递归。

递归问题的特点一个问题可被分解为若干层简单的子问题

子问题和其上层问题的解决问题方案一致

外层问题的解决依赖于子问题的解决

递归结构包括两个部分：递归结束条件

递归体

例子：使用递归求n!

public int jc(int n){

if(n == 1||n== 0){

return n;

}else{

return n*jc(n-1);

}

}

public static void main(String[] args) {

Scanner input = new Scanner(System.in);

System.out.println("请输入你要算的阶乘的数字：");

int n = input.nextInt();

Ceshi c = new Ceshi();

System.out.println("你所输入的"+n+"的阶乘为："+c.jc(n));

}

关于递归的总结：

递归的优点：

简单的程序

递归的缺点：

递归虽然程序简单，但是递归调用会占用大量的系统堆栈，内存耗用多。

在递归调用层次多时的速度要比循环慢的多。

递归的使用场合：

任何可用递归解决的问题也能使用迭代解决。

当递归方法可以更加自然地反映问题，并且易于理解和调试，并且不强调效率问题时，可以采用递归。

在要求高性能的情况下尽量避免使用递归，递归既花时间又耗内存。

好了，关于方法与递归，大饼我就先分享到这吧！我们下期见，ByeBye~