零基础学java第四天循环结构_内层循环结束后会进入外层吗-CSDN博客

本文链接：https://blog.csdn.net/w326389/article/details/129468437

今天的内容

1.三目运算符
2.循环结构

1.三目运算符

开发中用的很多
语法格式：
数据类型 x = （表达式） ? value1 : value2;
执行流程: 来判断表达式你如果表达式为true 就将value1赋值给x这个变量，如果为false 就将value2赋值给变量x

public class Demo1 {
	public static void main(String[] args) {
		int a = 30;
		int c;
		//int c = a > 31 ? 20 : 21;
		//执行流程:  判断a > 31 的值  如果 是true 将 20赋值给c     如果是false 将21 赋值给c
		//System.out.println(c);
		//三目运算符和if-else  类似
		
		if (a > 31) {
			c = 20;
		} else {
			c = 21;
		}
		System.out.println(c);
		
		
	}
}

2.循环结构

2.1为啥会有循环结构

如果代码中出现了大量的重复的代码或者有规律的代码的时候，可以使用循环结构出来
让代码变得简洁
1.代码看着红臃肿
2.阅读性差
3.可以维护低
循环可以解决以上所有的问题
循环是很有必要学习的

2.2while循环

语法格式：
while (布尔表达式) { 语句体 }
执行流程: 当代码执行到while关键字的时候，先去判断布尔表达式，如果布尔表达式为false，就不会执行
语句体。如果布尔表达式为true 执行语句体，然后（重要）再去判断布尔表达式，如果布尔表达式为true
执行语句体，然后再去判断布尔表达式，直到布尔表达式为false的时候，循环就结束了（就不再执行语句体了）。接着执行循环以外的代码

public class Demo3 {
	public static void main(String[] args) {
		//打印4遍的中午吃烤羊排，使用while循环
		
		//无论任何循环  都要必须有三个条件：
			//1.初始化条件
			//2.循环条件
			//3.终止条件
		
		/**
		 * 分析代码，主要是分析执行的流程:
		 * i=0   0<4  true  执行大括号里面的代码  打印第一次的  中午吃烤羊排  i++
		 * i=1   1<4 true 执行大括号里面的代码  打印第二次的  中午吃烤羊排  i++
		 * i=2   2<4 true 执行大括号里面的代码  打印第三次的  中午吃烤羊排  i++
		 * i=3   3<4 true执行大括号里面的代码  打印第四次的  中午吃烤羊排  i++
		 * i=4  4<4 false  就不再执行大括号中的代码了！！！
		 */
		//1.声明一个变量
		int i = 0;//初始化条件
		while (i < 4) {// i <  4  终止条件   
			System.out.println("中午吃烤羊排");
			i++;//i++  是循环条件  自身加1
		}
		
		
	}
}

打印100遍的hellowolrd

public class Demo4 {
	public static void main(String[] args) {
		
		int i = 1;
		while (i <= 100) {
			System.out.println("第" + i + "遍hello wolrd");
			i++;
		}
		
		System.out.println("======");
		int i1 = 100;
		while (i1 > 0) {
			System.out.println("helloworld");
			i--;
		}
		
		//总结：   小数 -》大数   循环条件是++    大数-》小数   循环条件是--
		
		
	}
}

循环可以做重复的事情，或者有规律的
打印1~5 1 2 3 4 5

public class Demo5 {
	public static void main(String[] args) {
		
		//打印1~5  while循环
		
		//打印的结果很巧妙的借助于了i这个变量
		/**
		 * 执行流程:
		 * i=1 1<6  true 执行大括号中的代码   sout(1)  i++
		 * i=2  2<6 true 执行大括号中的代码   sout(2) i++
		 * i=3 3<6  true执行大括号中的代码   sout(3) i++
		 * i=4 4<6 true  执行大括号中的代码   sout(4) i++
		 * i=5 5<6 true 执行大括号中的代码   sout(5) i++
		 * i=6 6<6 false  不执行大括号中的代码 循环结束
		 */
		int i = 1;
		while (i < 6) {
			System.out.println(i);
			i++;
		}
		
		
	}
}

打印1~10的奇数 1 3 5 7 9

public class Demo6 {
	public static void main(String[] args) {
		//打印10以内的奇数
		
		/**
		 * i = 1  1<11 true  执行if语句 1%2 !=0 true  执行if后面的大括号的代码 sout(1) i++
		 * i=2    2<11 true 执行if语句 2%2 !=0 false  if后面的大括号就不再执行了 i++
		 * i= 3   3<11 true  执行if语句 3%2 !=0 true 执行if后面的大括号的代码 sout(3) i++
		 * i=4  4<11   true执行if语句 3%2 !=0  false  if后面的大括号就不再执行了 i++
		 * i=5  
		 * 
		 * 循环了10遍
		 */
		int i = 1;
		while (i < 11) {
			//while循环可以嵌套if语句
			if (i % 2 != 0) {
				System.out.println(i);
			}
			i++;
		}
		
		System.out.println("============");
		
		/**
		 * a = 1  1<11 true   sout(1) a = a+2  a=3
		 * a= 3  3 <11 true sout(3) a=a+2  a=3+2
		 * a=5  5<11  true sout(5)  a=a+2   a=5+ 2
		 * a=7 ...
		 */
		int a = 1;
		while (a < 11) {
			System.out.println(a);
			//a = a + 2;
			a += 2;//步幅
		}
	}
}

打印1~100之内的偶数

public class Demo7 {
	public static void main(String[] args) {
		//打印100以内的偶数
		
		int i = 0;
		while (i <= 100) {
			if (i % 2 == 0) {
				System.out.println(i);
			}
			i++;
		}
		
		System.out.println("==========");
		int a = 0;
		while (a < 101) {
			System.out.println(a);
			a += 2;
		}
	}
}

2.3do-while循环【几乎不用】

语法格式：
do { 语句体 } while(布尔表达式);
执行流程:首先代码执行到do 然后执行do后面大括号中的语句体，再去判断while后面的布尔表达式
如果布尔表达式为false的话，就不再执行do后面的语句体了，相当于循环结束
如果布尔表达式为true，再回到do 去执行后面的语句体，执行完语句体之后，再判断while后面的布尔表达式，如果布尔表达式为true的话，就再执行do后面的语句体，然后再去判断while布尔表达式，直到为false的时候，循环结束了

public class Demo8 {
	public static void main(String[] args) {
		//打印 3遍的 一枝红杏出墙来
		
		/**
		 * i=0  打印第一遍的一枝红杏出墙来  i++ i=1   while后面的布尔表达式  1 <3 true
		 * 	      打印第二遍的一枝红杏出墙来 i++  i=2   while后面的布尔表达式 2< 3 true
		 *     打印第三遍的一枝红杏出墙来 i++  i=3   while后面的布尔表达式3 <3 false  循环结束
		 * 
		 */
		int i = 0;
		do {
			System.out.println("一枝红杏出墙来");
			i++;
		} while (i < 3);
		
		//do-while循环 和while循环的不同之处？
		//while 先判断 再执行     do-while 先执行再判断
	}
}

回顾上午的内容

1.三目运算符
  数据类型  x = 布尔表达式 ?   值1 :  值2;
  执行流程:    判断 布尔表达式  如果为true  将值1赋值给x. 如果为false 就会将值2赋值给x
2.循环结构
	做重复的事情或者有规律的事情
	一个循环必须有三个条件:  1.初始条件   2.循环条件    3.终止条件
	while循环
	while(布尔表达式) {
		语句体
	}
	
	
	do-while循环
	do {
		语句体
	} while (布尔表达式);

2.4for循环【重点】

语法格式：
for (表达式1; 布尔表达式2; 表达式3) { 语句体 }
表达式1：初始化的条件
表达式2: 终止条件
表达式3: 循环条件
执行流程: 首先执行表达式1，再执行表达式2，如果布尔表达式2为true，执行大括号中语句体。然后再执行表达式3，再执行表达式2，再次判断布尔表达式2，直到为false，就不执行语句体。就意味着循环结束

public class Demo9 {
	public static void main(String[] args) {
		//打印3遍今天好热，但是我穿了棉袄
		
		/**
		 * i = 0   0 <3  true  执行大括号中的语句体  打印第一遍的今天好热，但是我穿了棉袄  i++
		 * i = 1   1<3  true 执行大括号中的语句体  打印第二遍的今天好热，但是我穿了棉袄 i++
		 * i=2 2<3   true执行大括号中的语句体  打印第三遍的今天好热，但是我穿了棉袄 i++
		 * i=3 3<3  false  大括号中的代码不再执行 循环结束了
		 */
		for (int i = 0; i < 3; i++) {
			System.out.println("今天好热，但是我穿了棉袄");
		}
		
	}
}

打印10以内的奇数

public class Demo10 {
	public static void main(String[] args) {
		//打印10以内的奇数
		
		/**
		 * i=1 1<11 执行大括号中的if语句  i%2!=0  true  执行if语句大括号中的代码 sout(1) i++
		 * i=2 2<11 执行大括号中的if语句  i%2!=0 false  不再执行if语句后面的大括号中的代码了  i++
		 * i=3 3<11 ...
		 */
		//循环和if的嵌套
		for (int i = 1; i < 11; i++) {
			if (i % 2 != 0)  {
				System.out.println(i);
			}
		}
		
		System.out.println("=======");
		for (int i = 1; i < 11; i+=2) {
			System.out.println(i);
		}
	}
}

求1~100的和

public class Demo11 {
	public static void main(String[] args) {
		//求1~100的和
		/**
		 * sum是一个变量
		 *  第一次sum = 0     
		 *  第二次sum = sum(第一次的) + 1
		 *  第三次sum = 0 + 1 + 2
		 *  第四次sum = 0+ 1 + 2  + 3
		 * ...
		 * sum = sum + i
		 */
		
		/**
		 * sum = 0; i=0  0<101 true sum= sum + i=>sum=0+0  i++
		 * i=1  1<101  true sum =sum + i  =>sum = 0 + 1  i++
		 * i=2  2<101 true sum = sum + i =>sum=0+1 + 2  i++
		 * i=3  3<101  true sum=sum+i=>sum= 0+1 + 2 + 3 i++
		 * ...
		 * i=100 100<101 true sum=sum+i=>sum =0 + 1+2+...+ 99  + 100 i++
		 * i=101 101<101 false  大括号不再执行， 代码还要继续往下走。
		 * 执行 sout(sum)
		 * 
		 */
		int sum = 0;
		for (int i = 0; i < 101; i++) {
			sum = sum + i;
			
		}
		System.out.println(sum);
	}
}

1~100以内逢7过
1 2 3 4 5 6 过 8 9 10 11 12 13 过 15 16 过...
分析：
得用for循环从1开始一直到100 得把这些数过一遍的
但是是7的倍数或者带7 的
i 这个值就是要处理的数
7的倍数 i % 7 ==0 true 是7的倍数
个位带7 i % 10 == 7 true 是个位带7De
十位带7 i / 10 == 7 true 是十位带7

public class Demo12 {
	public static void main(String[] args) {
		//逢7打印过
		/**
		 * i=1 1<101 true if  sout(1) i++
		 * i=2 2<101 true if sout(2) i++
		 * ..,.
		 * i=7  7<101 true if sout("过")i++
		 */
		for (int i = 1; i < 101; i++) {
			if (i % 7 == 0 || i % 10 == 7 || i / 10 == 7) {
				System.out.println("过");
			} else {
				System.out.println(i);
			}
		}
	}
}

2.4嵌套循环【重点难点】

前提是循环
一个循环里面套另外一个循环。秉承着一个特点：从外层循环先进入到内层循环，然后内存循环先结束
然后再回到外层循环，再进入到内层循环，内层循环结束，再会带外层循环
案例1
**** **** ****

****
****
****



public class Demo13 {
	public static void main(String[] args) {
//		System.out.println("****");
//		System.out.println("****");
//		System.out.println("****");
//		for (int i = 0; i < 4; i++) {
//			System.out.print("*");
//		}
//		for (int i = 0; i < 3; i++) {
//			//****   
//			System.out.println("****");
//		}
		/**
		 * i = 0  0< 3 true  执行大括号中的内层的for循环
		 * 		j=0  0<4 true 	打印1个*  j++
		 * 		j=1  1<4  true  打印1个*  j++
		 * 		j=2 2<4 true    打印1个*  j++
		 * 		j=3  3<4  true  打印1个*  j++
		 * 		j=4  4<4 false 内层for循环结束 立马换行    i++  
		 * i = 1  1<3   true  再次执行大括号中的内层的for循环
		 * 		j=0 0< 4 true  打印1个* j++
		 * 		j=1  1<4  true  打印1个* j++
		 * 		j=2  2<4  true 打印1个* j++
		 * 		j=3  3<4  true  打印1个* j++
		 * 		j=4 4<4 false    内层循环结束  立马换行  i++
		 * i=2 2<3   true  再次执行大括号中的内层的for循环
		 * 		j=0   0< 4  打印1个* j++
		 * 		...
		 * 		j=3  3<4  true  打印1个*  j++
		 * 		j=4  4<4 false    内层循环结束  立马换行 i++
		 * i=3 3<3 false  整体循环就结束了
		 */
		for (int i = 0; i < 3; i++) {
			for (int j = 0; j < 4; j++) {//打印的是4个*
				System.out.print("*");
				
			}
			System.out.println();//换行
		}
		//总结：   最外层for循环 控制的是   行      最内层控制的 是 列
	}
}

找规律

案例2：

* 第一行 1个* （2 * 行数） -1 *** 第二行 3个* ***** 第三行 5个* ******* 第四行 7个* 外层的for循环 int i = 1 i < 5 i++ 那个* 有规律 int j = 1 ;j <= (2 * i) -1; j++

*
***
*****
*******

public class Demo14 {
	public static void main(String[] args) {
		//打印直角三角形
		
		/**
		 * i = 1  1<5 true 执行大括号内的内层的for循环
		 * 		j=1 1<=1  true 打印1个*  j++
		 * 		j=2 2<=1 false 立马换行   i++
		 * i = 2  2<5  true 执行大括号内的内层的for循环
		 * 		j=1 1<= 3  true  打印*  j++
		 * 		j=2 2<= 3 true   打印一个* j++
		 * 		j=3 3<=3  true   打印一个* j++
		 * 		j=4 4<=3 false 内层循环结束  换行 i++
		 * i= 3 3<5  true 执行大括号内的内层的for循环
		 * 		j=1  1<=5 true  打印一个* j++
		 * 		...
		 * 		j=4  4<=5 true  打印一个* j++
		 * 		j=5  5<=5 true  打印一个* j++		
		 * 		j=6  6<=5  false  内层循环结束  换行 i++
		 * i= 4 4<5  true 执行大括号内的内层的for循环
		 * 		j=1 1<=7  true  打印一个*  j++
		 * 		...
		 * 		j=7 7<=7 true 打印一个*   j+=
		 * 		j=8 8<= 7false  内层循环结束  换行 i++
		 * i=5 5<5  false 整体循环结束
		 * 		
		 */
		for (int i = 1; i < 5; i++) {
			for (int j = 1; j <= (2 * i) - 1; j++) {
				System.out.print("*");
			}
			System.out.println();//换行
		}
	}
}

案例九九乘法表
1*1=1 1*2=2 2*2=4 1*3=3 2*3=6 3*3=9 ... 找规律几行 9行第一行 1列第二行 2列 .... 每行的列数和每行息息相关的

public class Demo15 {
	public static void main(String[] args) {
		
		//打印九九乘法表
		//你们自己分析代码的执行的流程！！！
		for (int i = 1; i < 10; i++) {
			for (int j = 1; j <= i; j++) {
								//1*2=2
				System.out.print(j + "*" + i + "=" + i*j + "\t");
			}
			System.out.println();
		}
	}
}

作业：

1.
 *******
 *****
 ***
 *
2.
    *          第一行 由3个空格  1个*
   **          第二行  由 2个空格 2个*
  ***           第三行  由 1个空格  3个*
 ****           第四行  由 0个空格   4个*
 for (int i = 0; i < 4; i++) {
			//控制是空格
			for (int j = 0; j < args.length; j++) {
				
			}
			//控制是*
			for (int j = 0; j < args.length; j++) {
				
			}
		}
3.
   *         第一行  3个空格 1个*
  ***        第二行  2个空格 3 个*
 *****       第三行  1个空格  5个*
*******      第四行  0个空格  7个*

基础比较弱的！！！一定要写一个倒三角！！！前提你得把我讲的弄懂弄会！！！理解掌握的