5. 方法小记

什么是方法?

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

传参的时候应该注意

1. 参数的个数必须匹配
2. 参数的类型必须匹配
3. 参数的顺序必须匹配

写一个求和方法(一个有返回值, 一个无返回值)

    public static void add2(int a, int b) {
        int ret = a + b;
        System.out.println(ret);
    }

    public static int add1(int a, int b) {
        return a + b;
    }
    public static void main(String[] args) {
        int pr = add1(3,7);//需要用ret去接受
        System.out.println(pr);
        
        add2(30,6);
    }

1. 修饰符：现阶段直接使用public static 固定搭配
2. 返回值类型：如果方法有返回值，返回值类型必须要与返回的实体类型一致，如果没有返回值，必须写成
   void
3. 方法名字：采用小驼峰命名
4. 参数列表：如果方法没有参数，()中什么都不写，如果有参数，需指定参数类型，多个参数之间使用逗号隔开
5. 方法体：方法内部要执行的语句
6. 在java当中，方法必须写在类当中
7. 在java当中，方法不能嵌套定义
8. 在java当中，没有方法声明一说

求1! + 2! + 3! + 4! + 5!

    public static int func1(int n) {
        int ret = 1;
        for (int i = 1; i <= n; i++) {
            ret *= i;
        }
        return ret;
    }

    public static void func2(int n) {
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum += func1(i);
        }
        System.out.println(sum);
    }


    public static void main(String[] args) {
        int ret = func1(5);
        System.out.println(ret);
        func2(5);
    }

判断素数

无返回值

   public static void isPrim(int n) {
        int i = 2;
        for (; i <= Math.sqrt(n); i++) {
            if (n % i == 0) {
                System.out.println(n +" 不是素数");
                break;
            }
        }
        if (i > Math.sqrt(n)) {
            System.out.println(n + " 是素数");
        }
    }

    public static void main(String[] args) {
        for (int i = 2; i < 101; i++) {
            isPrim(i);
        }
    }

有返回值

    public static boolean isPrim1(int n) {
        int i = 2;
        for (; i <= Math.sqrt(n); i++) {
            if (n % i == 0) {
                System.out.println(n +" 不是素数");
                break;
            }
        }
        if (i > Math.sqrt(n)) {
            return true;
        }
        return false;
    }

    public static void main(String[] args) {
        for (int i = 2; i < 101; i++) {
            boolean ret = isPrim1(i);
            if (ret == true) {
                System.out.println(i + " 是素数");
            }
        }
    }

要不要返回值是看, 是否需要用到返回值去做事情

方法的重载

重载(overload)

1. 方法名称相同
2. 形参列表不同
3. 返回值可以相同也可以不同

输入一组数字找到只出现一次的数字
这里我们需要用到^(异或), 下面由我来详细介绍一下这个运算符

    /**
     * 输入一组数字找到只出现一次的数字
     * @param args
     */
    public static void main(String[] args) {
        int[] array = {1,2,3,2,1};
        int sum = 0;
        for (int i = 0; i < array.length; i++) {
            sum = sum ^ array[i];
        }
        System.out.println(sum);
    }

递归

递归相当于数学上的 “数学归纳法”, 有一个起始条件, 然后有一个递推公式

写一个n的阶乘的递归

public static int func(int n) {
        if (n == 1) {
            return 1;
        }
        int tmp = n * func(n-1);
        return tmp;
    }
    public static void main(String[] args) {
        int ret = func(4);
        System.out.println(ret);
    }

使用递归，按照顺序打印一个数字的每一位数

   /**
     * 按照顺序打印一个数字的每一位数
     * @param n
     */
    public static void print(int n) {
        if (n < 10) {
            System.out.println(n);
        }else {
            print(n/10);
            System.out.println(n%10);
        }
    }
    public static void main(String[] args) {
        print(1234);
    }

使用递归求1+2+3…+10

    public static int sum(int n) {
        if (n == 1) {
            return 1;
        }else {
            int tmp = n + sum(n-1);
            return tmp;
        }
    }
    public static void main(String[] args) {
        int ret = sum(10);
        System.out.println(ret);
    }

写一个递归方法，输入一个非负整数，返回组成他们的数字之和。例如：输入1729，则应该返回1+7+2+9，它的和是19

    public static int sum(int n) {
        if (n < 10) {
            return n;
        }else {
            int tmp = n % 10 + sum(n / 10);
            return tmp;
        }
    }
    public static void main(String[] args) {
        int ret = sum(1729);
        System.out.println(ret);
    }

使用递归写出斐波那契数列

    public static int fib(int n) {
        if (n == 1 || n == 2) {
            return 1;
        }else {
            int tmp = fib(n-1) + fib(n-2);
            return tmp;
        }
    }
    public static void main(String[] args) {
        int ret = fib(5);
        System.out.println(ret);
    }

斐波那契数列并不适合使用递归去算，原因：计算量太大

迭代就是【循环】只是叫法不同！

创作于：2022年9月28日01:13:18😆😆😆