day06 循环结构补充和方法

Libra_97

已于 2022-09-14 21:33:54 修改

阅读量98

点赞数

分类专栏： javase 文章标签： java 开发语言

于 2022-09-06 20:48:24 首次发布

本文链接：https://blog.csdn.net/Libra_97/article/details/126733512

版权

javase 专栏收录该内容

22 篇文章 0 订阅

订阅专栏

循环结构补充和方法

1. break关键字补充

1.循环中存在switch，switch中的break只作用于switch，不会对循环产生影响

2.双重循环中，break只针对离当前break关键字最接近的循环产生作用

3.我们可以通过定义标记: 例如 a1: 这种方式来指定break跳出的循环

package com.atguigu.test1;

/**
 * 循环中存在switch，break关键字的效果
 * */
public class Test1 {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++){
            switch (i){
                case 1:
                    System.out.println("第1次打印switch中i的取值为：" + i);
                    break;
                case 2:
                    System.out.println("第2次打印switch中i的取值为：" + i);
                    break;
            }
            System.out.println("for循环打印i的取值为：" + i);
        }
        System.out.println("----------------------------------------");

        for (int i = 1; i <= 5; i++){
            for (int j = 1; j <= 5; j++){
                System.out.println("第" + i + "轮打印循环j的取值为：" + j);
                if (j == 3){
                    break;
                }
            }
        }
        System.out.println("----------------------------------------");

        // 中断外层循环
        a1 : for(int i = 1;i <= 5; i++){
            for (int j = 1;j <= 5; j++){
                System.out.println("第" + i + "轮打印循环j的取值为：" + j);
                if (j == 3){
                    break a1;
                }
            }
        }
        System.out.println("程序结束");

    }
}

2.局部变量

局部变量存储位置

局部变量	描述
定义位置	定义在方法中
作用范围	离当前变量最近的大括号以内
默认值	没有默认值必须先赋值才能使用
重名问题	在重合的作用范围以内不能重名
存储位置	基本数据类型全部存在栈(stack)中，引用数据类型名字在栈，值在堆(heap)
生命周期	随着方法的入栈(压栈)而生效随着方法的出栈(弹栈)而死亡

package com.atguigu.test1;
/**
 * 局部变量：书写在方法中的变量都属于局部变量(目前所使用的都是局部变量)
 *      定义变量：定义在方法中
 *      作用范围：在定义行开始的结构代码块以内 / 离当前变量最近的大括号以内
 *      默认值：没有默认值 必须先赋值才能使用
 *      重名问题：在重合的作用范围以内不能重名
 *
 *      存储位置：基本数据类型全部存在栈(stack)中，引用数据类型名字在栈，值在堆(heap)
 *      生命周期：随着方法的入栈(压栈)而生效 随着方法的出栈(弹栈)而死亡
 * */

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

        String str1 = new String("abc");

        int a = 10;
        int b;
        System.out.println(a);  // 10
        b = 100;
        System.out.println(b);  // 100

//        int a = 200;  // 不能重复定义同一个变量

        if (b > 50){
//            int a = 200;  // 不能重复定义同一个变量
            int c = 200;
            System.out.println(a);  // 10
            System.out.println(b);  // 100
            System.out.println(c);  // 200
        }else{
            int c = 500;
            System.out.println(c);  // 500
        }

//        System.out.println(c);  // 报错 无法调用if结构中的局部变量
    }
}

方法

1. 方法的概念

方法是一系列代码指令的集合，用于解决特定的问题，可以反复调用

2. 定义语法

public static void 方法名(){

// 方法体

}

3. 定义位置

与main方法平级并列关系

4. 方法的调用

在需要调用方法的位置直接书写方法名()即可。

5. 方法的使用

5.1 使用方法优化诗句打印

package com.atguigu.test2;
/**
 * 以现有知识打印诗句
 * */
public class Test1 {
    public static void main(String[] args) {

        System.out.println("床前明月光");
        System.out.println("----------");

        System.out.println("疑是地上霜");
        System.out.println("----------");

        System.out.println("举头望明月");
        for (int i = 1;i <= 10; i++){
            System.out.print("-");
        }
        System.out.println();

        System.out.println("低头思故乡");
        for (int i = 1;i <= 10; i++){
            System.out.print("-");
        }

    }
}

debug模式点击step into可以进入到方法体内部查看方法执行过程

package com.atguigu.test2;
/**
 * 使用方法优化Test1.java
 * */
public class Test2 {
    public static void main(String[] args) {

        System.out.println("床前明月光");
        printSign();

        System.out.println("疑是地上霜");
        printSign();

        System.out.println("举头望明月");
        printSign();

        System.out.println("低头思故乡");
        printSign();

    }

    public static void printSign(){
        System.out.println("----------");
    }
}

5.2 使用单个参数优化诗句打印

使用单个参数完善com.atguigu.test2.Test2.java 实现可以让用户/调用者灵活的指定横线的个数

package com.atguigu.test3;
/**
 * 使用单个参数完善com.atguigu.test2.Test2.java  实现可以让用户/调用者灵活的指定横线的个数
 * */

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

        System.out.println("床前明月光");
        printSign(6);

        System.out.println("疑是地上霜");
        int num = 6;
        printSign(num);

        System.out.println("举头望明月");
        int b = 5;
        int c = 6;
        int sum = b + c;

//        printSign(b + c);  // 不推荐 阅读性差
        printSign(sum);

        System.out.println("低头思故乡");
        printSign(8);

    }

    /**
     * num属于形参(形式参数)：在定义方法的时候书写的参数，称之为形式参数
     * 形参规定了参数的个数、类型、顺序，要求实参必须遵守这个规定
     * @param num
     */
    public static void printSign(int num){
        for (int i = 1;i <= num; i++){
            System.out.print("-");
        }
        System.out.println();
    }
}

5.3 使用多个参数优化诗句打印

使用多个参数实现可以让用户灵活的指定符号的类型以及符号的个数

package com.atguigu.test3;

/**
 * 使用多个参数实现可以让用户灵活的指定符号的类型 以及 符号的个数
 * */
public class Test2 {
    public static void main(String[] args) {
        System.out.println("床前明月光");
        printSign(6, "*");

        System.out.println("疑是地上霜");
        printSign(8, "+");

        System.out.println("举头望明月");
        printSign(10, "-");

        System.out.println("低头思故乡");
        printSign(12, "/");

    }


    public static void printSign(int num, String sign){
        for (int i = 1; i <= num; i++){
            System.out.print(sign);
        }
        System.out.println();
    }
}

6. return关键字

return关键字表示结束方法并且返回内容

方法定义的时候，如果返回值类型书写不是void，那么必须使用return关键字返回一个对应类型的数据

package com.atguigu.test4;

/**
 * 编写方法用于计算两个数之和 再在main方法判断最终的结果属于奇数 还是 偶数
 * */

public class Test1 {

    /**
     * void 空的 无效的 在方法定义时书写void 表示此方法没有返回值
     * @param numa
     * @param numb
     */
    public static void add(int numa, int numb){
        System.out.println("两个数之和是：" + (numa + numb));  // 两个数之和是：30
    }

    /**
     * int 书写方法返回值为int 表示此方法执行完毕将返回给调用者一个int类型的数据
     * return关键字表示结束方法 并且 返回内容 return之后加上具体返回的数据 必须和定义的返回值类型匹配
     * @param a
     * @param b
     * @return
     */
    public static int plus(int a, int b){
        int sum = a + b;
        return sum;
    }

    public static void main(String[] args) {
        add(10, 20);
        if (30 % 2 == 0){
            System.out.println("偶数");  // 偶数
        }else {
            System.out.println("奇数");
        }
        System.out.println("-----------------------");

        int sum = plus(10, 20);
        if (sum % 2 != 0){
            System.out.println("奇数");
        }else {
            System.out.println("偶数");  // 偶数
        }

        System.out.println("-----------------------");

        System.out.println(plus(10, 20));  // 30

    }
}

6.1 return具体使用1

return关键字表示结束方法并且返回内容所以return关键字之后不能写代码

package com.atguigu.test5;
/**
 * return关键字表示结束方法并且返回内容 所以return关键字之后不能写代码
 * */
public class Test1 {
    public static String m1(String str1, String str2){
        return str1 + str2;
//        System.out.println("hello");  // return之后的代码执行不到
    }
}

6.2 return具体使用2

如需在分支结构中使用return关键字返回内容那么必须保证每一条分支都有正确的返回值

package com.atguigu.test5;

/**
 * 如需在分支结构中使用return关键字返回内容 那么必须保证每一条分支都有正确的返回值
 * */
public class Test2 {

    public static String testNum(int num){
        if (num % 2 == 0){
            return "偶数";
        }
        return "奇数";
    }

    public static boolean isEven(int num){
        if (num % 2 == 0){
            return true;
        }
        return false;
    }

    public static boolean isEven1(int num){
        return num % 2 == 0 ? true : false;
    }

    public static int isEven2(int num){
        if (num % 2 == 0){
            return 0;
        }
        return 1;
    }

    public static int isEven3(int num){
        return num % 2;
    }

    public static void main(String [] args){
        System.out.println(isEven(5) ? "偶数" : "奇数");  // 奇数
        System.out.println(isEven(5) == true ? "偶数" : "奇数");  // 奇数
    }
}

6.3 return具体使用3

在返回值类型为void的方法中书写return只表示结束方法 return关键字之后不能有任何内容

package com.atguigu.test5;

/**
 * 在返回值类型为void的方法中 书写return只表示结束方法 return关键字之后 不能有任何内容
 * */
public class Test3 {

    public static void m1(){
        for (int i = 1; i <= 10; i++){
            if (i == 5){
                return;  // break  注意这两个的区别 return结束方法 break结束循环
            }
            System.out.println(i);
        }
        System.out.println("m1方法执行完毕");
    }

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

7.方法之间调用

方法进栈出栈

方法与方法之间的调用

栈：方法必须进栈才会执行栈属于一种数据结构类似于桶先进后出 FILO First In Last Out

package com.atguigu.test7;

/**
 * @author WHD
 * @description TODO
 * @date 2022/9/6 15:41
 *  方法与方法之间的调用
 *  栈：方法必须进栈才会执行 栈属于一种数据结构 类似于桶 先进后出  FILO First In Last Out
 */
public class Test2 {


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


    public static void m1(){
        System.out.println("m1 method start****************");
        m2();
        System.out.println("m1 method end****************");
    }

    public static void m2() {
        System.out.println("m2 method start");
        System.out.println("m2 method end");
    }


}

8.返回值类型的自动提升

package com.atguigu.test6;

/**
 * 自动提升 手动下降
 * 返回值的类型提升 依然遵循之前讲解的类型提升规则
 * */
public class Test1 {
    public static double m1(){
        int a = 20;
        return a;
    }

    public static void main(String[] args) {
        System.out.println(m1());  // 20.0
    }
}

9. 递归

递归(递进和回归)：可以简单的理解为自己调自己

递归用于解决一些特定的问题，这些问题的特点是：一个大的问题，可以拆分为若干个小的问题

比如：我们求 1~5之间的和

举例：赵四找广坤要100 ====》广坤找大拿要100 ====》大拿找小宝要100

递归的两个重要因素：

1.当前问题可以拆分为若干个小的问题

2.递归必须有正确的出口 (否则将产生无穷递归/死循环)

package com.atguigu.test6;

/**
 * 递归(递进和回归)：可以简单地理解为自己掉自己
 * 递归用于解决一些特定的问题，这些问题的特点是：一个大的问题，可以拆分为若干个小的问题
 *
 * 比如：我们求1~5之间的和
 * 举例：赵四找广坤要100  ====》 广坤找大拿要100  ====》 大拿找小宝要100
 *
 * 递归的两个重要元素：
 *  1.当前问题可以拆分为若干个小的问题
 *  2.递归必须有正确的出口(否则将产生无穷递归/死循环)
 * */

public class Test3 {

    public static void m1(){
        m1();
    }

    public static int m2(){
        return 10 + m3();
    }

    public static int m3(){
        return 10;
    }

    public static void main(String[] args) {
        System.out.println(m2());  // 20

        System.out.println(getNum(5));  // 15

        System.out.println(getNum5(5));  // 15
    }

    public static int getNum(int num){
        if (num == 1){
            return 1;
        }else {
            return num + getNum(num - 1);
        }
    }

    public static int getNum5(int num){
        return num + getNum4(num - 1);
    }

    public static int getNum4(int num){
        return num + getNum3(num - 1);
    }

    public static int getNum3(int num){
        return num + getNum2(num - 1);
    }

    public static int getNum2(int num){
        return num + getNum1(num - 1);
    }

    public static int getNum1(int num){
        return num;
    }

}

package com.atguigu.test6;

/**
 * 求n的阶乘
 * */
public class Test4 {
    public static int factorial(int num){
        if (num == 1 || num == 0){
            return 1;
        }else {
            return num * factorial(num - 1);
        }
    }

    public static void main(String[] args) {
        System.out.println(factorial(5));  // 120
    }
}

10. 方法重载 Overload

同一个类或者父子类中，方法名相同，参数列表不同(包括参数的个数、类型、顺序)有一个不同，即可称之为不同，这种现象称之为方法重载(跟返回值，访问权限修饰符无关)

package com.atguigu.test7;

/**
 * 编写方法实现多个数加法计算
 * */
public class Test1 {

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

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

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

    public static void add(int a, int b, int c){
        System.out.println(a + b + c);
    }

    public static void add(int a, int b, int c, int d){
        System.out.println(a + b + c + d);
    }

    public static double add(int a, int b, int c, int d, int e){
        return a + b + c + d + e;
    }

    public static void main(String[] args) {
        add(10, 20, 30);  // 60

        System.out.println(add("abc", 20));  // 100
    }
}

11.方法相关练习

package com.atguigu.test8;
/**
 * 练习
 * */
public class Test1 {

    public static void main(String[] args) {
        System.out.println(add(2, 3));  // 5

        getDivisor(16);

        getSum(5);  // 15

        printString(5);

        getNumberLength(23434523);

        getNum();
    }

    // 1.写一个函数add，接收两个整数作为参数，返回这两个整数的和
    public static int add(int n1, int n2){
        return n1 + n2;
    }

    // 2.写一个函数，接收一个整数，输出这个整数的所有因子
    public static void getDivisor(int num){
        for (int i = 1; i <= num; i++){
            if (num % i == 0){
                System.out.println(i);
            }
        }
    }

    // 3.写一个函数，接收一个整数n，输出1+2+3+...+n的和
    public static void getSum(int n){
        int sum = 0;
        for (int i = 1; i <= n; i++){
            sum += i;
        }
        System.out.println(sum);
    }

    // 4.写一个函数，接收一个整数n，输出n个HelloWorld
    public static void printString(int n){
        for (int i = 1;i <= n; i++){
            System.out.println("HelloWorld");
        }
    }

    // 5.写一个函数，接收一个整数，输出这个整数是几位数
    public static void getNumberLength(int n){
        int count = 1;
        while (n > 10){
            count++;
            n /= 10;
        }
        System.out.println(count);
    }

    // 6.求一个三位数，该三位数等于每位数字的阶乘之和
    public static void getNum(){
        int a, b, c;
        for (int i = 100; i <= 999; i++){
            a = i / 100;
            b = i / 10 % 10;
            c = i % 10;
            if (i == factorial(a) + factorial(b) + factorial(c)){
                System.out.println(i);
            }
        }
    }

    public static int factorial(int num){
        int sum = 1;
        for (int i = 1; i <= num; i++){
            sum *= i;
        }
        return sum;
    }

}