Java_基础语法3

最新推荐文章于 2023-06-06 23:04:04 发布

xiaote0225

最新推荐文章于 2023-06-06 23:04:04 发布

阅读量275

点赞数

分类专栏： Java基础文章标签： java基础

本文链接：https://blog.csdn.net/xiaote0225/article/details/79363554

版权

Java基础专栏收录该内容

18 篇文章 0 订阅

订阅专栏

内容概述

选择结构
循环结构

选择结构

if语句的格式一

	if(逻辑表达式){
		//if体语句。当"逻辑表达式"为true时，会执行这里；
	}

if语句的注意事项：

	if(关系表达式){
	}
	1.关系表达式的结果必须是一个boolean值；
	2.if体内，如果只有一条语句，可以省略一对{}；但是不建议；

if语句的格式2：

	if(关系表达式){
		//如果为true，执行这里
	}else{
		//如果为false，执行这里
	}

if语句的格式2和三目运算符的相互转换问题:

	有些时候，三目运算符的判断结果只能返回一个值，所做的事情有限；
	这时，就不如使用if...else...语句，在if...else...语句内，可以做很多事情；

if语句的格式3：

	if(关系表达式1){
		//表达式1为true，执行这里
	}else if(关系表达式2){
		//表达式2为true,执行这里
	}else if(关系表达式3){
		//表达式3为true，执行这里
	}else{
		//表达式3为false，执行这里
	}

switch语句：

	1.同if的作用的一样，也是"选择结构"；先判断，后选择；
	2.格式：
			switch(表达式){
				case 值1:
					//执行代码;
					break;
				case 值2:
					//执行代码;
					break;
				case 值3:
					//执行代码
					break;
				......
				default:
					//执行代码
					break;
			}
		说明：
			1."表达式"可以产生的值：byte,short,int,char,枚举(JDK5以后),String(JDK7以后)
			2.case语句后跟"常量表达式"，不能是"变量"；而且不能出现相同的常量值；
			3.break;语句"不是必须的"。如果不写，如果一旦case相应的值成功，但内部没有break语句，
			  那么将会无条件(不再进行case匹配)的继续向下执行其它case中的语句，直到遇到break;语句
			  或者到达switch语句结束。
			4.多个case之间，没有顺序关系；
			5.default语句"不是必须的"。可以不写，它就相当于多重if语句中最后的else。
			6.default语句和case语句"没有顺序关系"。

选择语句各自使用场景

	if语句使用场景：
		针对结果是boolean类型的判断
		针对一个范围的判断
		针对几个常量值的判断
	switch语句使用场景
		针对几个常量值的判断

while循环：

	1.基本格式：
		while(条件表达式){
			//循环体内容
		}
	2.扩展格式：
		初始化语句；
		while(判断条件语句){
			循环体语句；
			控制条件语句；
		}

do_while循环：

	基本格式：
		do{		
			//循环体语句
		}while(判断条件表达式);
	扩展格式:
		初始化语句；
		do{
			循环体语句；
			控制条件语句；
		}while(判断条件语句);
	执行流程：
	1.先无条件进入到"循环体"，执行一遍；
	2.再执行"条件表达式"判断；
	  如果为：true
			再进入循环体执行；
	  如果为：false
			结束循环；

for循环：

	for循环语句格式：
	for(初始化语句;判断条件语句;控制条件语句){
		循环体语句；
	}
	1.for：是关键字；
	2.for后面的小括号必须要写；
	3.定义循环变量表达式、关系表达式、增量表达式：都不是必须的；
	  但是，中间的分号";"必须要写；
	4.关于"循环变量"的作用域：	
		for( int num = 1,i = 1,j = 1; num <= 100 ; num++){		
		}
		System.out.println("num = " + num);//编译错误。num的作用域范围只能在for循环内部
		定义循环变量：可以同时定义多个变量；中间用,隔开；

/*
	求5的阶乘1*2 *3*4*5
*/

class Demo1 
{
	public static void main(String[] args) 
	{
		int result = 1;//存储的结果
		int num = 1;//代表每个数字
		while(num <= 5){
			result = result * num;
			num++;
		}
		System.out.println("5的阶乘--while循环：" + result);

		//使用for循环
		result = 1;
		for(int n = 1 ; n <= 5 ; n++){
			result *= n;
		}
		System.out.println("for循环的结果：" + result);

	}
}

/*
	在控制台输出所有的”水仙花数”
	所谓的水仙花数是指一个三位数，其各位数字的立方和等于该数本身。
	举例：153就是一个水仙花数。
	153 = 1*1*1 + 5*5*5 + 3*3*3
	流程：
	1.三位数：100--999：for循环遍历；
	2.获取每个数，获取每一位上的数字，计算立方和；
		153：
			个位数：153 % 10  ： 3
			十位数：153 / 10 % 10 : 5
			百位数：153 / 100 % 10 : 1
			千位数：数字 / 1000 % 10 ...
			万位数：数字 / 10000 % 10 ...
	3.判断立方和是否等于该数字：
	   是：打印：水仙花数；
	   否则：下一个数；
*/

class Demo2 
{
	public static void main(String[] args) 
	{
		int count = 0
		for(int n = 100 ; n <= 999 ; n++){
			int ge = n % 10;
			int shi = (n / 10) % 10;
			int bai = (n / 100) % 10;
			if((ge * ge * ge + shi * shi * shi + bai * bai * bai) == n){
				System.out.println("找到水仙花数：" + n);
				count++;
			}
		}
		System.out.println("水仙花数一共有：" + count + " 个");
	}
}

/*
	请在控制台输出满足如下条件的五位数:
	个位等于万位
	十位等于千位
	个位+十位+千位+万位=百位
	步骤：
	1.五位数：10000 -- 99999:使用for循环
	2.取每一位，判断
		是：打印
		否则：下一个数字
*/

class Demo3 
{
	public static void main(String[] args) 
	{
		for(int n = 10000 ; n <= 99999 ; n++){
			int ge = n % 10;
			int shi = (n / 10) % 10;
			int bai = (n / 100) % 10;
			int qian = (n / 1000) % 10;
			int wan = (n / 10000) % 10;
			if(ge == wan && shi == qian && (ge + shi + qian + wan) == bai){
				System.out.println("五位数：" + n);
			}
		}
	}
}

循环内部还可以写其它的循环结构，这就是：循环的嵌套；

	for(){
		while(){
			do{
				for(){
				}
			}while();
		}
	}

循环的嵌套：

	1.外层循环，每执行一次循环，内层循环都要全部的执行一次；
	2.系统开销比较大，虽然可以无限的嵌套，但建议：只写两层嵌套的循环，如果出现第三层，请考虑优化代码；

/*
	需求：请输出一个4行5列的星星(*)图案。
			*****
			*****
			*****
			*****
		  每次只能输出一个*符号
*/

class Demo1 
{
	public static void main(String[] args) 
	{
		for(int n = 1 ; n <= 4 ; n++){//外层循环，一般是用来控制”行"
			for(int m = 1 ; m <= 5; m++){//内层循环，一般是用来控制"列"
				System.out.print("*");
			}
			System.out.println();//输出一个换行符
		}
		
	}
}

/*
	需求：请输出如下图形
			*
			**
			***
			****
			*****
*/

class Demo2 
{
	public static void main(String[] args) 
	{
		for(int n = 1 ; n <= 5 ; n++){
			for(int m = 1; m <= n ;m++){
				System.out.print("*");
			}
			System.out.println();
		}
	}
}

/*
	1*1=1
	1*2=2	2*2=4
	1*3=3	2*3=6	3*3=9
	1*4=4	2*4=8	3*4=12	4*4=16
	.....
	1*9=9	2*9=18	3*9=27	4*9=36	5*9=45	6*9=54	7*9=63	8*9=72	9*9=81
*/

class Demo3 
{
	public static void main(String[] args) 
	{
		for(int n = 1 ;n <= 9 ; n++){//n代表行
			for(int m = 1 ; m <= n ; m++){
				System.out.print(m + "*" + n + "=" + (m*n) + "\t");
			}
			System.out.println();
		}
	}
}

各种循环的区别：

	1.while循环：特点：先判断，后进入循环体；
	2.do...while循环：特点：先无条件的进入循环体执行一次，之后再判断；
	3.for循环：特点：先判断，后进入循环体。语法格式比较紧凑；执行顺序：(见图)
	4.对于任何一个循环需求，三种循环结构都可以实现；
	5.对于存在非常明显的"遍历范围"的需求，可以优先考虑使用for循环；

break和continue语句：

	break：
		1.可以用于switch语句，表示结束switch语句的执行；
		2.可以用"循环结构"，表示：结束循环；
	continue:
		1.只能用于"循环结构"；
		2.表示：结束本次循环，继续下一次循环；

带标签的break和continue:

	标签的语法规则：
	1.标签属于"自定义标识符"，遵循自定义标识符的命名规则和命名规范；
	2."标签"下面必须是"循环"语句，不能是其它的语句：例如：
			loop:
			int n = 10;//错误，中间不能有任何其它语句；
			for(){
			}
	3."标签"的跳转规则：
		loop1:
		for(){
			loop3:
			while(){
				break loop3/loop1；//其它都不可以
			}

			loop4:
			do{
				continue loop4/loop1;//其它都不可以；
			}while();

		}

		loop2:
		while(){
			break loop2;
		}

class Demo 
{
	public static void main(String[] args) 
	{
		loop:
		for(int i = 1 ; i<= 5 ; i++){
			System.out.println("i = " + i);
			for(int j = 1 ; j <= 5 ; j++){
				if(i >= 3){
					break loop;//直接停掉外层循环
				}
				System.out.println("\tj = " + j);
				
			}
		}
		System.out.println("--------------------------------");
		loop2:
		for(int i = 1 ;i <= 5 ; i++){
			System.out.println("i = " + i);
			for(int j = 1; j <= 5 ;j++){
				if(i % 2 == 0){
					continue loop2;//直接结束外层循环的本次循环，继续外层循环的下一次循环；
				}
				System.out.println("\tj = " + j);
			}
			System.out.println("**************************");
			
		}
	}
}