Java基础之循环控制语句、函数、数组

Java基础

1.循环控制语句: break、continue

public static void main(String[] args) {
        /*
            TODO 循环控制语句 - break
                 需要和 for 以及 while 循环搭配使用  当在循环中执行了 break语句 那么就可以退出当前循环
         */

        int sum = 0;
        for (int i = 1; i <= 1000; i++) {
            sum += i;
            if (i >= 100) {
                break;
            }
        }
        System.out.println("sum:" + sum);

        sum = 0;
        int num = 1;
        while (true) {
            if (num > 100){
                // 当循环进入if中时，可以退出当前循环
                break;
            }
            sum += num;
            num += 1;
        }
        System.out.println("sum:" + sum);
        
        
        
        
        /*
            TODO 循环控制语句 - continue
                 需要和 for 以及 while 循环搭配使用  当在循环中执行了 continue 语句 那么就可以退出当次循环进入下一次循环
         */

        // 对1~100之间所有的偶数进行求和
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 1) {
                // 当i的值为奇数时,什么都不做,直接进入下一次循环
                continue;
            }
            sum += i;
        }

        System.out.println("sum:" + sum);
        
        
        //拓：
        /*
        
           TODO DEBUG: (Debug使用非常非常重要)
                通过IDEA的工具,展示程序在运行时,每一步的过程,并对其进行控制
                用法:
                    ① 运行时需要右键选择 Debug 当前代码
                    ② 在当前代码的左边控制栏 点击会出现红点 其作用是在Debug运行模式下,程序到该行时会暂停
                    ③ 当程序暂停时,可以对程序进行控制
                            step over 表示执行当前代码文件中下一行代码
                            stop into 进入当前方法内
                            stop out 退出当前方法
                            Resume Program 从当前断点继续执行程序,到下一个断点继续暂停程序
                    ④ 对于程序运行中可以打断点,使用 Resume Program 跳转到当前断点
         */

        
        
        
        /*
            TODO 双重循环控制语句下 continue 和 Break的使用
                 注意:
                    break 默认每次执行都只能退出一个循环
                    如果要退出多层循环,那么就需要对某一层循环进行标记 格式为:
                        标记信息:for / while 同时 break后加上 标记信息
                   continue和Break的用法一致
         */

        wd:for (int i = 0; i < 5; i++) {
            for (int j = 0; j <= i ; j++) {
                System.out.print("*\t");
                if (i == 3 && j ==2) {
                    break wd;
                }
            }
            System.out.println();
        }
        
        System.out.println("=============");
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j <= i ; j++) {
                if (j == 2) {
                    continue;
                }
                System.out.print("*\t");
            }
            System.out.println();
        }
        

    }

2.方法/函数

public static void main(String[] args) {
        /*
           TODO 方法/函数
                作用:
                    对于代码中重复出现的代码,进行包装,形成一个方法,在需要方法代码时,直接调用即可
                格式:
                    修饰符 返回值类型 方法名称(参数列表){
                        方法体(方法执行时的代码)
                        return 值; 如果有返回值的情况下
                    }
                修饰符: 用于修饰当前方法的访问权限,以及方法的类型  暂时使用 public static
                返回值类型: 基本数据类型 / 引用类型  如果没有返回值此时需要使用 void 关键字 表示
                方法名称: 要注意名称定义规则 首个单词首字母小写 其他单词首字母大写 单词间可以直接拼接
                参数列表: 可以给定多个参数  格式: 参数类型 参数名
                    -> 1.形参  在参数列表中定义的 定义时,没有具体值 用于指代一个变量
                    -> 2.实参  在方法调用时,给方法的参数进行传入值称为实参
                方法体:  具体的代码,可以直接调用其他方法
                return: 如果方法没有返回值,可以不需要添加 对于Java来说 return 返回值需要和返回值类型相匹配,每次执行返回一个值

            TODO   注意:
                    1.方法调用,可以直接使用方法名(参数值)
                    2.方法在传参时,需要类型想对应
                    3.方法与方法是平级关系，不能嵌套定义
                    4.方法调用的时候不用在传递数据类型
                    5.如果方法有明确的返回值，一定要有return带回一个值

         */

        printFun();
        int funRes = addFun(4, (short) 5);
        System.out.println("funRes:" + funRes);

        String str = strAddFun(3, (short) 4);
        System.out.println(str);

        int a = 3;
        short b = 4;
        String s = strAddFun(a, b);

        // 方法内不能再定义方法
//        public static int addFun1(int a, short b) {
//            return a + b;
//        }
    }

    public static void printFun() {
        System.out.println("这是一个无参无返回值的函数");
    }

    public static int addFun(int a, short b) {
        return a + b;
    }

    public static String strAddFun(int a, short b) {
        return a + b + "";
    }

3.方法重载

public static void main(String[] args) {
        /*
             TODO 方法重载
                 定义: 将方法名称相同,但是参数列表不同的函数的定义方式,成为方法的重载
                 注意: 方法的重载只和参数列表有关,和返回值无关
         */

        // 将方法的结果作为另外一个方法的参数传入
        System.out.println(add(3));
        System.out.println(add(2, 3));

    }

    public static int add(int a){
        return a+a;
    }

    public static int add(int a,int b){
        return a+b;
    }

    // 错误 ：返回值相同导致
//    public static String add(int a,int b){
//        return a+b+"";
//    }

4.递归

public static void main(String[] args) {
    /*
        TODO 方法递归
             注意:
                 1.方法内部调用自身
                 2.方法递归需要有停止标记  如果没有停止标记那么会出现 栈内存溢出错误 java.lang.StackOverflowError
     */

    System.out.println(reloadFun(5)); // 120

    /*
        TODO 递归函数的调用逻辑 以 reloadFun(3)为例
             reloadFun(3) n =3
                ->  n * reloadFun(n-1); n = 3  (必须先将 n * reloadFun(n-1); 计算完成才能执行return 返回数据 )
                  ->  reloadFun(2)
                    ->  n * reloadFun(n-1); n = 2
                      ->  reloadFun(1)
                      ->  return 1;
                    ->  reloadFun(2) = n * reloadFun(1) => 2 * 1 = 2
                -> 3 * reloadFun(2) = 3 * 2 = 6
             程序执行结束
     */

    reloadFunLong(10);

}

// 函数的递归调用
public static int reloadFun(int n){
    System.out.println("接收到N:"+n);
    // 当n不等于1时调用自身,等于1时返回结果1
    if (n == 1){
        return 1;
    }else {
        return n * reloadFun(n-1);
    }
}

5.一维数组

public static void main(String[] args) {
        /*
           TODO  Array 数组
                定义:  将相同类型的数据汇集到一起,形成一个变量 改变成为数组 可以看成是一个容器
                数组变量的形式为 引用类型,引用类型为空可以使用 null 来进行表示
                格式1：数据类型[] 数组名;
                      初始化:  ① 数据类型[] 数组名 = new 数据类型[长度]  -> 动态初始化
                              ② 数据类型[] 数组名 = new 数据类型[]{元素,元素,元素,...} -> 静态初始化
                              ③ 数据类型[] 数组名 = {元素,元素,元素,...} -> 静态初始化
                格式2：数据类型 数组名[]
                              ① 数据类型 数组名[] = new 数据类型[长度]  -> 动态初始化
                              ② 数据类型 数组名[] = new 数据类型[]{元素,元素,元素,...} -> 静态初始化
                              ③ 数据类型 数组名[] = {元素,元素,元素,...} -> 静态初始化

           TODO     注意:
                    ① 对于变量定义后需要对其进行初始化(赋值)
                    ② 对于数组定义后,其长度固定
                    ③ 通过数组的下标可以对数组元素进行赋值,同时也可以进行取值,同时下标从0开始
                    ④ 对于数组初始化后,对其中每个下标对应位置保存的数据也进行了初始化,使用相对应的默认值进行填充
                            例如 String  ->  null

         */
        // 需求:定义员工姓名  => 姓名元素是一个字符串  => String 类型
//        String[] employName = null;
        String[] employName = new String[3];
        employName = new String[4];
        employName[0] = "李白";
        employName[1] = "杜甫";
        employName[2] = "白居易";
//        employName[3] = "李国涛";
        // 超过长度后出错: java.lang.ArrayIndexOutOfBoundsException  -> 数组越界异常
        employName[3] = "纳兰性德";
        System.out.println(employName); // [Ljava.lang.String;@4554617c  => [ 数组  java.lang.String 存储的元素类型 @4554617c 地址
        System.out.println(employName[0]); // 李白
        System.out.println(employName[1]); // 杜甫
        System.out.println(employName[2]); // 白居易
        System.out.println(employName[3]); // 纳兰性德
    
    
    
    /*
            定义两个数组，先定义一个数组，赋值，输出。然后定义第二个数组的时候把第一个数组的地址赋值给第二个数组。
            然后给第二个数组赋值，再次输出两个数组的名及元素。

            TODO 两个变量指向同一个对象地址
                 当对变量进行操作时,实际上就是对其变量保存的内存地址上的对象数据进行操作

         */

        String[] names1 = new String[3];
        String[] names2 = new String[2];
        names1[0] = "唐三";
        names1[1] = "小舞";
        names2[0] = "大明";

        // 将 names2 的内存地址赋予给 names2, names2保存的内存地址也存在
        //此时names2、names2指向内存中的同一块地址，因此当二者无论谁操作都会引起内存中值的变化
        names1 = names2;
        System.out.println(names1[0]);//大明

        names1[1] = "唐三";
        System.out.println(names2[1]); //唐三
    
}

6.数组的遍历、最值、逆序

public static void main(String[] args) {
        /*
            TODO 数组常见操作:
                1.数组遍历
         */

//      TODO 1.数组遍历
        int numArr[] = {1, 2, 3, 3, 2, 1, 4, 5, 6};

        // numArr.length 表示数组的长度
        for (int i = 0; i < numArr.length; i++) {
            // 遍历所有的下标,根据下标进行取数据
            System.out.println("获取到数据:" + numArr[i]);
        }
        System.out.println("+++++++++++分割+++++++++++");
        int index = 0;
        while (index < numArr.length) {
            System.out.println("获取到数据:" + numArr[index]);
            index++;
        }
        System.out.println("+++++++++++分割+++++++++++");
        // TODO 注意: 增强for遍历数据
        // 每次循环都直接取出 数组中的元素
        for (int elem : numArr) {
            System.out.println("获取到数据:" + elem);
        }


        /*
           TODO  数组获取最值(获取数组中的最大值最小值)
         */
        int max = numArr[0];
        int min = numArr[0];
        for (int elem : numArr) {
            max = elem > max ? elem : max;
            min = elem < min ? elem : min;
        }
        System.out.println("max:"+max);
        System.out.println("min:"+min);

        /*
           TODO 数组元素逆序 (就是把元素对调)
         */

        for (int i = 0; i < numArr.length / 2; i++) {
            
            int tmpNum = numArr[i];
            numArr[i] = numArr[numArr.length - i - 1];
            numArr[numArr.length - i - 1] = tmpNum;
        }
        System.out.println("====================分割====================");
        for (int elem : numArr) {
            System.out.println("获取到数据:" + elem);
        }



    }

7.二维数组

 public static void main(String[] args) {
        /*
            TODO 二维数组
                格式1
                    数据类型[][] 变量名 = new 数据类型[m][n];
                格式2:
                    数据类型[][] 变量名 = new 数据类型[m][];
                格式3
                    数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}};
                    数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};


                二维数组 赋值及取值 => 变量名[一维下标][二维下标]
         */
        String[][] allClassStu = new String[30][40];
        // 当直接使用变量名[] 可以取出一个维度中的数组
        String[] oneClassStu = allClassStu[1];
        oneClassStu[0] = "张三";
        oneClassStu[1] = "李四";

        System.out.println(oneClassStu[0]);
        System.out.println(oneClassStu[1]);
        System.out.println(allClassStu[1][0]);


        // 对于每个班级的学生人数不一样
        String[][] allClassStu2 = new String[30][];
        String[] oneClassStu2 = allClassStu2[29];
//        oneClassStu2[0] = "王五"; // java.lang.NullPointerException => 变量调用的内存地址为null 空
//        System.out.println(allClassStu2[29][0]);
        /*
            TODO  NullPointerException 问题
                由于 new String[30][]; 定义时,对于第二个维度没有定义长度=> 没有进行实例化
                allClassStu2 变量中 第一个维度中的数组 长度为 30 每个元素 为null
         */

        // TODO 重新创建一个字符串数组 其长度为 22 将其内存地址 赋予给 allClassStu2 变量的第29个下标的位置
        allClassStu2[29] = new String[22];
        allClassStu2[29][0] = "邱六";
        System.out.println(allClassStu2[29][0]);


        int[][] allInt = {{1, 2, 4}, {2, 3, 4}, {2, 3, 4}};
        // 双循环遍历二维数组中的所有数据
        for (int i = 0; i < allInt.length; i++) {
            for (int index = 0; index < allInt[i].length; index++) {
                System.out.println(allInt[i][index]);
            }
        }
     

        int[][] allSalary = {
                {22, 66, 44}
                , {77, 33, 88}
                , {25, 45, 65}
                , {11, 66, 99}
        };

        //增强for循环遍历二维数组
        int sum = 0;
        for (int[] oneArr : allSalary) {
            for (int elem : oneArr) {
                sum += elem;
            }
        }
        System.out.println("sum:" + sum);
     
 }

原文地址：https://blog.csdn.net/m0_58050808/article/details/137935062

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！