JavaSe基础2022年12月05日学习内容

森森爱学习

已于 2022-12-05 20:44:33 修改

阅读量75

点赞数

分类专栏： JavaSe基础文章标签：学习 java 算法

于 2022-12-05 20:43:38 首次发布

本文链接：https://blog.csdn.net/weixin_53214204/article/details/128192672

版权

JavaSe基础专栏收录该内容

19 篇文章 0 订阅

订阅专栏

JavaSe-2022-12-05

每日一句:先众人而为，后众人而言。

学习内容:方法、递归

方法

概念：将一堆代码重用的机制；
用自己的话来说：方法是一个概念从古至今就有，如原始人钻木取火得到火种的方法；方法一个方法定义多个人去使用的才能叫做方法；在代码中也是这样如我们定义一个求和的方法，只需要调用两个数字就能够求出它们的和是多少
语法结构
- 访问修饰符静态修饰符返回值类型方法名（参数类型）{}

根据返回值的不同和参数的不同主要分为4类

 public static void main(String[] args) {
        // 1  无返回值无参数
        f1();
        // 2  无返回值有参数
        f2("小黑");
        // 3  有返回值无参数
        f3();
        // 4  有返回值有参数
        f4(4);
    }
    // 1  无返回值无参数
    public static void f1(){}
    // 2  无返回值有参数
    public static void f2(String name){}
    // 3  有返回值无参数
    public static int f3(){return 1;}
    // 4  有返回值有参数
    public static int f4(int a){return a;}

注意：方法必须在主方法中调用才能执行，方法之间是并列关系。

方法的使用

public static void main(String[] args) {
        int[] a1 = {1,2,24,52,6,2,3,4,1,2,3};
        //调用下面写的方法 加上static（静态）我们就可以直接调用
        sort(a1);
        System.out.println(f1(1,2));  //f1(1,2)传递的是实参
        System.out.println(f2(3,4));
        System.out.println(f3());
    }
    //冒泡排序
    public static void sort(int[] arr){
//        将传递过来的arr直接使用
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = 0; j < arr.length -i-1; j++) {
                if(arr[j] > arr[j+1]){
                    int t = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = t;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
    //定义一个方法f1，返回两个指定整数的和并调用  int x是形参
    public static int f1(int x,int y){
        return x+y;
    }
    //定义一个方法f2，返回两个指定整数中的较大者并调用
    public static int f2(int x,int y){
        return x > y ? x : y;
    }
    //定义一个方法f3，输出两个随机整数的乘积并调用
    public static int f3(){
        Random random = new Random();
        int x = random.nextInt(10)+1;
        int y = random.nextInt(10)+1;
        return x*y;
    }

递归

什么是递归
- 方法自己调用自己就是递归
- 递归很耗费栈内存的，能够不用尽量不要用
- 递归必须有结束条件，没有结束条件一定会发生栈内存溢出错误

递归的使用

//计算第n项阶乘
 public static void main(String[] args) {
        System.out.println(f(3));
    }
    public static int f(int n){
        if(n<=1)
            return 1;
        else
            return n*f(n-1);
    }
}
//   计算第n项斐波那契数的值
 public static void main(String[] args) {
        int n = 10;
        System.out.println(f(n));
 }
 public static int f(int n){
        //推导出递归推送
        //给出递归终止条件
        if(n== 1 || n==2){
            return 1;
        }
        return f(n-1)+f(n-2);
 }