1. Toy模板网首页
  2. > Toy博客

Java流程控制(二)

10月前 作者：造次阿 分类：Toy博客 阅读(38) 违法举报

这篇具有很好参考价值的文章主要介绍了Java流程控制(二)。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

⭐ 循环结构

Java流程控制(二)

循环结构分两大类，一类是当型，一类是直到型。

🐟 当型：
当布尔表达式条件为 true 时，反复执行某语句，当布尔表达式的值为 false 时才停止循环，比如：while 与 for 循环。
🐟 直到型：
先执行某语句， 再判断布尔表达式，如果为 true，再执行某语句，如此反复，直到布尔表达式条件为 false 时才停止循环，比如 do-while 循环。

while 循环
Java流程控制(二)

语法结构：

	while(布尔表达式){
		循环体;
}

🐟 在循环刚开始时，会计算一次“布尔表达式”的值，若条件为真，执行循环体。而对于后来每一次额外的循环，都会在开始前重新计算一次。
🐟 语句中应有使循环趋向于结束的语句，否则会出现无限循环–––"死"循环。

【eg】while 循环结构：求 1 到 100 之间的累加和

		public class Test {
		public static void main(String[ ] args) {
			int i = 0;
			int sum = 0;
		// 1+2+3+…+100=?
			while (i <= 100) {
			sum += i;//相当于 sum = sum+i;
			i++;
		}
		System.out.println("Sum= " + sum);
	}
}

执行结果如图所示：
Java流程控制(二)

do-while 循环
Java流程控制(二)

语法结构：

	do{
	循环体
	}while(布尔表达式);

do-while 循环结构会先执行循环体，然后再判断布尔表达式的值，若条件为真，执行循环体，当条件为假时结束循环。do-while 循环的循环体至少执行一次。

【eg】do-while 循环结构：求 1-100 之间的累加和

	public class Test {
		public static void main(String[ ] args) {
		int i = 0;
		int sum = 0;
		do {
		sum += i; // sum = sum + i
		i++;
		} while (i <= 100); //此处的；不能省略
		System.out.println("Sum= " + sum);
	}
}

执行结果如下所示：
Java流程控制(二)

【eg】while 与 do-while 的区别

		public class Test {
		public static void main(String[ ] args) {
		//while 循环：先判断再执行
		int a = 0;
			while (a < 0) {
				System.out.println(a);
		a++;
	}
		System.out.println("-----");
		//do-while 循环：先执行再判断
		a = 0;
		do {
		System.out.println(a);
		a++;
		} while (a < 0);
		}
}
//	运行结构，可以看出 do-while 总是保证循环体至少会被执行一次！

循环结构(for)
Java流程控制(二)

语法结构：

	for (初始表达式; 布尔表达式; 迭代因子) {
 		循环体;
}

🐟 初始化部分设置：循环变量的初值
🐟 条件判断部分为：布尔表达式
🐟 迭代因子：控制循环变量的增减

for 循环在执行条件判定后，先执行的循环体部分，再执行步进。

【eg】for 循环

	public class Test {
		public static void main(String args[ ]) {
		int sum = 0;
	//1.求 1-100 之间的累加和
		for (int i = 0; i <= 100; i++) {
		sum += i;
	}
		System.out.println("Sum= " + sum);
	//2.循环输出 9-1 之间的数
		for(int i=9;i>0;i--){
		System.out.print(i+"、");
	}
	System.out.println();
	//3.输出 90-1 之间能被 3 整除的数
		for(int i=90;i>0;i-=3){
		System.out.print(i+"、");
		}
	System.out.println();
	}
}

执行结果如下所示：
Java流程控制(二)

【eg】逗号运算符

	public class Test {
		public static void main(String[ ] args) { 
			for(int i = 1, j = i + 10; i < 5; i++, j = i * 2) {
			System.out.println("i= " + i + " j= " + j); 
 		} 
	}
}

执行结果如下所示：
Java流程控制(二)

【eg】无限循环

	public class Test {
		public static void main(String[ ] args) { 
		for ( ; ; ) { // 无限循环: 相当于 while(true)
		 System.out.println("北京");
		}
	}
}

编译器将 while(true)与 for(;;)看作同一回事，都指的是无限循环。

【eg】初始化变量的作用域

		public class Test {
			public static void main(String[] args) {
			for(int i = 1; i < 10; i++) {
				System.out.println(i+" ");
		}
				System.out.println(i);//编译错误，无法访问在 for 循环中定义的变量 i
		}
}

⭐ 嵌套循环

循环语句内部，再写一个或多个循环，称为嵌套循环。一般工作中多见的就是两层。

Java流程控制(二)

【eg】嵌套循环

		public class Test {
			public static void main(String args[ ]) {
			for (int i=1; i <=5; i++) {
			 for(int j=1; j<=5; j++){
 			System.out.print(i+" ");
		 }
		System.out.println();
		}
	}
}

执行结果如下图所示：
Java流程控制(二)

【eg】使用嵌套循环实现九九乘法表
Java流程控制(二)

	public class Test {
		public static void main(String args[ ]) {
		for (int i = 1; i < 10; i++) { // i 是一个乘数
		for (int j = 1; j <= i; j++) { // j 是另一个乘数
 		System.out.print(j + "*" + i + "=" + (i * j < 10 ? (" " + i * j) : i * j) + " ");
		}
		System.out.println();
		}
	}
}

执行结果如下图所示：
Java流程控制(二)

⭐ break 语句和 continue 语句

Java流程控制(二)

🐟	break 用于强行退出整个循环
🐟	continue 用于结束本次循环，继续下一次

【eg】break 语句

//产生 100 以内的随机数，直到随机数为 88 时终止循环
	public class Test {
		public static void main(String[ ] args) {
		int total = 0;//定义计数器
		System.out.println("Begin");
		while (true) {
		total++;//每循环一次计数器加 1
		int i = (int) Math.round(100 * Math.random());
		//当 i 等于 88 时，退出循环
		if (i == 88) {
		break;
		}
	}
		//输出循环的次数
		System.out.println("Game over， used " + total + " times.");
		}
}

执行结果如下所示：
Java流程控制(二)

continue 语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。

【eg】continue 语句

//把 100~150 之间不能被 3 整除的数输出，并且每行输出 5 个
	public class Test {
		public static void main(String[ ] args) {
		int count = 0;//定义计数器
		for (int i = 100; i < 150; i++) {
		//如果是 3 的倍数，则跳过本次循环，继续进行下一次循环
		if (i % 3 == 0){
		continue;
	}
	//否则（不是 3 的倍数），输出该数
		System.out.print(i + "、");
		count++;//每输出一个数，计数器加 1
		//根据计数器判断每行是否已经输出了 5 个数
		if (count % 5 == 0) {
		System.out.println();
			}
		}
	}
}

执行结果如下所示：
Java流程控制(二)

带标签的 continue 语句

🐟	“标签”是指后面跟一个冒号的标识符，例如：“label:”。对 Java 来说唯一用到标签的地方是在循环语句之前。
🐟	“goto 有害”论中，最有问题的就是标签，而非 goto，随着标签在一个程序里数量的增多，产生错误的机会也越来越多。但 Java 标签不会造成这方面的问题，因为它们的活动场所已被限死，不可通过特别的方式到处传递程序的控制权。

【eg】带标签的 continue

	//控制嵌套循环跳转(打印 101-150 之间所有的质数)
	public class Test {
		public static void main(String args[ ]) {
		outer: for (int i = 101; i < 150; i++) {
		for (int j = 2; j < i / 2; j++) {
		if (i % j == 0){
		continue outer; //符合某条件，跳到外部循环继续
		}
	}
		System.out.print(i + " ");
		}
	}
}

执行结果如下所示：
Java流程控制(二)

⭐ 方法

语句块

🐟	语句块（也叫复合语句）。语句块中定义的变量只能用于自己，外部不能使用。
🐟	语句块可以使用外部的变量，而外部不能使用语句块的变量；

【eg】语句块

	public class Test {
		public static void main(String[ ] args) {
		int n;
		int a;
		{
			int k;
			int n; //编译错误：不能重复定义变量 n
			} //变量 k 的作用域到此为止
		}
}

方法
Java流程控制(二)

⭐	方法(method)：一段用来完成特定功能的代码片段，类似于其它语言的函数(function)。
⭐	方法用于定义该类或该类的实例的行为特征和功能实现。
⭐	面向过程中，函数是最基本单位，整个程序由一个个函数调用组成。
⭐	面向对象中，整个程序的基本单位是类，方法是从属于类和对象的。

方法声明格式：

		[修饰符 1 修饰符 2 …] 返回值类型 方法名(形式参数列表){
		 Java 语句；… … …
}

方法的调用方式：
Java流程控制(二)

方法的详细说明

⭐	形式参数：在方法声明时用于接收外界传入的数据。（方法定义时）
⭐	实参：调用方法时实际传给方法的数据。 (方法调用时)
⭐	返回值：执行完毕后，返还给调用它的环境的数据。
⭐	返回值类型：事先约定的返回值的数据类型，如无返回值，则为 void。

【eg】方法的声明及调用

	public class Test {
/** main 方法：程序的入口 */
		public static void main(String[ ] args) {
		int num1 = 10;
		int num2 = 20;
//调用求和的方法：将 num1 与 num2 的值传给 add 方法中的 n1 与 n2
// 求完和后将结果返回，用 sum 接收结果
		int sum = add(num1, num2);
		System.out.println("sum = " + sum);//输出：sum = 30
	//调用打印的方法：该方法没有返回值
		print();
}
		/** 求和的方法 */
	public static int add(int n1, int n2) {
	int sum = n1 + n2;
	return sum;//使用 return 返回计算的结果
	}
	/** 打印的方法 */
	public static void print() {
		System.out.println("北京...");
	}
}

注意

🐟	实参必须和形参列表匹配。
🐟	return：终止方法运行，并返回的数据。
🐟	Java 中传递参数，遵循值传递的原则(传递的都是数据的副本)：
🐟	基本类型传递的是该数据值的 copy 值。
🐟	引用类型传递的是该对象引用的 copy 值，但指向的是同一个对象。

⭐ 方法的重载(overload)

Java流程控制(二)
重载：一个类中可以定义多个名称相同，但形式参数列表不同的方法。

构成方法重载的条件：

🐟	形参列表不同的含义：形参类型、形参个数、形参顺序不同
🐟	只有返回值不同不构成方法的重载
如：int a(String str){}与 void a(String str){}不构成方法重载
🐟	只有形参的名称不同，不构成方法的重载
如：int a(String str){}与 int a(String s){}不构成方法重载

【eg】方法重载

	public class Test {
		public static void main(String[ ] args) {
		System.out.println(add(3, 5));// 8
		System.out.println(add(3, 5, 10));// 18
		System.out.println(add(3.0, 5));// 8.0
		System.out.println(add(3, 5.0));// 8.0
		// 我们已经见过的方法的重载
		System.out.println();// 0 个参数
		System.out.println(1);// 参数是 1 个 int
		System.out.println(3.0);// 参数是 1 个 double
	}
	/** 求和的方法 */
	public static int add(int n1, int n2) {
		int sum = n1 + n2;
		return sum;
	}
	// 方法名相同，参数个数不同，构成重载
	public static int add(int n1, int n2, int n3) {
		int sum = n1 + n2 + n3;
		return sum;
	}
	// 方法名相同，参数类型不同，构成重载
	public static double add(double n1, int n2) {
		double sum = n1 + n2;
		return sum;
	}
	// 方法名相同，参数顺序不同，构成重载
	public static double add(int n1, double n2) {
		double sum = n1 + n2;
		return sum;
	}
	//编译错误：只有返回值不同，不构成方法的重载
	public static double add(int n1, int n2) {
		double sum = n1 + n2;
		return sum;
	}
	//编译错误：只有参数名称不同，不构成方法的重载
	public static int add(int n2, int n1) {
		double sum = n1 + n2;
		return sum;
	}
}

⭐ 递归结构

Java流程控制(二)

🐟	递归是一种常见的算法思路，在很多算法中都会用到。比如：深度优先搜索（DFS:Depth First Search）等。
🐟	递归的基本思想就是“自己调用自己”。

Java流程控制(二)

递归结构包括两个部分：

🐟	定义递归头。 解决：什么时候不调用自身方法。如果没有头，将陷入死循环，也就是递归的结束条件。
🐟	递归体。 解决：什么时候需要调用自身方法。

【eg】使用递归求 n!

	public class Test {
		public static void main(String[ ] args) {
			long d1 = System.currentTimeMillis(); 
			factorial(10);
			long d2 = System.currentTimeMillis();
		System.out.printf("递归费时:"+(d2-d1)); //耗时：32ms
	}
	/** 求阶乘的方法*/
		static long factorial(int n){
		if(n==1){//递归头
		return 1;
		}else{//递归体
		return n*factorial(n-1);//n! = n * (n-1)!
		}
	}
}

执行结果如下所示：
Java流程控制(二)

执行结果如下所示：
Java流程控制(二)

递归的缺陷
❗算法简单是递归的优点之一。但是递归调用会占用大量的系统堆栈，内存耗用多，在递归调用层次多时速度要比循环慢的多，所以在使用递归时要慎重。

比如上面的递归耗时 558ms(看电脑配置)。但是用普通循环的话快得多，如下所示。

【eg】使用循环求 n!

	public class Test {
		public static void main(String[ ] args) {
			long d3 = System.currentTimeMillis();
			int a = 10;
			int result = 1;
			while (a > 1) {
			result *= a * (a - 1);
			a -= 2;
	}
			long d4 = System.currentTimeMillis();
		System.out.println(result);
		System.out.printf("普通循环费时："+(d4 - d3));
		}
}

执行结果如下所示：
Java流程控制(二)文章来源地址https://www.toymoban.com/news/detail-462182.html

到了这里，关于Java流程控制(二)的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • Java学习路线（4）——程序流程控制

    一、顺序结构 顺序结构是程序默认流程。 二、分支结构 if 作用： 主要用于区间匹配。 格式1： 格式2： 格式3： 注意： 当语句体只有一条程序时，可以将{}去除。 switch 作用： 适用于值匹配分支选择，即作为字典进行查找。 格式： 注意： （1）表达式类型仅支持byte、short、

    2024年02月05日
    浏览(46)
  • Java流程控制——the next day

    Java流程控制——the next day

    Java5的新特性，带来了java.util.Scanner类，提供了人机交互的作用。我们可以通过它 获取用户的输入 。 next(): 一定要读取到字符才能结束输入。（才能使程序继续运行） 不会记录空白，并且以空格为结束符。 不能得到带有空格的字符串。 nextLine(): 以Enter为结束符。 可以获得空

    2024年02月08日
    浏览(78)
  • Java基础 驼峰规则、流程控制、自增自减

    Java基础 驼峰规则、流程控制、自增自减

     命名规则（驼峰）、流程控制、自增自减。 上一篇文章中提到了标识符，在Java中很多标识符都需要我们自己起名，但起名的方式千百不一，会让代码看的杂乱无章，故在漫长的近三十年时光里，Java形成了一套完成的命名规则，各大公司也在内部进行了命名规范的制约，最

    2024年01月22日
    浏览(48)
  • git的版本控制流程

    git的版本控制流程

    例如我们常用的淘宝，每次升级，版本号就会加一。那么我们怎么控制版本号呢？ --使用git。 不建议 使用【Git Bash】中去输入指令，使用idea 中以及集成好的三个按钮更加快捷方便。 从左到右依次是【git pull】拉项目、【commit】暂提交到本地、【git push】提交到远程。 注意

    2024年02月04日
    浏览(42)

  • kotlin——流程控制

    when分支取代了Java原有的switch语句 不需要使用case case值后的冒号改为使用箭头(-) default改为更有意义，更明确的wlse 除此之外， when分支可以匹配多个值 when分支后的值不要求是常量，可以是任意表达式 when分支对条件的表达式的类型没有任何要求 除了范围还可以使用i

    2024年02月02日
    浏览(34)
  • Kotlin-控制流程

    Kotlin-控制流程

    本文主要是【Kotlin】——Kotlin-控制流程的文章，如果有什么需要改进的地方还请大佬指出⛺️ 🎬作者简介：大家好，我是听风与他🥇 ☁️博客首页：CSDN主页听风与他 🌄每日一句：狠狠沉淀，顶峰相见 Kotlin有三种结构化跳转表达式: return 默认从最直接包围它的函数或者匿

    2024年01月19日
    浏览(54)
  • 【Scala】——流程控制

    【Scala】——流程控制

    让程序有选择的的执行，分支控制有三种：单分支、双分支、多分支 • Scala 中 if else 表达式其实是有返回值的，具体返回值取决于满足条件的 代码体的最后一行内容。 • Scala 中返回值类型不一致，取它们共同的祖先类型。 在一个分支结构中又完整的嵌套了另一个完整的分

    2024年01月22日
    浏览(15)
  • 五、C#流程控制

    五、C#流程控制

    分支语句： if语句和switch语句 迭代语句 跳转语句 if （判断条件表达式）{ 表达式结果为true时执行}else{表达式结果为false时执行} 输入1显示为星期一，依次类推 swithc(条件表达式){ case 常量表达式：条件语句； case 常量表达式：条件语句； case 常量表达式：条件语句； default：

    2024年02月08日
    浏览(9)

  • python流程控制与异常

    目录 布尔类型 布尔类型的使用 流程控制  if语句 while循环 for循环 while循环与for循环的区别 range语句 range语句与for循环 变量的作用域 break和continue 异常 前言 异常的捕获 异常的传递性 布尔类型： 主要用来表示现实生活中的逻辑。 语法： 变量名称=布尔类型字面量 注意： b

    2024年02月14日
    浏览(23)

  • 【Python】流程控制（重复处理）

    检查重复处理的行为 这次，将看看 while 和 for-in 等循环处理。 做简单的重复，但还要检查一下如何指定循环。 while 循环 在下面的示例中，重复该过程，直到basket中不再存放任何水果为止。 定义一个名为basket的列表，并对列表中的每个元素执行相同的处理。 Python的for语句只

    2024年02月04日
    浏览(16)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包