方法

   public static boolean isLeapYear(int year){
        if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0){
            return true;
        }
        return false;
    }

方法调用：

import java.util.Scanner;

public static void main(String[] args) {
        System.out.println("请输入一个年份");
        Scanner scan = new Scanner(System.in);
        int year = scan.nextInt();

        boolean flg = isLeapYear(year);
        if (flg){
            System.out.println(year + "是闰年");
        }
        else {
            System.out.println(year + "不是闰年");
        }
    }

例：调用输出1！+2！+3！+4！+5！的和

public class wew {//输出1！+2！+3！+4！+5！的和
    public static int facSum(int n){
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum += fac(i);
        }
        return sum;
    }

    public static int fac(int n){
        int ret = 1;
        for (int i = 1; i <= n; i++) {
            ret *= i;
            //System.out.println(ret);
        }
        return ret;
    }
    public static void main(String[] args) {
        System.out.println(facSum(5));
    }
}

对于交换两个数的程序的思想：面向对象，才能真正解决问题

调用方法要给方法开辟空间，这个结束后程序会回收栈帧，但栈上的地址，程序无法获取到

方法重载的构成

主函数写实参的时候只用写add就有提示

方法重载的必要条件：

1.方法名一样

2.参数列表不一样（数据类型，个数，顺序）

3.返回值没有要求（满足前两个的前提下）

方法签名：

经过编译器修改后方法最终的名字

具体方式：方法全路径名+参数列表+返回值类型 ---》构成方法完整的名字

可以用JDK自带的javap反汇编工具查看

1.先对工程进行编译生成，class字节码文件

2.在控制台进入到要查看的.class所在的目录（cmd）

3.输入：javap -v 字节码文件名

方法签名中一些特殊符号说明：

V	void
Z	bloolean
B	byte
C	char
S	short
I	int
J	long
F	float
D	double
【	数组
L	以L开头以；结尾，中间是引用类型的全类名

执行运行完之后再看字节码文件（.class），可以在本地文件的out里看到字节码文件

例如：求2个整数的最大值和求3个整数的最大值，构成重载

public class qqq {
    public static int max(int a,int b){
        return a>b?a:b;
    }

    public static int max(int a,int b,int c){
        int temp = max(a,b);
        return max(temp,c);
    }

    public static void main(String[] args) {
        System.out.println(max(5, 3, 4));
    }
}

可变参数编程

打印一组都是整型的数据

实参超过3个调用的是可变参数编程

递归

相当于“数学归纳法”：起始条件、递推公式

递归必要条件：1.将原问题划分为子问题 2.递归出口

例如：递归求 N！

例如：按顺序打印数字的每一位，例如1234打印出1234

public class test {//按顺序打印数字的每一位，例如1234打印出1234
    public static void func(int n){
        if (n < 10){
            System.out.print(n);
            return;
        }
        else{
            func(n / 10);
            System.out.print(n % 10);
        }
    }

    public static void main(String[] args) {
        func(123);
    }
}

例如：递归求1+2+3+...+10

public class rest2 {//求1+2+3+...+10
    public static int func(int n){
        if (n == 1){
            return n;
        }
        else {
            return n + func(n-1);
        }
    }

    public static void main(String[] args) {
        System.out.println(func(10));
    }
}

例如：用递归方法算，输入一个非负整数，返回组成它的数字之和，例如输入1234，则应返回1+2+3+4，它的和是10

public class test3 {
    public static int fun(int n){
        if (n < 10){
           return n;
        }
        else {
            return (n % 10) +fun(n / 10);
        }
    }

    public static void main(String[] args) {
        System.out.println(fun(1729));
    }
}

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

求这个用递归做，会进行重复的计算，称为多路递归

public class text4 {//求斐波那契数列的第N项
   public static int fib(int n){
        //递归形式
        if (n == 1 || n == 2){
            return 1;
        }
        else {
            return fib(n-1)+fib(n-2);
        }
    }

   /** public static int fib2(int n){
        //非递归形式
        if (n == 1 || n == 2){
            return 1;
        }
        else {
            int f1 = 1;
            int f2 = 1;
            int f3 = 0;
            for (int i = 3; i <=n ; i++) {
                f3 = f1 + f2;
                f1 = f2;
                f2 = f3;
            }
            return f3;
        }
    }*/

    public static void main(String[] args) {
        System.out.println(fib(5) + fib(20));
    }
}

（听课笔记）