【Java基础】循环、嵌套、跳转控制break/continue、调试器、函数

最新推荐文章于 2024-04-30 22:23:54 发布

繁花郁晴

最新推荐文章于 2024-04-30 22:23:54 发布

阅读量286

点赞数

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

本文链接：https://blog.csdn.net/qq_43520842/article/details/126362285

版权

java基础专栏收录该内容

17 篇文章 1 订阅

订阅专栏

1.循环语句

1.1 while

● 循环语句功能：
在循环条件满足的情况下，反复执行特定代码
●循环语句的四个组成部分
初始化部分(init_ statement)
循环条件部分(test_ exp )
循环体部分( body_ statement)
迭代部分( alter_ statement)
●循环语句分类
for循环
while循环
do/while 循环

1.1.1 格式

while(表达-判断){
        循环体语句;
}

1.1.2 例子

实现从1到10 的阶乘并打印结果。

public class Main {
    public static void main(String[] args) {
//计算1-10的阶乘，并打印结
        int n = 1;
        while(n<=10){
            int i = 1,sum = 1;
            while(i<n){
                sum = sum*i;
                i++;
            }
            System.out.println(n+"的阶乘是"+sum);
            n++;
        }
    }
}

1.2 do-while

1.2.1 格式

do
{
   循环体语句
}while(表达式-判断);

1.2.2 例子

用do-while实现用Scanner输入一个数据，并将这个数据打
印出来，如果这个数字小于100的话继续输入，如果大于等
于100的话退出。

import java.util.Scanner;
public class Main{
   public static void main (String[] args){
// 用do-while实现用Scanner输入一 个数据，并将这个数据打
//印出来，如果这个数字小于100的话继续输入，如果大于等
//于100的话退出。
       Scanner sc = new Scanner(System.in);
       int n;
       do{
           System.out.println("请输入数字（大于等于100会退出）：");
           n = sc.nextInt();
       }while(n<100);
   }
}

1.3 for

for比while更灵活、功能性更强。

1.3.1 格式

for(e1;e2;e3){
s;//循环体语句
}

1.3.2 例子

1.用for语句实现从1到100的和，并打印结果。
2.用for语句实现1到10的阶乘，并打印结果。

public class Main{
    public static void main(String[] args){
// 1.用for语句实现从1到100的和，并打印结果。
        int sum = 0;
        for(int i=0;i<100;i++){
            sum+=i;
        }
        System.out.println("0-100的和是："+sum);
    }
}

public class Main{
    public static void main(String[] args){
//        用for实现1-10的阶乘并打印结果
        for(int n=1;n<=10;n++){
            int sum = 1;
            for (int i=1;i<=n;i++){
                sum*=i;
            }
            System.out.println(n+"的阶乘是："+sum);
        }
    }
}

1.4 循环的嵌套

1.4.1 格式

while(){
    while(){
    }
}

for(;;){
    for(;;){
    }
}

1.4.2 例子

public class Main{
    public static void main(String[] args){
        for (int i=0;i<4;i++){
            for(int j=0;j<=i;j++){
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

在这里插入图片描述

public class Main{
    public static void main(String[] args){
        for (int i=0;i<4;i++){
          for (int j=0;j<4;j++){
              if (j>=3-i){
                  System.out.print("*");
              }else{
                  System.out.print(" ");
              }
          }
          System.out.println();
        }
    }
}

在这里插入图片描述

public class Main{
    public static void main(String[] args){
        for (int i=0;i<4;i++){
          for (int j=0;j<4;j++){
              if (j<=3-i){
                  System.out.print("*");
              }else{
                  System.out.print(" ");
              }
          }
          System.out.println();
        }
    }
}

在这里插入图片描述

public class Main{
    public static void main(String[] args){
        for (int i=0;i<4;i++){
          for (int j=0;j<4;j++){
              if (j<=2-i){
                  System.out.print(" ");
              }else{
                  System.out.print("*");
              }
          }
          System.out.println();
        }
    }
}

在这里插入图片描述

2.跳转控制语句

2.1 break

① 可以在switch语句当中终止一个case

switch(表达式){
    case 常量1:
        语句;
        break;//遇见break 直接跳出 执行循环体外语句      
    default：
        语句;
}
循环体外语句;

例子

public class Main{
    public static void main(String[] args){
        int n=1; //输出: 玩游戏
        n=2;//输出： 跳舞 打球 唱歌 写作业 做的很棒可以吃饭
        switch(n){
            case 1:
                System.out.println("玩游戏");
                break;
            //注意不加break的分支，匹配到之后会顺序执行所有语句。
            case 2:
                System.out.println("跳舞");
            case 3:
                System.out.println("打球");
            case 4:
                System.out.println("唱歌");
            case 5:
                System.out.println("写作业");
            default:
                System.out.println("做的很棒可以吃饭");

        }
    }
}

②可以越过常规条件测试，立即强制制止循环（while，for）

while(表达式-判断){
    循环体语句;
    if(...)
        break;//遇见break直接跳出循环        
    循环体语句;//满足if条件 这些不再执行
}

例子

public class Main{
    public static void main(String[] args){
        int n=5,sum=0;
        for(int i=0;i<n;i++){
            sum+=i;
            if (sum>5)
                break;
        }
        System.out.println(sum);//6=0+1+2+3
    }
}

2.2 continue

continue跳过剩余代码，强制开始下一轮循环。不是跳出循环强制退出。

while(表达式-判断){
    循环体语句;
    if(....)
        continue;
    循环体语句;//被跳过 然后执行洗一次循环。    
}

public class Main{
    public static void main(String[] args){
        int i=2;
        while(i<7){
            System.out.println(i);
            i++;
            if (i==6) {
                continue;
            }
            System.out.println("可以通行");

        }
        /*运行结果：
        2
        可以通行
        3
        可以通行
        4
        可以通行
        5
        6
        可以通行*/
    }
}

2.3 break to

break to 跳转语句可以跳转到本代码块的任意位置。但是它需要一个标号（在java语言中，后跟冒号是标识符）。而且break to只能在标识其内部时，跳转到表示处。
break to 语句一般用于跳出多层循环，或跳转到其他代码块。

there:循环体外语句;
while(表达式-判断){
    循环体语句；
    if(...)
        break there;//there为指向某一语句的标号
    循环体语句：//被跳过。
}

例子

public class Main{
    public static void main(String[] args){
//        1.选择一种循环结构，结合continue，实现1到100的和，但
//        其中不包含10到20,80到90这些数字。
        int sum = 0;
        for(int i=1;i<=100;i++){
            if((i>=10&&i<=20)||(i>=80&&i<=90))
                continue;
            sum+=i;
        }
        System.out.println(sum);//5050 3950
    }
}

public class Main{
    public static void main(String[] args){
//        2.编写一个双层for循环:
//        for(i=0; i< 10; i++)
//            for(j=0;j< 10; j++)
//                完成:内层循环体求i和j的积并打印。若i等于7且j等于9时，退出循环体。
        for(int i=0;i<10;i++){
            System.out.println();
            for(int j=0;j<10;j++){
                System.out.print(i*j+" ");
                if (i==7&&j==9){
                    break;
                }
            }
        }

    }
}

3. 调试器的基本使用

我们在代码较为复杂时，很难通过观察代码来判断某一时刻下的程序状态(某个变量的值)。因此，我们需要通过“调试”的手段，来在运行时查看程序的变化。

3.1 设置断点

在myeclipse和eclipse中，可以在某一行代码的左边栏双击添加一个断点。也可以在左边栏点击右键添加断点
也可以让光标位于某一行时，直接使用快捷键: Ctrl+Shift+B来设置或取消断点。但需注意，此快捷键会与某些输入法冲突，需先关闭输入法再使用。

3.2 进入调试模式

在myeclipse和eclipse中，我们在左边“包浏览器”导航中，源文件或项目上点击右键，选择“Debug as"，选中相应的调试类型，即可进入调试模式

4. 函数（方法）

4.1 格式

函数（也成为方法method）是面向过程程序设计中，对功能的抽象。
在java中，函数是封装在类体内的，分为静态函数（类函数）和实例函数（实例方法）。

//返回类型标识符：若无返回值，写void 
//形式参数： 是被初始化的内部变量，寿命和可见性仅限于函数内部。
返回类型标识符 函数名(形式参数表){
    语句序列
}

4.2 函数编写及调用

无返回值函数

void fun1(int a){
    println("there is func1，parameter is"+a)
    return;//可省略
}
...
func1(x)

有返回值函数：

int func2（int a,int b）
{
    return a+b;
}
....
int sum,a=1,b=2;
sum = fun2(a,b);

例子

public class Main {
    public static void main(String[] args) {
//        1基蛋写-个函数， 功能是求出3个数的最大值，并用程序验
//        证结果。
//        函数原型为: int max(int a, intb, intc)
//        2.写个函数， 求出3个数的最小值。
//        函数原型为: int minint a, int b, intec)
        int a = 4, b = 5, c = 6;
        System.out.println(max(a, b, c));
        System.out.println(min(a,b,c));
    }

    static int max(int a, int b, int c) {
        int max;
        max = Math.max(c, Math.max(a, b));
        return max;
    }


    static int min(int a, int b, int c) {
        int min;
        min = Math.min(c, Math.min(a, b));
        return min;
    }
}

4.3 函数的嵌套调用

函数声明：

int func1(int a, int b){
    return a+b;
}

int func(int a,int b,int c){
    return c+func1(a+b);
}
//函数调用
void main(){
    int x=1,y=2,z=3;
    println("sum is"+func2(x,y,z));
}

public class Main {
    public static void main(String[] args) {
        int x=1,y=2,z=3;
        System.out.println("sum is "+func2(x,y,z));
    }
    static int func1(int a, int b){
        return a+b;
    }
    static int func2(int a,int b,int c){
        return c+func1(a,b);
    }
}

写3个函数，函数1为返回3个数中最小值与最大值的乘积。
函数2为返回三个数中的最大值。
函数3为返回三个数中的最小值.
要求:在函数1中调用函数2和函数3，返回两个函数结果的

public class Main {
    public static void main(String[] args) {
        int x=1,y=2,z=3;
        System.out.println("sum is "+minandmax(max(x,y,z),min(x,y,z)));
    }
    static int max(int a,int b,int c){
        return Math.max(a,Math.max(b,c));
    }
    static int min(int a,int b,int c){
        return Math.min(a,Math.min(b,c));
    }
    static int minandmax(int a,int b){
        return a*b;
    }
}

4.4 函数递归调用

函数声明：

int sigma(int X){
    if(x==1)
        return 1;
    return x+sigma(x-1);
}

函数调用：

void main(){
    int a = sigma(8);
    printf("8's sigma is:%d\n",a);
}

参照上述函数递归调用求1-100的和示例代码，完成求1-10的
函数原型为: int factorial(int x);

public class Main {
    public static void main(String[] args) {
        System.out.println("10的阶乘是："+factorial(10));
    }
    static int factorial(int x){
        if(x==1)
            return 1;
        return x*factorial(x-1);
    }
}