java--第五章：java语言基础4

向右看齐 2023-06-08 12:56 18阅读 0赞

### 1 switch语句 ###

**switch语句格式：**

switch(表达式)\{

case 值1:

语句体1;

break;

case 值1:

语句体1;

break;

...

default:

语句体n+1;

break;

**switch：**表示这是switch选择结构

表达式：这个地方的取值是有限定的byte,short,int,char

JDK5以后可以是枚举，JDK7以后是string

**case：**后面跟的是要和表达式进行比较的值

**语句体**部分可以是一条语句或者多条语句

**break**表示中断，结束的意思，可以结束switch语句

**default**语句表示所有情况都不匹配的时候，就执行该处的内容，和if语句的else相似

**执行流程：**

首先计算出表达式的值，其次，和case依次进行比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。最后，如果所有的case都和表达式的值不匹配，就会执行default语句部分，然后程序结束。

/*
       byte可以作为swtich的表达式吗？可以
       long可以作为swtich的表达式吗？不可以
       string可以作为swtich的表达式吗？JDK7以后可以
       
       案例：键盘录入一个数据，根据这个数据，我们输出对应的星期？
       注意：遇到左大括缩进一个tab的位置；关联不是很大的语句间进行空行
    */
    import java.util.Scanner;
    
    class SwitchDemo{
    	public static void main(String[] args){
    		Scanner sc = new Scanner(System.in);
    		
    		System.out.println("请输入一个数据(1-7)：");
    		int week = sc.nextInt();
    		
    		switch(week){
    			case 1:
    				System.out.println("星期一");
    				break;
    			case 2:
    				System.out.println("星期二");
    				break;
    			case 3:
    				System.out.println("星期三");
    				break;
    			case 4:
    				System.out.println("星期四");
    				break;
    			case 5:
    				System.out.println("星期五");
    				break;
    			case 6:
    				System.out.println("星期六");
    				break;
    			case 7:
    				System.out.println("星期日");
    				break;
    			default:
    				System.out.println("你输入的数据有误");
    				break;
    		}
    	}
    }

**注意事项：**

A：case后面只能是常量，不能是变量，而且多个case后面的值不能出现相同的。

B：default可以省略吗？可以省略，但是一般不建议。除非判断的值是固定的（单选题）。

C：break可以省略吗？可以省略，但是一般不建议。否则结果可能不是你想要的，会出现一个case穿透的现象。

D：deault的位置一定要在最后吗？可以出现在switch语句任何位置，但是建议在最后。

E： switch语句结束条件：遇到break；执行到程序的末尾。

/int number = 3;
    		//把case后面的值改成number会报错
    		
    		switch(week){
    			case 1:
    				System.out.println("星期一");
    				break;
    			case 2:
    				System.out.println("星期二");
    				break;
    			case 3:
    				System.out.println("星期三");
    				break;
    			case 4:
    				System.out.println("星期四");
    				break;
    			case 5:
    				System.out.println("星期五");
    				break;
    			case 6:
    				System.out.println("星期六");
    				break;
    			case 7:
    				System.out.println("星期日");
    				break;
    			default:
    				System.out.println("你输入的数据有误");
    				break;
    		}

**练习1：看程序写结果**

class SwitchDemo2{
    	public static void main(String[] args){
    		int x = 2;
    		int y = 3;
    		switch (x){
    			default:
    				y++;
    				break;
    			case 3:
    				y++;
    			case 4:
    				y++;
    		}
    		System.out.println("y="+y);//4
    		/*
    		  先走case，但是case里没有符合的，所以走default，y++变成了4，break就结束了。
    		*/
    		
    		
    		int a = 2;
    		int b = 3;
    		switch (a){
    			default:
    				b++;
    			case 3:
    				b++;
    			case 4:
    				b++;
    		}
    		System.out.println("b="+b);//6
    		/*
    		  先走case，但是case里没有符合的，所以走default，y++变成了4，没有break，不能结束
    		  于是就得走到结尾结束，y++,y++,变成了6.
    		*/
    	}
    }

**练习2：单项选择**

/*
      练习：做单项选择题，根据你的选择，给出对应的答案。（表达式是字符的情况）
    */
    import java.util.Scanner;
    
    class SwitchDemo3{
    	public static void main(String[] args){
    		System.out.println("下面的几个人你最爱谁？");
    		//由于现在没有办法键盘录入得到一个a，b这样的东西，我们就用65,66这样的值替代
    		System.out.println("65 苑海洋");
    		System.out.println("66 男的");
    		System.out.println("67 女的");
    		System.out.println("68 人妖");
    		
    		Scanner sc=new Scanner(System.in);
    		
    		System.out.println("请输入你的选择：");
    		int choiceNumber = sc.nextInt();
    		
    		char choice =(char) choiceNumber;
    		
    		switch (choice){
    			case 'A':
    				System.out.println("恭喜你，选择正确");
    				break;
    			case 'B':
    				System.out.println("选择有误");
    				break;
    			case 'C':
    				System.out.println("选择有误");
    				break;
    			case 'D':
    				System.out.println("选择有误");
    				break;
    			default:
    				System.out.println("没有该选项");
    				break;
    		}
    		
    	}
    }

**练习3：表达式是字符串**

/*
      练习：键盘录入字符串，判断是否有满足要求的，如果有就输出，否则，提示错误。
      
      String s=sc.nextLine();拿的是字符串类型
    */
    import java.util.Scanner;
    
    class SwitchDemo4{
    	public static void main(String[] args){
    		Scanner sc=new Scanner(System.in);
    		
    		System.out.println("请输入你要判断的字符串：");
    		String s = sc.nextLine();
    		
    		switch (s){
    			case "hello":
    				System.out.println("你输入的是hello");
    				break;
    			case "world":
    				System.out.println("你输入的是world");
    				break;
    			case "java":
    				System.out.println("你输入的是java");
    				break;
    			default:
    				System.out.println("没有找到你输入的数据");
    				break;
    		} 
    	}
    }

**switch和if语句的各自使用场景：**

if语句的使用场景：

A：针对结果是布尔类型的判断（switch不可以）

B：针对一个范围的范围（switch不可以）

C：针对几个常量值的判断

switch语句的使用场景：

针对几个常量值的判断

/*
      用switch语句实现键盘录入月份，输出对应的季节
    */
    import java.util.Scanner;
    
    class SwitchDemo5{
    	public static void main(String[] args){
    		Scanner sc = new Scanner(System.in);
    		
    		System.out.println("请输入一个月份：");
    		int month = sc.nextInt();
    		
    		/*
    		switch (month){
    			case 1:
    				System.out.println("冬季");
    				break;
    			case 2:
    				System.out.println("冬季");
    				break;
    			case 3:
    				System.out.println("春季");
    				break;
    			case 4:
    				System.out.println("春季");
    				break;
    			case 5:
    				System.out.println("春季");
    				break;
    			case 6:
    				System.out.println("夏季");
    				break;
    			case 7:
    				System.out.println("夏季");
    				break;
    			case 8:
    				System.out.println("夏季");
    				break;
    			case 9:
    				System.out.println("秋季");
    				break;
    			case 10:
    				System.out.println("秋季");
    				break;
    			case 11:
    				System.out.println("秋季");
    				break;
    			case 12:
    				System.out.println("冬季");
    				break;
    			default:
    				System.out.println("您输入的数据有误");
    				break;
    		}
    		*/
    		
    		//这样写太麻烦了，我们使用一个case穿透
    		switch (month){
    			case 1:
    			case 2:
    			case 12:
    				System.out.println("冬季");
    				break;
    			case 3:
    			case 4:
    			case 5:
    				System.out.println("春季");
    				break;
    			case 6:
    			case 7:
    			case 8:
    				System.out.println("夏季");
    				break;
    			case 9:
    			case 10:
    			case 11:
    				System.out.println("秋季");
    				break;
    			default:
    				System.out.println("您输入的数据有误");
    				break;
    		}
    	}
    }

## ##

### 2 循环结构概述 ###

循环语句可以在满足循环条件的前提下，反复执行某一段代码，这段被重复执行的代码称为循环体语句。当反复执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形成死循环。

循环语句：for循环，while循环和do...while循环

**循环语句的组成：**

A：初始化语句：一条或者多条语句，这些语句完成一些初始化操作。

B：判断条件语句：这是一个布尔表达式，这个表达式能决定是否执行循环体。

C：循环体语句：这个部分是循环体语句，也是我们多次要做的事情。

D：控制条件语句：这个部分在一次循环体结束之后，下一次循环判断条件执行前执行。通过用户控制循环条件中的变量，使得循环在合适的时候结束。

## ##

### 3 循环结构for语句 ###

**for循环语句的格式：**

for(初始化语句;判断条件语句;控制条件语句)\{

循环体语句;

//在控制台输出10次"helloworld"
    
    class ForDemo{
    	public static void main(String[] args){
    		for(int x=1;x<=10;x++){
    			System.out.println("helloworld");
    		}
    	}
    }

**注意事项：**

A：判断条件语句的结果是一个boolean类型

B：循环体语句如果是一条语句，大括号可以省略；如果是多条语句，大括号不能省略。建议永远不要省略。

C：一般来说，有左大括号就没有分号，有分号就没有左大括号

**练习1：请在控制台输出数据1-10**

/请在控制台输出数据1-10
    
    class ForTest1{
    	public static void main(String[] args){
    		for(int x=0;x<10;x++){
    			System.out.println(x+1);
    		}
    	}
    }

**练习2：求和**

//求1-10的数据和
    
    class ForTest2{
    	public static void main(String[] args){
    	    int sum = 0;
    		
    		for(int x=1;x<=10;x++){
    			sum += x;
    		}
    		
    		System.out.println("sum="+sum);
    	}
    }

**练习3：求偶数和**

//求1-100偶数和
    
    class ForTest3{
    	public static void main(String[] args){
    		int sum = 0;
    		
    		//方式1
    		/*
    		for(int x=1;x<=100;x++){
    			if(x%2==0){
    				sum += x;
    			}
    		}
    		*/
    		
    		//方式2
    		for(int x=0;x<=100;x+=2){
    			sum += x;
    		}
    		
    		System.out.println("sum="+sum);
    	}
    }

**练习4：阶乘**

/*
      求5的阶乘
      什么是阶乘呢？
        n!=n*(n-1)(n-2)*...*3*2*1;
    	
    */
    
    class ForTest4{
    	public static void main(String[] args){
    		int jc=1;
    		
    		for(int x=1;x<=5;x++){
    			jc *= x;
    		}
    		
    		System.out.println(jc);
    	}
    }

**练习5：水仙花**

/*
      需求：在控制台输出所有的"水仙花数"
      
      何为"水仙花数"？
      水仙花数就是指一个三位数，其各位数字的立方和等于该数本身。
      比如153=1*1*1 + 5*5*5 + 3*3*3
      
      三位数是告诉了我们范围，
      麻烦的是吧如何获取这个三位数的个，十，百位上的数据
      
      假设有个数据：153
      ge:153%10 = 3
      shi:153/10%10 = 5
      bai:153/100%10 = 1
      
      让 ge*ge*ge + shi*shi*shi + bai*bai*bai 和该数据比较
      如果相同，就把该数据在控制台输出  
    */
    
    class ForTest5{
    	public static void main(String[] args){
    		for(int x=100;x<1000;x++){
    			int ge = x%10;
    			int shi = x/10%10;
    			int bai = x/100%10;
    			
    			if(x == (ge*ge*ge + shi*shi*shi + bai*bai*bai)){
    				System.out.println(x);
    			}
    		}
    	}
    }

**练习6：改进版的回文数**

/*
       请在控制台输出满足如下条件的五位数
       个位等于万位
       十位等于千位
       个位+十位+千位+万位=百位
       
    */
    
    class ForTest6{
    	public static void main(String[] args){
    		for(int x=10000;x<100000;x++){
    			int ge = x%10;
    			int shi = x/10%10;
    			int bai = x/100%10;
    			int qian = x/1000%10;
    			int wan = x/10000%10;
    			
    			if(ge==wan && shi==qian && (ge+shi+qian+wan)==bai){
    				System.out.println(x);
    			}
    		}
    	}
    }

**练习7：统计思想**

//统计水仙花数有多少个
    
    class ForTest7{
    	public static void main(String[] args){
    		int count = 0;
    		
    		for(int x=100;x<1000;x++){
    			int ge=x%10;
    			int shi=x/10%10;
    			int bai=x/100%10;
    			
    			if(x==(ge*ge*ge + shi*shi*shi + bai*bai*bai)){
    				count++;
    			}
    		}
    		
    		System.out.println(count);
    	}
    }

**练习8：同时取余**

/*
      统计1-1000之间同时满足如下条件的数据有多少个：
          对3整除余2 x%3==2
    	  对5整除余3 x%5==3
    	  对7整除余2 x%7==2
    */
    
    class ForTest8{
    	public static void main(String[] args){
    		int count = 0;
    		
    		for(int x=1;x<=1000;x++){
    			if(x%3==2 && x%5==3 && x%7==2){
    				count++;
    			}
    		}
    		
    		System.out.println(count);
    	}
    }

### 4 循环结构while语句 ###

**基本格式：**

while(判断条件语句)\{

循环体语句;

**扩展格式：**

初始化语句;

while(判断条件语句)\{

循环体语句;

控制条件语句;

class WhileDemo{
    	public static void main(String[] args){
    		//输出10次"helloworld"
    		int x = 0;
    		while(x<10){
    			System.out.println("helloworld");
    			x++;
    		}
    	}
    }

**练习1：求和**

//求出1-100之和
    
    class WhileTest1{
    	public static void main(String[] args){
    		//for
    		int sum=0;
    		for(int x=1;x<=100;x++){
    			sum += x;
    		}
    		System.out.println(sum);
    		
    		//while
    		int sum2 = 0;
    		int y=1;
    		
    		while(y<=100){
    			sum2 += y;
    			y++;
    		}
    		
    		System.out.println(sum2);
    	}
    }

**练习2：统计**

//统计水仙花个数有多少个
    
    class WhileTest2{
    	public static void main(String[] args){
    		//for
    	    int count=0;
    		
    		for(int x=100;x<1000;x++){
    			int ge=x%10;
    			int shi=x/10%10;
    			int bai=x/100%10;
    			
    			if(x == (ge*ge*ge + shi*shi*shi + bai*bai*bai)){
    				count++;
    			}
    		}
    		System.out.println(count);//4
    		
    		//while
    		int count2=0;
    		
    		int y=100;
    		while(y<1000){
    			int ge=y%10;
    			int shi=y/10%10;
    			int bai=y/100%10;
    			
    			if(y == (ge*ge*ge + shi*shi*shi + bai*bai*bai)){
    				count2++;
    			}
    			y++;
    		}
    		System.out.println(count);//4
    	}
    }

**while和for循环的区别**

使用区别：如果你想在结束循环之后，继续使用控制条件的那个变量，用while循环。否则就用for循环。

因为变量及早的从内存中消失，可以提高内存的使用率。

理解：其实还有一种常见的场景

如果是一个范围的，用for循环非常明确；如果是不明确要用多少次，用while循环较为合适

class WhileTest3{
    	public static void main(String[] args){
    		//for循环实现
    		for(int x=0;x<10;x++){
    			System.out.println("i love you");
    		}
    		//这里不能再继续访问x了
    		//System.out.println(x);//报错
    		
    		//while实现
    		int y=0;
    		while(y<10){
    			System.out.println("i love you");
    			y++;
    		}
    		//这里可以继续访问y
    		System.out.println(y);
    	}
    }

**练习3：珠穆朗玛峰**

/*
     我国最高山峰是珠穆朗玛峰：8848米。我现在有一张足够大的纸，厚度为：0.01m.
     请问，折叠多少次，就可以保证厚度不低于珠穆朗玛峰的高度？
     
     0.01初始厚度
     8848最终厚度
     折叠一次效果：厚度是以前的2倍
    */
    
    class WhileTest4{
    	public static void main(String[] args){
    		int count = 0;
    		
    		//为了简单，把0.01变成1,8848就变成884800
    		int end = 884800;
    		int start = 1;
    		
    		while(start<end){
    			count++;
    			start *= 2;
    			
    			//System.out.println(start);
    		}
    		System.out.println(count);
    	}
    }

### 5 循环结构do...while语句 ###

**基本格式：**

do\{

循环体语句;

\}while(判断条件语句);

**扩展格式：**

初始化语句;

do\{

循环体语句；

控制条件语句;

\}while(判断条件语句);

class DoWhileDemo{
    	public static void main(String[] args){
    		int x=0;
    		
    		do{
    			System.out.println("helloworld");
    			x++;
    		}while(x<10);
    		
    		//求和1-100
    		int sum=0;
    		
    		int a=0;
    		do{
    			sum += a;
    			a++;
    		}while(a<=100);
    		
    		System.out.println(sum);
    	}
    }

### 6 循环结构的总结 ###

**三种循环的区别：**

do...while至少执行一次，

而for，while必须先判断条件是否成立，然后决定是否执行循环体语句。

那一般使用哪种循环呢？优先考虑for，其次考虑while，最后考虑do...while

class XunHuan1{
    	public static void main(String[] args){
    		int x=3;
    		
    		while(x<3){
    			System.out.println("x<3");//没有执行
    			x++;
    		}
    		
    		int y=3;
    		do{
    			System.out.println("x<3");//执行了
    			x++;
    		}while(y<3);
    	}
    }

**死循环：**

A：一定要注意控制条件语句控制的的那个变量的问题，不要弄丢了，否则就变成了死循环。

B：两种最简单的死循环格式：

while(true)\{...\}

for(;;)\{...\}

class XunHuan2{
    	public static void main(String[] args){
    		int x=0;
    		while(x<10){
    			System.out.println(x);
    			x++;//没有这句话就变成了死循环
    		}
    		
    		//死循环的第一种格式
    		/*
    		while(true){
    			System.out.println("xuexi");
    		}
    		*/
    		
    		//死循环的第二种格式
    		/*
    		for(;;){
    			System.out.println("xuexi");
    		}
    		*/
    	}
    }

**循环嵌套**

外循环控制行数，内循环控制列数

/*
      请输出一个四行五列的星星图案
      结果：
          *****
    	  *****
    	  *****
    	  *****
    */
    
    class XunHuan3{
    	public static void main(String[] args){
    		//输出语句的另一种格式：System.out.print("*");这个不带换行
    		//我们可以通过空的输出语句实现换行：System.out.println();
    		for(int y=1;y<5;y++){
    			for(int x=0;x<5;x++){
    				System.out.print("*");
    			}
    			System.out.println();
    		}
    		
    	}
    }

**练习：输出正三角形**

/*输出正三角形
      *
      **
      ***
      ****
      *****
      
      行：5
      列：变化
      第一行：1列 y=0;y<=0;y++
      第二行：2列 y=0;y<=1;y++
      第三行：3列 y=0;y<=2;y++
      第四行：4列 y=0;y<=3;y++
      第五行：5列 y=0;y<=4;y++
    */
    
    class XunHuan4{
    	public static void main(String[] args){
    		//先输出一个5行5列的
    		for(int x=0;x<5;x++){
    			for(int y=0;y<5;y++){
    				System.out.print("*");
    			}
    			System.out.println();
    		}
    		
    		//输出正三角形
    		for(int x=0;x<5;x++){
    			for(int y=0;y<=x;y++){
    				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*9=9  2*9=18  3*9=27...
      
      '\x' x表示任意，这种做法就转义字符
      
      '\t' tab键的位置
      '\r' 回车
      ''n' 换行
      
    */
    
    class XunHuan5{
    	public static void main(String[] args){
    		for(int x=1;x<=9;x++){
    			for(int y=1;y<=x;y++){
    				System.out.print(y+"*"+x+"="+y*x+"\t");
    			}
    			System.out.println();
    		}
    	}
    }

## ##

### **7 控制跳转语句：** ###

java提供了break，continue，return来实现控制语句的跳转和中断

break：中断

continue：继续

return：返回

**break**

break的使用场景：①在选择结构switch中;②在循环语句中（一般是加入了if判断）

离开这两个场景没有意义

break的作用：跳出单层循环；跳出多层循环

带标签的跳出；格式：标签名：循环语句

class XunHuan6{
    	public static void main(String[] args){
    		//不能独立使用，在switch或loop外部中断
    		//break;
    		
    		//跳出单层循环
    		for(int x=0;x<10;x++){
    			if(x==2){
    				break;//仅仅表示退出当前循环
    			}
    			System.out.println("helloworld");
    		}
    		
    		//跳出多层循环
    		/*
    		for(int x=0;x<3;x++){
    			for(int y=0;y<4;y++){
    				if(y==2){
    					break;
    				}
    				System.out.print("*");
    			}
    			System.out.println();
    		}
    		*/
    		
    		//标签名
    		wc:for(int x=0;x<3;x++){
    			nc:for(int y=0;y<4;y++){
    				if(y==2){
    					break wc;
    				}
    				System.out.print("*");
    			}
    			System.out.println();
    		}
    	}
    }

**continue：**

使用场景：在循环语句中

作用：单层循环对比break，然后总结两个的区别

break退出当前循环；continue退出一次循环，进入下一次的执行

/*
       练习：
       for(int x=0;x<=10;x++){
    	   if(x%3==0){
    		   //在此处填写代码
    	   }
    	   System.out.println("aaa");
       }
       
       在控制台输出2次"aaa"
            break;
       在控制台输出7次"aaa"
            continue;
       在控制台输出13次"aaa"
            System.out.println("aaa");
       
    */
    
    class XunHuan7{
    	public static void main(String[] args){
    		/*
    		for(int x=0;x<10;x++){
    			if(x==3){
    				//break;0,1,2
    				continue;//0,1,2,4,5,6,7,8,9没有3
    			}
    			System.out.println(x);
    		}
    		*/
    		
    		for(int x=1;x<=10;x++){
    		   if(x%3==0){
    			   //在此处填写代码
    		   }
    		   System.out.println("aaa");
    	   }
    	}
    }

**return**

不是结束循环，而是结束方法。退出一个方法，跳转到上层调用的方法。

结束循环其实就是就是结束了main方法

class XunHuan8{
    	public static void main(String[] args){
    		for(int x=0;x<10;x++){
    			if(x==2){
    				System.out.println("退出");
    				//break;//0,1,退出,over
    				//continue;//0,1,退出,3,4,5,6,7,8,9,over
    				return;//0,1,退出
    			}
    			System.out.println(x);
    		}
    		System.out.println("over");
    	}
    }

**练习：小芳存钱**

/*
       需求：
           小芳的妈妈每天给她2.5元钱，她都会存起来。
           但是，每当这一天是存钱的第5天或者5的倍数时，她都会花去6元钱。
           请问，经过多少天，小芳才可以存到100元钱。
    	   
       分析：1 每天2.5
               double dayMoney=2.5;
             2 她都存起来
    		   double daySum=0;
    		 3 从第一天开始存
    		   int dayCount=1;
    		 4 结果不小于100
    		   double result=100;
    		 5 如果被5整除，就减去6元钱
    		   daySum -= 6;
    		   如果不能被5整除，每天要累加2.5
    		   daySum += 2.5;
    		 6 因为不知道是多少天，所以用死循环，一旦超过100元就退出循环
    */
    
    class XunHuan9{
    	public static void main(String[] args){
    		double dayMoney=2.5;
    		double daySum=0;
    		int dayCount=1;
    		double result=100;
    		
    		while(true){
    			daySum+=dayMoney;
    			
    			if(daySum>=result){
    				System.out.println(dayCount);
    				break;
    			}
    			
    			if(dayCount%5==0){
    				daySum -= 6;
    				System.out.println("第"+dayCount+"天花了6元钱");
    			}
    			
    			dayCount++;
    		}
    	}
    }