Day6 方法和递归

方法

什么是方法
封装在一起来执行操作语句的集合，用来完成某个功能操作

在某些语言中称为函数或者过程

特殊的方法main，程序执行的入口

public static void main(String [ ] args){
实现功能的语句
}

不可能所有的功能都放到main中，需要定义其他方法完成指定功能，需要时调用方法即可

定义方法
[修饰符] 方法返回值类型 方法名(形参列表 ) {
方法体
return 返回值；
}
public static int add(int a, int b, int c) {
int k = a + b + c;
return k;
}
修饰符：封装性时再讲，决定了方法的工作范围
返回值类型：必选，如果没有返回值，须写void。方法只能返回一个值
方法名：
参数列表：可以0个、1个、多个，需要同时说明类型。称为形式参数
方法体：完成具体功能。如果有返回值，必须有return语句；如果没有返回值，默认最后一条语句是return，可以省略。

方法重载
一个类中可以定义有相同的名字，但参数不同的多个方法
调用时，会根据不同的参数表选择对应的方法。
判断依据
同一个类
同一个方法名
不同：参数列表不同(类型，个数，顺序不同)
注意
只有返回值不同不构成方法的重载（
int a(String str){},
void a{String i},
调用：a()， 谁能告诉我是调哪个方法?
只有形参的名称不同，不构成方法的重载

例题：

功能：模拟计算器加法运算
技能：认识方法

class MethodTest2{
    public static void printHello(){
        System.out.println("HelloWorld");
    } 
    //此处声明加法方法
    public static int add(int a1,int b1){
        printHello();
        int sum = a1 + b1;
        return sum;
    }
    public static void main(String [] args){
        int m = 10;
        int n = 66;
        //定义变量接收方法执行的结果
        int sum = add(m,n);
        System.out.println(sum);
    }
}

2.使用方法完成2~100内的质数
判断一个数是否为质数通过方法完成

class MethodTest3{
    public static void main(String[] args){

        System.out.println(Math.sqrt(16));

        for(int i = 2;i <= 100; i++){
            //如果是质数就输出
            if(isZhiShu(i)){
                System.out.println(i);
            }
        }
    }
    //定义方法判断是否为质数
    public static boolean isZhiShu(int num){
        //for(int j = 2; j<num;j++){
        for(int j = 2; j<=Math.sqrt(num);j++){
            if(num % j == 0){
                return false;
            }
        }
        return true;
    }
}

3.功能：模拟计算器加法运算
技能：认识方法的重载

方法的重载：
使用同一方法名，不同的形参列表，完成相同的功能
使用方法重载需要注意的地方：
两同一（3）不同
同一类中
同一方法名
不同的形参列表
数量
顺序
类型
方法的重载方法很多 根据 传入实参的不同调用相应的方法

class MethodTest4{
    public static void main(String[] args){
        int m = 10;
        int n = 20;
        double d = 3.14;
        add(m,n);
        add(m,d);
        add(10,20,30);
        add(5.26,10);
    }

    public static void add(int a,int b){
        //return a+b;
        System.out.println(a+b);
    }
    public static void add(int a,double s){
        System.out.println(a+s);
    }
    public static void add(double d1,int a1){

        System.out.println("double + int "+(d1+a1));
    }
    public static void add(int a,int b,int c){
        System.out.println("三个int类型的参数相加"+(a+b+c));

    }
}

递归算法

什么是递归（recursion）
程序调用自身的编程技巧称为递归。
一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法
递归问题的特点
一个问题可被分解为若干层简单的子问题
子问题和其上层问题的解决方案一致
外层问题的解决依赖于子问题的解决

递归的优点
简单的程序

递归的缺点
但是递归调用会占用大量的系统堆栈，内存耗用多，
在递归调用层次多时速度要比循环慢的多

递归的使用场合
任何可用递归解决的问题也能使用迭代解决。
当递归方法可以更加自然地反映问题，并且易于理解和调试，并且不强调效率问题时，可以采用递归；
在要求高性能的情况下尽量避免使用递归，递归既花时间又耗内存。

例题：

用循环和递归分别打印斐波那契数列前10个数：

public class Test1 {

    public static void main(String[] args) {
        for (int i = 1; i <= 15; i++) {
            System.out.print(getNum1(i) + " ");
        }
        System.out.println();
        for (int i = 1; i <= 15; i++) {
            System.out.print(getNum2(i) + " ");
        }
    }

    /**
     * 1 1 2 3 5 8 13 求斐波那契数列中第n个数的数值
     * 
     * @param n
     * @return 返回要求的数
     */
    public static int getNum1(int n) {
        int front = 1;
        int next = 1;
        int sum = 1;
        for (int i = 3; i <= n; i++) {
            sum = front + next;
            // 角色改变 (当前循环的前一个数，为上次循环中的后一个数，当前循环后一个数，为上次循环和)
            front = next;
            next = sum;
        }
        return sum;
    }

    /**
     * 递归求斐波那契数列中的第n个数
     * 
     * @param n
     * @return
     */
    public static int getNum2(int n) {
        // 如果n是第一个或者第二个数字的时候，值为1
        // 否则为前连个数的和 getNum2(n-1) + getNum(n-2);
        if (n == 1 || n == 2) {
            return 1;
        } else {
            return getNum2(n - 1) + getNum2(n - 2);
        }
    }

}

小结

方法
定义方法指定形参，调用方法指定实参
方法调用是要求形参实参要求个数相同，类型匹配
方法重载：方法名相同，参数不同

递归
程序调用自身的编程技巧称为递归。
递归简单，但是内存耗用多，速度要比循环慢
任何可用递归解决的问题也能使用循环解决，反之不见得