Java中的循环结构（while）、方法

最新推荐文章于 2024-02-27 00:31:00 发布
最新推荐文章于 2024-02-27 00:31:00 发布
阅读量1.2k 收藏
点赞数 2
分类专栏： Java专栏。 文章标签： java 算法 rust
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/l_dsj/article/details/119061306
版权
本文详细介绍了Java中的循环结构，包括while和do...while循环的使用，以及如何通过循环实现特定功能。同时，讨论了跳转控制语句，如break和continue的场景和作用。此外，还探讨了方法的概念、定义及其在程序中的应用，并提到了方法的重载。文章通过实例代码加深了读者对这些概念的理解。
摘要由CSDN通过智能技术生成

今天涉及的内容是有关流程控制语句、跳转控制语句、数组的定义、Java中的内存分配部分的内容。

循环结构

（while循环语句）

while循环语句的基本格式：
基本格式：
while(判断条件语句){
循环体语句;
}
扩展格式：
while(判断条件语句){
循环体语句;
控制条件语句;
}

范例1：

public class WhileDemo1 {
    public static void main(String[] args) {
        System.out.println("HelloWorld");
        System.out.println("HelloWorld");
        System.out.println("HelloWorld");
        System.out.println("*************使用for循环改进********************");
        for(int i=1;i<=3;i++){
            System.out.println("HelloWorld");
        }
        System.out.println("***********使用while循环改进*****************");
        int i = 0;
        while(i<3){
            System.out.println("HelloWorld");
            i++;
        }
    }
}
//HelloWorld
//HelloWorld
//HelloWorld
//*************使用for循环改进********************
//HelloWorld
//HelloWorld
//HelloWorld
//***********使用while循环改进*****************
//HelloWorld
//HelloWorld
//HelloWorld

范例2

/*
            用while循环实现1-100之和
            注意：for循环与while循环之间的小区别：
                1、使用区别：控制条件语句所控制的那个变量，在for循环结束后，就不能再被访问到了，
                    而while循环结束还可以继续使用，如果你想继续使用，就用while，否则推荐使用for。
                    原因是for循环结束，该变量就从内存中消失，能够提高内存的使用效率。
                2、场景区别：
                    for循环适合针对一个范围判断进行操作
                    while循环适合判断次数不明确操作
 */
public class WhileDemo2 {
    public static void main(String[] args) {
        int sum = 0;
        for(int i=1;i<=100;i++){
            sum += i;
        }
        System.out.println("1-100的和为："+sum);
        System.out.println("**********************使用while循环进行改进*********************");
        int i =1;
        sum = 0;
        while(i<=100){
            sum+=i;
            i++;
        }
        System.out.println("1-100的和为："+sum);
    }
}
//1-100的和为：5050
//**********************使用while循环进行改进*********************
//1-100的和为：5050

范例3：

public class WhileDemo3 {
    public static void main(String[] args) {
        int maxHeight = 884800;
        int count = 0;//定义的是总的折叠次数
        int thick = 1;//定义的是厚度
        while(thick<=884800){
            thick *= 2;
            count++;
        }
        System.out.println("折叠"+count+"次到8848米，"+"厚度为："+thick);
    }
}
//折叠20次到8848米，厚度为：1048576

循环结构（do…while循环语句）

do…while循环语句格式：
基本格式：
do{
循环体语句;
}while(判断条件语句);
扩展格式：
do{
循环体语句;
控制条件语句;
}while(判断条件语句);

范例1：

public class DoWhileDemo1 {
    public static void main(String[] args) {
        //求1-100的和
        int i = 0;//定义的是循环的次数
        int sum = 0;//定义的是总和
        do{
            sum+=i;
            i++;
        }while(i<=100);
        System.out.println("1-100的和为："+sum);
    }
}
//1-100的和为：5050


 3. 跳转控制语句
 主要有三个跳转语句：
 	break	中断
 	continue	继续
 	return	返回

break：
	使用场景：
            1、在选择结构switch语句中
            2、在循环语句中，加入了if判断的情况
            3、离开使用场景的存在是没有意义的


范例1：

```c
import java.util.Scanner;
public class ControlDemo1 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你想要的星期的数字（1-7）");
        int num = sc.nextInt();
        //break跳出当前控制语句
        switch (num){
            case 1:
                System.out.println("星期一");
                break;
            case 2:
                System.out.println("星期二");
                break;
            case 3:
                System.out.println("星期三");
                break;
            default:
                System.out.println("程序没有匹配");
                break;
        }
        System.out.println("*********************************");
        //循环打印1-10，加入break，并在3的时候停止for循环
        for(int i=1;i<=10;i++){
            if(i==3){
                break;
            }
            System.out.println(i);
        }
    }
}

循环中break的作用：

跳出单层循环：
跳出多层循环：
带标签的跳出：
格式：标签名: 循环语句
范例2：

public class ControlDemo2 {
    public static void main(String[] args) {
        for(int i=1;i<=9;i++){
            for(int j=1;j<=i;j++){
                System.out.print(i+"*"+j+"="+(i*j)+'\t');
            }
            System.out.println();
        }

        System.out.println("*******加入break循环*********");

        for(int i=1;i<=9;i++){
            for(int j=1;j<=i;j++){
                if(j==4){
                    break;
                }
                System.out.print(i+"*"+j+"="+(i*j)+"\t");
            }
            System.out.println();
        }

        System.out.println("*****加入break带标签跳出多层循环******");
        wc:for(int i=1;i<=9;i++){
            nc:for(int j=1;j<=i;j++){
                if(j==4){
                    break wc;
                }
                System.out.print(i+"*"+j+"="+(i*j)+"\t");
            }
            System.out.println();
        }

    }
}
1*1=1	
2*1=2	2*2=4	
3*1=3	3*2=6	3*3=9	
4*1=4	4*2=8	4*3=12	4*4=16	
5*1=5	5*2=10	5*3=15	5*4=20	5*5=25	
6*1=6	6*2=12	6*3=18	6*4=24	6*5=30	6*6=36	
7*1=7	7*2=14	7*3=21	7*4=28	7*5=35	7*6=42	7*7=49	
8*1=8	8*2=16	8*3=24	8*4=32	8*5=40	8*6=48	8*7=56	8*8=64	
9*1=9	9*2=18	9*3=27	9*4=36	9*5=45	9*6=54	9*7=63	9*8=72	9*9=81	
*******加入break循环*********
1*1=1	
2*1=2	2*2=4	
3*1=3	3*2=6	3*3=9	
4*1=4	4*2=8	4*3=12	
5*1=5	5*2=10	5*3=15	
6*1=6	6*2=12	6*3=18	
7*1=7	7*2=14	7*3=21	
8*1=8	8*2=16	8*3=24	
9*1=9	9*2=18	9*3=27	
*****加入break带标签跳出多层循环******
1*1=1	
2*1=2	2*2=4	
3*1=3	3*2=6	3*3=9	
4*1=4	4*2=8	4*3=12

循环中的continue：

使用场景：
1、在循环语句中
2、离开使用场景的存在是没有意义的
return：
结束循环其实是结束了main方法

范例：

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

        //循环打印1-10，加入continue
        for(int i=1;i<=10;i++){
            if(i==3){
                continue;//跳出当前此次循环，继续后面循环
            }
            System.out.println(i);
        }//在这里面 3 就被抽走了

        System.out.println("********改为return*********");

        for(int i=1;i<=10;i++){
            if(i==3){
                return;
            }
            System.out.println(i);
        }
    }
}
//1
//2
//4
//5
//6
//7
//8
//9
//10
//********改为return*********
//1
//2

方法

什么是方法：

方法就是完成特定功能的代码块
在很多语言里面都有函数的定义
函数在Java中被称为方法

方法的语句格式：

修饰符 返回值类型 方法名(参数类型 参数名1，参数类型 参数名2…) {
函数体;
return 返回值;
}

一些方法中的名词解释：

修饰符

修饰符 比较多，后面会详细介绍。目前public static
返回值类型：
就是return返回的值的类型
方法名：
一个名称，为了方便我们调用方法，自己起的名字，方便我们调用。

参数：

1、形参
定义在方法上的参数名
2、实参
实际调用方法的时候传入的值

参数类型：

限定调用方法时传入参数的数据类型

参数名：（形参）

是一个变量，接收调用方法时传入的参数。

函数体：

完成功能的代码，实现方法的主要逻辑功能

return：

结束方法以及返回方法指定类型的值

返回值：

程序被return带回的结果，返回给调用者
注意：
方法与方法是平级，不能嵌套使用。

范例：

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

        int x = 10;
        int y = 20;

        int result = sum(x,y);
        System.out.println(result);
    }

    public static int sum(int x,int y){
        int result = x+y;
        return result;
    }

}
//30

FunctionDemo1图解：
在这里插入图片描述

范例：

import java.util.Scanner;
public class FunctionDemo3 {
    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        System.out.println("请输入行数");
        int x = sc.nextInt();
        System.out.println("请输入列数");
        int y = sc.nextInt();

        printStar(x,y);

    }

    public static void printStar(int a,int b){
        for(int i=1;i<=a;i++){
            for(int j=1;j<=b;j++){
                System.out.print("*"+"\t");
            }
            System.out.println();
        }
    }
}
//请输入行数
//4
//请输入列数
//5
//* 	*	*	*	*
//*	    *	*	*	*
//*	    *	*	*	*
//*	    *	*	*	*

方法的重载

什么是方法的重载：

在同一个类中，允许存在一个以上的同名方法，
只要它们的参数个数或者参数类型不同即可。

方法重载的特点：

1、与返回值类型无关，只看方法名和参数列表
2、在调用时，虚拟机通过参数列表的不同来区分同名方法

范例：

public class FunctionDemo5 {
    public static void main(String[] args) {
        //求加法

        int a = 1;
        int b = 2;
        int c = 3;
        int d = 4;

        byte e = 5;

    }

    public static int sum(int x,int y){
        int result = x+y;
        return result;
    }

    public static int sum1(int x,int y,int z){
        return (x+y+z);
    }

    public static int sum2(int x,int y,int z,int i){
        return (x+y+z+i);
    }

    public static int sum3(int x,byte y){
        return (x+y);
    }
}

感谢阅读，我是啊帅和和，一位大数据专业即将大四学生，祝你快乐。

啊帅和和。
关注
专栏目录
Java基础篇：循环语句之while语句
kaikeba的博客
11-13 1620
Java的循环语句有for，while和 do-while。这些语句创造了我们通常所称的循环（loops）。你可能知道，一个循环重复执行同一套指令直到一个结束条件出现。你将看到，Java有适合任何编程所需要的循环结构。 while语句 while语句是Java最基本的循环语句。当它的控制表达式是真时，while语句重复执行一个语句或语句块。它的通用格式如下： while(condition) { // body of loop } 条件condition可以是任何布尔表达式。只要条件表达式为真，循环体就被执
Java while循环
weixin_44552202的博客
04-17 3929
开发工具与关键技术：Myeclipse 10,Java 作者：刘俊杰 撰写时间：2019年04月16日 While循环由四个结构组成：初始化、条件判断、循环体、迭代。 在循环刚开始时，会计算一次“布尔表达式”的值，如果条件为真的话就执行循环体。而对于后来每一次额外的循环，都会在开始前重新计算一次。 语句中应有是循环趋向于结束的语句，否则会出现无限循环—“死”循环。 While循环是先判断，后执行的...
Java | while循环
最新发布
yingzix688的博客
02-27 1060
while 循环是Java中的一种基本控制流程语句。它会在指定的条件为真时，重复执行一个代码块。如果不更新循环条件中的变量，循环内部，形成嵌套循环。循环可以嵌套在另一个。循环会变成无限循环。
java的while循环结构_Java 循环结构 - for, while 及 do...while
weixin_42297446的博客
02-28 177
Java 循环结构 - for, while 及 do...while顺序结构的程序语句只能被执行一次。如果您想要同样的操作执行多次,，就需要使用循环结构。Java中有三种主要的循环结构：while循环do…while循环for循环在Java5中引入了一种主要用于数组的增强型for循环。while 循环while是最基本的循环，它的结构为：while( 布尔表达式 ){//循环内容 }只要布...
Java中的while循环
m0_67474739的博客
04-01 342
1.1格式下面这题 就是只知道循环的结束条件 ~大于等于珠穆朗玛峰高度循环停止。
Java实验报告——循环结构应用
02-21
在本Java实验报告中，我们关注的是循环结构的应用，特别是在解决实际问题——游戏中生命力购买的最佳策略。实验的主要目的是让学生深入理解变量与常量的定义，掌握while循环、if语句和break语句的使用，以及如何运用...
Java循环结构for语句while语句详解-Java教程
11-22
在Java中，有两种主要的循环结构：for循环和while循环，这两种循环在编写控制流程、处理数组、迭代集合等场景时非常常见。 **一、for循环** for循环是一种预定义迭代的循环结构，适用于已知循环次数的情况。基本...
java循环结构
01-18
Java语言中的循环结构是编程中不可或缺的一部分，它允许程序重复执行一段代码，直到满足特定条件为止。循环结构在处理重复任务、数组遍历、数据处理等场景中非常常见。这里我们将详细探讨Java中的几种主要循环结构，...
浅析JAVA 循环结构
08-18
JAVA 中有三种主要的循环结构：while 循环、do…while 循环和 for 循环。 一、while 循环 while 循环是最基本的循环结构，它的结构为：while( 布尔表达式 ) { //循环内容}只要布尔表达式为 true，循环就会一直执行...
for while dowhile_javado-while循环_
09-29
最后是do-while循环，它是Java中唯一一种后检查条件的循环结构。do-while循环至少会执行一次循环体，即使条件一开始就不满足。其语法如下： ```java do { // 循环体 } while (条件); ``` do-while循环的特点在于...
Java的while语句
weixin_44560731的博客
05-23 9076
循环是程序中的重要流程结构之一。 循环语句能够使程序代码重复执行，适用于需要重复一段代码直到满足特定条件为止的情 况。 循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体。当反复执行这个循环体时，需要在合适的时候把循环条件改为假，从而结束循环，否则循环将一直执行下去，形成死循环。 循环语句可能包含如下 4 个部分。 初始化语句（init statement）： 一条或多条语句，这些语句用于完成一些初始化工 作，初始化语句在循环开始之前执行。 循环条件（te
JAVA中while循环的使用
lanjinyu1121的博客
01-09 5523
while循环是一种在编程中常见的控制流语句，它允许代码在特定条件下（通常是一个布尔表达式）重复执行一段代码。其基本思想是：只要给定的条件为真，就会不断执行循环体内的代码。通过使用循环语句，可以避免编写大量重复的代码，并提供了更高效和灵活的方式来处理需要重复执行的任务。初始化部分：在while循环的开头，可以进行一些变量的初始化操作。这部分通常用于设置循环变量或其他需要在循环开始前准备的条件。循环条件：这是while循环的关键部分，它是一个布尔表达式。只要该条件为真，循环就会持续执行。迭代部分。
Java--while循环结构
柳落青
07-11 454
while循环 1. 什么是循环结构？ *在程序中总有一些需要执行反复/重复执行的代码，假设没有循环结构，那么这段代码需要重复执行，自然是要重复编写的。 *代码无法得到重复使用，所有编程语言都是支持循环结构的，把需要反复执行的代码，放到“循环体”中，在联合计数器，共同控制这段需要反复执行的代码 2. 基本上所有的编程语言都支持的循环包括三种； *for循环 *while循环 *do-while循环...
Java_while循环结构
weixin_45857066的博客
12-14 160
Java_while循环结构 while循环 while(布尔表达式){ ​ //循环内容 } 没有分号 布尔表达式为true，则会一直执行while内的语句，表达式不成立时，则跳出循环。 package struct; public class whileDemo1 { public static void main(String[] args) { int i = 0; while(i<=100){ System.out.print
Java:运用while()与do....while与for（）
cjk_wxdf的博客
04-20 129
while（true）{         操作；}与do{         操作；}while（true）作用于对大括号内操作的循环运行，只要条件判断为“真”，就可以永久循环。所以要写对该操作的循环条件，不然会死循环，导致后续的操作无法执行。两个while有个区别：while（）是先判断在执行，do{...}while（）是先执行在判断。 for（变量初始值；循环条件；变量变更）是在while的基...
Java控制语句——while语句
weixin_34318956的博客
01-26 94
while循环 在循环刚开始时，会计算一次“布尔表达式”的值，若条件为真，执行循环体，而对于后来每一次额外的循环，都会在开始前重新计算一次。 注意：语句中应有使循环趋向于结束的语句，否则会出现无限循环——“死循环”。 循环结构都由一下四个结构组成： 初始化、条件判断、循环体、迭代。 计算1+2+3+……+100的和。 Do-While循环（用的少，了解） do-while...
Java中的循环结构(一)-while循环结构
7旅病娘的博客
05-08 1344
Java中的循环结构(一)-while循环结构 前言 循环语句就是在满足一定条件的情况下反复执行某一操作。在Java语言中提供了三种常用的循环结构，分别为while循环结构、do…while循环结构和for循环结构。本期文章详细介绍一下while循环结构，希望有所帮助。 while循环语句也称条件判断语句，他的循环方式为利用一个条件来控制是否要反复执行这个语句。 语法： while(条件表达式)...
【JavaSE专栏14】Java 的 while 循环语句
热门推荐
Designer 小郑的技术博客
06-29 1万+
本文简单对 Java 中的 while 循环语句进行了介绍，讲解了语法，演示了样例代码，提出和 while 语句的应用场景
详解Java循环结构：while、do...while与for
本文将深入浅出地分析Java中的循环结构，帮助初学者更好地理解和掌握这一关键编程概念。Java语言提供了多种循环结构，包括基础的while循环、do...while循环以及更便捷的for循环。这些循环结构在程序设计中扮演着至关...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

啊帅和和。

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值