Java基础学习-day2、day3、day4、day5

最新推荐文章于 2025-03-07 05:00:00 发布

原创最新推荐文章于 2025-03-07 05:00:00 发布 · 621 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

JavaSE基础专栏收录该内容

57 篇文章

订阅专栏

本文深入讲解Java的基本语法，包括关键字、标识符、变量、数据类型、运算符、流程控制等核心概念，通过实例演示如何运用这些知识解决实际编程问题。

基本语法

1、关键字和保留字

在这里插入图片描述

2、标识符

在这里插入图片描述

package com.chb.day02;
/*
标识符的使用
1.标识符：凡是自己可以起名字的地方都叫标识符。
   比如：类名、变量名、方法名、接口名、包名...

2.标识符的命名规则：--> 如果不遵守如下的规则，编译不通过！需要大家严格遵守

> 由26个英文字母大小写，0-9 ，_或 $ 组成  
> 数字不可以开头。
> 不可以使用关键字和保留字，但能包含关键字和保留字。
> Java中严格区分大小写，长度无限制。
> 标识符不能包含空格。

3. Java中的名称命名规范： --->如果不遵守如下的规范，编译可以通过！建议大家遵守

包名：多单词组成时所有字母都小写：xxxyyyzzz
类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz
变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz
常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ

4.
注意1：在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。
注意2：java采用unicode字符集，因此标识符也可以使用汉字声明，但是不建议使用。 


*/
class IdentifierTest{

	public static void main(String[] args){
		
		//int myNumber = 1001;
		//System.out.println(myNumber);
		int mynumber = 1002;
		System.out.println(mynumber);

		int 学号 = 1003;
		System.out.println(学号);
		
	
	}


}

class Hello1_${

}
//class 1Hello{
//}
class staticpublic{
}
class Static{
}

class User{
}

class Account{
}

3、变量

在这里插入图片描述

package com.chb.day02;
/*
变量的使用
1. java定义变量的格式：数据类型 变量名 = 变量值;

2. 说明：
   ① 变量必须先声明，后使用
   ② 变量都定义在其作用域内。在作用域内，它是有效的。换句话说，出了作用域，就失效了
   ③ 同一个作用域内，不可以声明两个同名的变量

*/
class VariableTest {
	public static void main(String[] args) {
		//变量的定义
		int myAge = 12;
		//变量的使用
		System.out.println(myAge);
		
		//编译错误：使用myNumber之前并未定义过myNumber
		//System.out.println(myNumber);

		//变量的声明
		int myNumber;
		
		//编译错误：使用myNumber之前并未赋值过myNumber
		//System.out.println(myNumber);

		//变量的赋值
		myNumber = 1001;
		//编译不通过
		//System.out.println(myClass);

		//不可以在同一个作用域内定义同名的变量
		//int myAge = 22;
		
	}

	public void method(){
		int myClass = 1;
	}
}

在这里插入图片描述

package com.chb.day02;

public class VariableTest1 {
	public static void main(String[] args) {
		// 1. 整型：byte(1字节=8bit) \ short(2字节) \ int(4字节) \ long(8字节)
		// ① byte范围：-128 ~ 127
		byte b1 = -128;
		// byte b2=128;//编译不通过

		// ② 通常，定义整型变量时，使用int型。
		int i1 = 1234;

		// ③ 声明long型变量，必须以"l"或"L"结尾
		long l1 = 3414234324L;

		// 2. 浮点型：float(4字节) \ double(8字节)
		// ① 浮点型，表示带小数点的数值
		// ② float表示数值的范围比long还大
		double d1 = 123.3;
		// ③ 定义float类型变量时，变量要以"f"或"F"结尾
		float f1 = 12.3F;
		// ④ 通常，定义浮点型变量时，使用double型。

		// 3. 字符型：char (1字符=2字节)
		// ① 定义char型变量，通常使用一对'',内部只能写一个字符
		char c1 = 'a';
		char c2 = '1';
		char c3 = '中';
		char c4 = 'ス';
		// 编译不通过
		// c1 = 'AB';
		// ② 表示方式：1.声明一个字符 2.转义字符 3.直接使用 Unicode 值来表示字符型常量
		char c5 = '\n';// 换行符
		c5 = '\t';// 制表符
		char c6 = '\u0043';// Unicode 值

		// 4.布尔型：boolean
		// ① 只能取两个值之一：true 、 false
		// ② 常常在条件判断、循环结构中使用
		boolean bb1 = true;
		boolean isMarried = true;
		if (isMarried) {
			System.out.println("你结婚了，不能参加单身派对");
		} else {
			System.out.println("你应该多参加单身派对");
		}
	}
}

在这里插入图片描述

package com.chb.day02;

/*
基本数据类型之间的运算规则：

前提：这里讨论只是7种基本数据类型变量间的运算。不包含boolean类型的。

1. 自动类型提升：
    结论：当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型。
	byte 、char 、short --> int --> long --> float --> double 

	特别的：当byte、char、short三种类型的变量做运算时，结果为int型
	
2. 强制类型转换：见VariableTest3.java
    (1).需要使用强转符：()
    (2).注意点：强制类型转换，可能导致精度损失。


说明：此时的容量大小指的是，表示数的范围的大和小。比如：float容量要大于long的容量
*/
public class VariableTest2 {
	public static void main(String[] args) {
		byte b1 = 2;
		int i1 = 12;
		// byte b2 = b1 + i1;//编译不通过
		int i2 = b1 + i1;
		long l1 = b1 + i1;
		float f = b1 + i1;

		// ***************特别地*********************
		char c1 = 'a';// 97
		int i3 = 10;
		int i4 = c1 + i3;
		System.out.println(i4);

		double d1 = 12.9;
		// 精度损失举例1
		int i5 = (int) d1;// 截断操作

		// 没有精度损失
		long l2 = 123;
		short s2 = (short) l1;
	}
}

在这里插入图片描述

package com.chb.day02;
/*
String类型变量的使用
1. String属于引用数据类型,翻译为：字符串
2. 声明String类型变量时，使用一对""
3. String可以和8种基本数据类型变量做运算，且运算只能是连接运算：+
4. 运算的结果仍然是String类型
*/
public class StringTest {
	public static void main(String[] args) {
		String s1 = "Hello World!";
		String s2 = "a";
		String s3 = "";
		int number = 1001;
		String numberStr = "学号：";
		String info = numberStr + number;// +：连接运算
		System.out.println(info);//学号：1001
		boolean b1 = true;
		String info1 = info + b1;// +：连接运算
		System.out.println(info1);//学号：1001true
	}
}

在这里插入图片描述

package com.chb.day02;

public class VariableTest4 {
	public static void main(String[] args) {
		// 1.编码情况1：
		long l = 123213;// 比较小，默认为int型
		System.out.println(l);
		// 编译失败：过大的整数
		// long l1 = 21332423235234123;
		long l1 = 21332423235234123L;

		// float一定要加f，否则编译失败
		// float f1 = 12.3;

		// 2.编码情况2：
		// 整型常量，默认类型为int型
		// 浮点型常量，默认类型为double型
		byte b = 12;
		// byte b1 = b + 1;//编译失败，1是int型
		// float f1 = b + 12.3;//编译失败，12.3默认是double型
	}
}

在这里插入图片描述

4、运算符

在这里插入图片描述
（1）算术运算符

注：取模结果的正负与被模数的符号一致。

package com.chb.day03;

public class AriTest {
	public static void main(String[] args) {
		//除号：/
		int num1 = 12;
		int num2 = 5;
		int result1 = num1 / num2;//2
	
		int result2 = num1 / num2 * num2;//10

		double result3 = num1 / num2;//2.0
		
		double result4 = num1 / num2 + 0.0;//2.0
		double result5 = num1 / (num2 + 0.0);//2.4
		double result6 = (double)num1 / num2;//2.4
		double result7=num1/(double)num2;//2.4
		double result8 = (double)(num1 / num2);//2.0
		
		// %:取余运算
		//结果的符号与被模数的符号相同
		//开发中，经常使用%来判断能否被除尽的情况。
		int m1 = 12;
		int n1 = 5;
		System.out.println("m1 % n1 = " + m1 % n1);
		
		int m2 = -12;
		int n2 = 5;
		System.out.println("m2 % n2 = " + m2 % n2);

		int m3 = 12;
		int n3 = -5;
		System.out.println("m3 % n3 = " + m3 % n3);

		int m4 = -12;
		int n4 = -5;
		System.out.println("m4 % n4 = " + m4 % n4);
		
		//(前)++ :先自增1，后运算
		//(后)++ :先运算，后自增1
		int a1 = 10;
		int b1 = ++a1;
		System.out.println("a1 = " + a1 + ",b1 = " + b1);//a1 = 11,b1 = 11
		
		int a2 = 10;
		int b2 = a2++;
		System.out.println("a2 = " + a2 + ",b2 = " + b2);//a2 = 11,b2 = 10
		
		int a3 = 10;
		++a3;//a3++;
		int b3 = a3;
		System.out.println("a3 = " + a3 + ",b3 = " + b3);//a3 = 11,b3 = 11
		
		//注意点：
		short s1 = 10;
		//s1=s1+1;//编译失败
		s1=(short) (s1+1);//正确的
		s1++;//自增1不会改变本身变量的数据类型
		System.out.println(s1);//12
		
		//问题：
		byte bb1 =127;
		bb1++;
		System.out.println("bb1 = " + bb1);//bb1 = -128,超过了byte的范围
		
		//(前)-- :先自减1，后运算
		//(后)-- :先运算，后自减1
		int a4 = 10;
		int b4 = a4--;//int b4 = --a4;
		System.out.println("a4 = " + a4 + ",b4 = " + b4);//a4 = 9,b4 = 10
	}
}

package com.chb.day03;
//练习：随意给出一个三位数的整数，打印显示它的个位数，十位数，百位数的值。
public class AriExer {
	public static void main(String[] args) {
		int num=253;
		int bai=num/100;
		int shi=num/10%10;
		int ge=num%10;
		System.out.println("百位"+bai+",十位"+shi+",个位"+ge);
	}
}

（2）赋值运算符
在这里插入图片描述

package com.chb.day03;

/*
运算符之二：赋值运算符
=  +=  -=  *=  /=  %= 
*/
public class SetValueTest {
	public static void main(String[] args) {
		// 赋值符号：=
		int i1 = 10;
		int j1 = 10;

		// 连续赋值
		int i2, j2;
		i2 = j2 = 10;

		int i3 = 10, j3 = 20;

		int num1 = 10;// num1 = num1 + 2;
		num1 += 2;
		System.out.println(num1);// 12

		int num2 = 12;
		num2 %= 5;// num2=num2%2;
		System.out.println(num2);// 2

		short s1 = 10;
		// s1 = s1 + 2;//编译失败
		s1 += 2;// 结论：不会改变变量本身的数据类型
		System.out.println(s1);// 12

		// 开发中，如果希望变量实现+2的操作，有几种方法？(前提：int num = 10;)
		// 方式一：num = num + 2;
		// 方式二：num += 2; (推荐)

		// 开发中，如果希望变量实现+1的操作，有几种方法？(前提：int num = 10;)
		// 方式一：num = num + 1;
		// 方式二：num += 1;
		// 方式三：num++; (推荐)
	}
}

（3）比较运算符
在这里插入图片描述

package com.chb.day03;
/*
运算符之三：比较运算符
==  !=  >  <  >= <=  instanceof

结论：
1.比较运算符的结果是boolean类型
2.区分 ==  和  = 
*/
public class CompareTest {
	public static void main(String[] args) {
		int i = 10;
		int j = 20;
		System.out.println(i == j);//false
		System.out.println(i = j);//20
		
		boolean b1 = true;
		boolean b2 = false;
		System.out.println(b2 == b1);//false
		System.out.println(b2 = b1);//true
	}
}

（4）逻辑运算符
在这里插入图片描述

package com.chb.day03;

/*
运算符之四：逻辑运算符
&  && |  || ! ^

说明：
1.逻辑运算符操作的都是boolean类型的变量
*/
public class LogicTest {
	public static void main(String[] args) {
		// 区分& 与 &&
		// 相同点1：& 与 && 的运算结果相同
		// 相同点2：当符号左边是true时，二者都会执行符号右边的运算
		// 不同点：当符号左边是false时，&继续执行符号右边的运算。&&不再执行符号右边的运算。
		// 开发中，推荐使用&&
		boolean b1 = true;
		b1 = false;
		int num1 = 10;
		if (b1 & (num1++ > 0)) {
			System.out.println("我现在在北京");
		} else {
			System.out.println("我现在在南京");
		}
		System.out.println("num1 = " + num1);// 我现在在南京,num1 = 11

		boolean b2 = true;
		b2 = false;
		int num2 = 10;
		if (b2 && (num2++ > 0)) {
			System.out.println("我现在在北京");
		} else {
			System.out.println("我现在在南京");
		}

		System.out.println("num2 = " + num2);// 我现在在南京,num2 = 10

		// 区分：| 与 ||
		// 相同点1：| 与 || 的运算结果相同
		// 相同点2：当符号左边是false时，二者都会执行符号右边的运算
		// 不同点3：当符号左边是true时，|继续执行符号右边的运算，而||不再执行符号右边的运算
		// 开发中，推荐使用||
		boolean b3 = false;
		b3 = true;
		int num3 = 10;
		if (b3 | (num3++ > 0)) {
			System.out.println("我现在在北京");
		} else {
			System.out.println("我现在在南京");
		}
		System.out.println("num3 = " + num3);//我现在在北京,num3=11

		boolean b4 = false;
		b4 = true;
		int num4 = 10;
		if (b4 || (num4++ > 0)) {
			System.out.println("我现在在北京");
		} else {
			System.out.println("我现在在南京");
		}
		System.out.println("num4 = " + num4);//我现在在北京,num4=10
	}

}

（5）位运算符
在这里插入图片描述

package com.chb.day03;

/*
运算符之五：位运算符 （了解）

结论：
1. 位运算符操作的都是整型的数据
2. << ：在一定范围内，每向左移1位，相当于 * 2
   >> :在一定范围内，每向右移1位，相当于 / 2
*/
public class BitTest {
	public static void main(String[] args) {
		int i = 20;
		System.out.println("i << 2 :" + (i << 2));
		System.out.println("i >> 2 :" + (i >> 2));

		// 练习：交换两个变量的值
		int num1 = 10;
		int num2 = 20;
		System.out.println("num1 = " + num1 + ",num2 = " + num2);

		// 方式一：定义临时变量的方式
		// 推荐的方式
		int temp = num1;
		num1 = num2;
		num2 = temp;

		// 方式二：好处：不用定义临时变量
		// 弊端：① 相加操作可能超出存储范围 ② 有局限性：只能适用于数值类型
		// num1 = num1 + num2;
		// num2 = num1 - num2;
		// num1 = num1 - num2;

		// 方式三：使用位运算符
		// 有局限性：只能适用于数值类型
		// num1 = num1 ^ num2;
		// num2 = num1 ^ num2;
		// num1 = num1 ^ num2;

		System.out.println("num1 = " + num1 + ",num2 = " + num2);

	}
}

（6）三元运算符
在这里插入图片描述
注：凡是能使用三元运算符的，都可以用if-else替换，反之不成立

package com.chb.day03;

/*
运算符之六：三元运算符
1.结构：(条件表达式)? 表达式1 : 表达式2
2. 说明
① 条件表达式的结果为boolean类型
② 根据条件表达式真或假，决定执行表达式1，还是表达式2.
  如果表达式为true，则执行表达式1。
  如果表达式为false，则执行表达式2。
③ 表达式1 和表达式2要求是一致的。
④ 三元运算符可以嵌套使用

3. 
凡是可以使用三元运算符的地方，都可以改写为if-else
反之，不成立。

4. 如果程序既可以使用三元运算符，又可以使用if-else结构，那么优先选择三元运算符。原因：简洁、执行效率高。
*/
public class SanYuanTest {
	public static void main(String[] args) {
		// 获取两个整数的较大值
		int m = 12;
		int n = 5;
		int max = (m > n) ? m : n;
		System.out.println(max);

		// 获取三个数的最大值
		int n1 = 12;
		int n2 = 30;
		int n3 = -43;
		int max1 = (n1 > n2) ? n1 : n2;
		int max2 = (max1 > n3) ? max1 : n3;
		System.out.println(max2);

		// 不建议
		int max3 = (((n1 > n2) ? n1 : n2) > n3) ? ((n1 > n2) ? n1 : n2) : n3;
		System.out.println(max3);

		// 该写成if-else:
		if (m > n) {
			System.out.println(m);
		} else {
			System.out.println(n);
		}
	}
}

5、分支语句（选择语句）

（1）if-else
在这里插入图片描述

package com.chb.day03;

/*
分支结构中的if-else（条件判断结构）

三种结构
第一种：
if(条件表达式){
	执行表达式
}

第二种：二选一
if(条件表达式){
	执行表达式1
}else{
	执行表达式2
}

第三种：n选一
if(条件表达式){
	执行表达式1
}else if(条件表达式){
	执行表达式2
}else if(条件表达式){
	执行表达式3
}
...
else{
	执行表达式n
}
*/
public class IfTest {
	public static void main(String[] args) {
		// 举例1
		int heartBeats = 39;
		if (heartBeats < 60 || heartBeats > 100) {
			System.out.println("需要做进一步检查");
		}
		System.out.println("检查结束");

		// 举例2
		int age = 23;
		if (age < 18) {
			System.out.println("你还可以看动画片");
		} else {
			System.out.println("你可以看成人电影了");
		}

		// 举例3
		if (age < 0) {
			System.out.println("您输入的数据非法");
		} else if (age < 18) {
			System.out.println("青少年时期");
		} else if (age < 35) {
			System.out.println("青壮年时期");
		} else if (age < 60) {
			System.out.println("中年时期");
		} else if (age < 120) {
			System.out.println("老年时期");
		} else {
			System.out.println("你是要成仙啊~~");
		}
	}
}

package com.chb.day04;

/*
如何从键盘获取不同类型的变量：需要使用Scanner类

具体实现步骤：
1.导包：import java.util.Scanner;
2.Scanner的实例化:Scanner scan = new Scanner(System.in);
3.调用Scanner类的相关方法（next() / nextXxx()），来获取指定类型的变量

注意：
需要根据相应的方法，来输入指定类型的值。如果输入的数据类型与要求的类型不匹配时，会报异常：InputMisMatchException
导致程序终止。
*/
import java.util.Scanner;

public class ScannerTest {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);

		System.out.println("请输入你的姓名：");
		String name = scan.next();
		System.out.println(name);

		System.out.println("请输入你的体重：");
		double weight = scan.nextDouble();
		System.out.println(weight);

		System.out.println("你是否相中我了呢？(true/false)");
		boolean isLove = scan.nextBoolean();
		System.out.println(isLove);

		// 对于char型的获取，Scanner没有提供相关的方法。只能获取一个字符串
		System.out.println("请输入你的性别：(男/女)");
		String gender = scan.next();// "男"
		char genderChar = gender.charAt(0);// 获取索引为0位置上的字符
		System.out.println(genderChar);
	}
}

package com.chb.day04;
/*
编写程序：由键盘输入三个整数分别存入变量num1、num2、num3，
对它们进行排序(使用 if-else if-else),并且从小到大输出。

说明：
1. if-else结构是可以相互嵌套的。
2. 如果if-else结构中的执行语句只有一行时，对应的一对{}可以省略的。但是，不建议大家省略。
*/
import java.util.Scanner;

public class IfTest2 {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);

		System.out.println("请输入第一个整数：");
		int num1 = scanner.nextInt();
		System.out.println("请输入第二个整数：");
		int num2 = scanner.nextInt();
		System.out.println("请输入第三个整数：");
		int num3 = scanner.nextInt();

		if (num1 >= num2) {
			if (num3 >= num1)
				System.out.println(num2 + "," + num1 + "," + num3);
			else if (num3 <= num2)
				System.out.println(num3 + "," + num2 + "," + num1);
			else
				System.out.println(num2 + "," + num3 + "," + num1);

		} else {
			if (num3 >= num2)
				System.out.println(num1 + "," + num2 + "," + num3);
			else if (num3 <= num1)
				System.out.println(num3 + "," + num1 + "," + num2);
			else
				System.out.println(num1 + "," + num3 + "," + num2);

		}

	}
}

在这里插入图片描述
生成[a,b]：(int)(Math.random()*(b-a+1)+a

package com.chb.day04;

public class IfExer {
	public static void main(String[] args) {
		int x = 4;
		int y = 1;
		if (x > 2) 
			if (y > 2) 
                System.out.println(x + y);
				//System.out.println("atguigu");
			else //就近原则
				System.out.println("x is " + x);//输出x is 4
		

		//课后练习3：测算狗的年龄
		int dogAge = 6;
		if(dogAge >= 0 && dogAge <= 2){
			System.out.println("相当于人的年龄：" + dogAge * 10.5);
		}else if( dogAge > 2){
			System.out.println("相当于人的年龄：" + (2 * 10.5 + (dogAge - 2) * 4));
		}else{
			System.out.println("狗狗还没出生呢！");
		}

		//课后练习4：如何获取一个随机数：10 - 99
		int value = (int)(Math.random() * 90 + 10);// [0.0,1.0) --> [0.0,90.0) --->[10.0, 100.0) -->[10,99]
		System.out.println(value);
		//公式：[a,b]  :  (int)(Math.random() * (b - a + 1) )+ a
	}
}

（2）switch-case
在这里插入图片描述

在这里插入图片描述

package com.chb.day04;

/*
分支结构之二：switch-case

1.格式
switch(表达式){
case 常量1:
	执行语句1;
	//break;

case 常量2:
	执行语句2;
	//break;

...

default:
	执行语句n;
	//break;

}

2.说明：
① 根据switch表达式中的值，依次匹配各个case中的常量。一旦匹配成功，则进入相应case结构中，调用其执行语句。
  当调用完执行语句以后，则仍然继续向下执行其他case结构中的执行语句，直到遇到break关键字或此switch-case结构
  末尾结束为止。

② break,可以使用在switch-case结构中，表示一旦执行到此关键字，就跳出switch-case结构

③ switch结构中的表达式，只能是如下的6种数据类型之一：
   byte 、short、char、int、枚举类型(JDK5.0新增)、String类型(JDK7.0新增)

④ case 之后只能声明常量。不能声明范围。

⑤ break关键字是可选的。

⑥ default:相当于if-else结构中的else.  
  default结构是可选的，而且位置是灵活的。
*/
public class SwitchCaseTest {
	public static void main(String[] args) {
		int number = 2;
		switch (number) {

		case 0:
			System.out.println("zero");
			break;
		case 1:
			System.out.println("one");
			break;
		case 2:
			System.out.println("two");
			break;
		case 3:
			System.out.println("three");
			break;
		default:
			System.out.println("other");
			// break;
		}

		String season = "summer";
		switch (season) {
		case "spring":
			System.out.println("春暖花开");
			break;
		case "summer":
			System.out.println("夏日炎炎");
			break;
		case "autumn":
			System.out.println("秋高气爽");
			break;
		case "winter":
			System.out.println("冬雪皑皑");
			break;
		default:
			System.out.println("季节输入有误");
			break;
		}
		
		// **************如下的两种情况都编译不通过*********************
		// 情况一

//		boolean isHandsome = true;
//		switch (isHandsome) {
//
//		case true:
//			System.out.println("我好帅啊~~~");
//			break;
//
//		case false:
//			System.out.println("我好丑啊~~~");
//			break;
//		default:
//			System.out.println("输入有误~~~");
//		}
//
//		// 情况二
//
//		int age = 10;
//		switch (age) {
//		case age > 18:
//			System.out.println("成年了");
//			break;
//		default:
//			System.out.println("未成年");
//		}

	}
}

package com.chb.day04;

/*
例题：对学生成绩大于60分的，输出“合格”。低于60分的，输出“不合格”。

说明：如果switch-case结构中的多个case的执行语句相同，则可以考虑进行合并。
*/
public class SwitchCaseTest1 {
	public static void main(String[] args) {
		/*
		 * int score = 78; switch(score){ case 0:
		 * 
		 * case 1:
		 * 
		 * case 2:
		 * 
		 * ... case 100:
		 * 
		 * }
		 */

		/*
		 * int score = 78; if(score >= 60){
		 * 
		 * }else{
		 * 
		 * }
		 */
		int score = 78;
		switch (score / 10) {
		case 0:
		case 1:
		case 2:
		case 3:
		case 4:
		case 5:
			System.out.println("不及格");
			break;
		case 6:
		case 7:
		case 8:
		case 9:
		case 10:
			System.out.println("及格");
			break;

		}

		// 更优的解决方案：
		switch (score / 60) {
		case 0:
			System.out.println("不及格");
			break;
		case 1:
			System.out.println("及格");
			break;
		}
	}
}

在这里插入图片描述

package com.chb.day04;

import java.util.Scanner;

/*
编写程序：从键盘上输入2019年的“month”和“day”，要求通过程序输出输入的日期为2019年的第几天。

2  15:  31 + 15

5 7: 31 + 28 + 31 + 30 + 7 

....

说明:break在switch-case中是可选的
*/
public class SwitchCaseTest2 {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入2019年的month：");
		int month = scan.nextInt();
		System.out.println("请输入2019年的day：");
		int day = scan.nextInt();


		//定义一个变量来保存总天数
		int sumDays = 0;

		//方式一：冗余
		/*
		
		if(month == 1){
			sumDays = day;
		}else if(month == 2){
			sumDays = 31 + day;
		}else if(month == 3){
			sumDays = 31 + 28 + day;
		}else if(month == 4){
			sumDays = 31 + 28 + 31 + day;
		}
		//...
		else{//month == 12
			//sumDays = ..... + day;
		}

		*/

		//方式二：冗余
		/*
		switch(month){
		case 1:
			sumDays = day;
			break;
		case 2:
			sumDays = 31 + day;
			break;
		case 3:
			sumDays = 31 + 28 + day;
			break;
		...
		}
		*/

		switch(month){
		case 12:
			sumDays += 30;
		case 11:
			sumDays += 31;
		case 10:
			sumDays += 30;
		case 9:
			sumDays += 31;
		case 8:
			sumDays += 31;
		case 7:
			sumDays += 30;
		case 6:
			sumDays += 31;
		case 5:
			sumDays += 30;
		case 4:
			sumDays += 31;
		case 3:
			sumDays += 28;
		case 2:
			sumDays += 31;
		case 1:
			sumDays += day;
		}

		System.out.println("2019年" + month + "月" + day + "日是当年的第" + sumDays + "天");
	}
}

运行结果：
在这里插入图片描述

package com.chb.day04;
/*
从键盘分别输入年、月、日，判断这一天是当年的第几天
 
   注：判断一年是否是闰年的标准：
       1）可以被4整除，但不可被100整除
	或
       2）可以被400整除


说明：
1. 凡是可以使用switch-case的结构，都可以转换为if-else。反之，不成立。
2. 我们写分支结构时，当发现既可以使用switch-case,（同时，switch中表达式的取值情况不太多），
  又可以使用if-else时，我们优先选择使用switch-case。原因：switch-case执行效率稍高。

*/
import java.util.Scanner;
public class SwitchCaseExer {
	public static void main(String[] args) {
		
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入year：");
		int year = scan.nextInt();
		System.out.println("请输入month：");
		int month = scan.nextInt();
		System.out.println("请输入day：");
		int day = scan.nextInt();


		//定义一个变量来保存总天数
		int sumDays = 0;

		switch(month){
		case 12:
			sumDays += 30;
		case 11:
			sumDays += 31;
		case 10:
			sumDays += 30;
		case 9:
			sumDays += 31;
		case 8:
			sumDays += 31;
		case 7:
			sumDays += 30;
		case 6:
			sumDays += 31;
		case 5:
			sumDays += 30;
		case 4:
			sumDays += 31;
		case 3:
			//sumDays += 28;
			//判断year是否是闰年
			if((year % 4 == 0 && year % 100 != 0 ) || year % 400 == 0){
				sumDays += 29;
			}else{
				sumDays += 28;
			}

		case 2:
			sumDays += 31;
		case 1:
			sumDays += day;
		}

		System.out.println(year + "年" + month + "月" + day + "日是当年的第" + sumDays + "天");
	}
}

在这里插入图片描述
注：凡是能用switch-case的，一定能用if-else，反之不成立

6、循环语句

在这里插入图片描述

（1）for循环

package com.chb.day04;
/*
For循环结构的使用
一、循环结构的4个要素
① 初始化条件
② 循环条件  --->是boolean类型
③ 循环体
④ 迭代条件

二、for循环的结构

for(①;②;④){
	③
}

执行过程：① - ② - ③ - ④ - ② - ③ - ④ - ... - ②

*/
public class ForTest {
	public static void main(String[] args) {
		for (int i = 0; i < 5; i++) {
			System.out.println("Hello World");
		}
		//i:在for循环内有效。出了for循环就失效了。
		//System.out.println(i);
		
		//练习
		int num=0;
		for (System.out.print("a"); num < 3; System.out.print("c"),num++) {
			System.out.print("b");
		}
		System.out.println();
		//注意：用逗号隔开的属于同一个部分。输出结果：abcbcbc
		
		//例题：遍历100以内的偶数,输出所有偶数的和,输出偶数的个数
		int sum=0;
		int count=0;
		for (int i = 1; i <=100; i++) {
			if(i%2==0) {
				sum+=i;//记录所有偶数的和
				count++;//记录偶数的个数
			}
			//System.out.println("总和为：" + sum);
		}
		System.out.println("总和为：" + sum);
		System.out.println("个数为：" + count);
	}
}

运行结果：
在这里插入图片描述

package com.chb.day4;
/**
 * 用for循环和break求两个数的最大公约数和最小公倍数
 * 说明：break关键字的使用：一旦在循环中执行到break，就跳出循环
 */
import java.util.Scanner;

public class testfor {
	public static void main(String[] args) {
		Scanner s=new Scanner(System.in);
		System.out.println("请输入第一个正整数");
		int m=s.nextInt();
		System.out.println("请输入第二个正整数");
		int n=s.nextInt();
		//获取两个数的较小值
		int min=(m>=n)?m:n;
		//获取两个数的较大值
		int max=(m>=n)?m:n;
		
		for (int i = min; i >=1; i--) {//从后往前遍历
			if(m%i==0&&n%i==0) {
				System.out.println("最大公约数为"+i);
				break; //取一个就结束
			}
		}
		
		for (int i = max; i <=m*n; i++) {//从前往后遍历
			if(i%m==0&&i%n==0) {
				System.out.println("最小大公倍约数为"+i);
				break; //取一个就结束
			}
		}
	}
}

运行结果：
在这里插入图片描述
（2）while循环

package com.chb.day05;
/*
While 循环的使用

一、循环结构的4个要素
① 初始化条件
② 循环条件  --->是boolean类型
③ 循环体
④ 迭代条件

二、while循环的结构

①
while(②){
	③;
	④;
}

执行过程：① - ② - ③ - ④ - ② - ③ - ④ - ... - ②

说明：
1.写while循环千万小心不要丢了迭代条件。一旦丢了，就可能导致死循环！
2.我们写程序，要避免出现死循环。
3.for循环和while循环是可以相互转换的！ 
  区别：for循环和while循环的初始化条件部分的作用范围不同。


*/
public class WhileTest {
	public static void main(String[] args) {
		//遍历100以内的所有偶数
		int i=1;
		while(i<=100) {
			if(i % 2 == 0){
				System.out.println(i);
			}
			
			i++;
		}
		//出了while循环以后，i仍可以调用。
		System.out.println(i);//101
	}
}

（3）do-while循环
在这里插入图片描述

package com.chb.day05;
import java.util.Scanner;

/*
题目：
从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时结束程序。

说明：
1. 不在循环条件部分限制次数的结构：for(;;) 或 while(true)
2. 结束循环有几种方式？
     方式一：循环条件部分返回false
	 方式二：在循环体中，执行break
*/
public class ForWhileTest {
	public static void main(String[] args) {
		Scanner scan=new Scanner(System.in);
		int sum1=0;
		int sum2=0;
		while(true) {//或者用for(;;)
			int n=scan.nextInt();
			if(n>0) {
				sum1++;
			}else if(n<0){
				sum2++;
			}else {
				break;
			}
		}
		System.out.println("正数个数为："+sum1);
		System.out.println("负数个数为："+sum2);
	}
}

运行结果：
在这里插入图片描述
（4）嵌套循环

注：外层循环控制行数，内存循环控制列数

package com.chb.day05;

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

运行结果：
在这里插入图片描述

package com.chb.day05;
//9*9乘法表
public class test5 {
	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();
		}
	}
}

运行结果：
在这里插入图片描述

package com.chb.day05;
/*
100以内的所有质数的输出。
质数：素数，只能被1和它本身整除的自然数。-->从2开始，到这个数-1结束为止，都不能被这个数本身整除。

最小的质数是：2
*/
public class PrimeNumberTest {
	public static void main(String[] args) {
		boolean isFlag = true;//标识i是否被j除尽，一旦除尽，修改其值
		for(int i = 2;i <= 100;i++){//j:被i去除
		    //或者在这设置boolean isFlag = true，后面就不需要把马甲洗干净
			for (int j = 2; j <i; j++) {
				if(i % j == 0){//i被j除尽
					isFlag = false;
				}
			}
			//
			if(isFlag == true){
				System.out.println(i);
			}
			//重置isFlag,把马甲洗干净
			isFlag = true;//或者把boolean isFlag = true;放入外循环中
		}
	}
}

package com.chb.day05;
/*
100000以内的所有质数的输出。实现方式一
质数：素数，只能被1和它本身整除的自然数。-->从2开始，到这个数-1结束为止，都不能被这个数本身整除。

对PrimeNumberTest.java文件中质数输出问题的优化
*/
public class PrimeNumberTest2 {
	public static void main(String[] args) {
		boolean isFlag = true;//标识i是否被j除尽，一旦除尽，修改其值
		int count = 0;//记录质数的个数
		long start=System.currentTimeMillis();//获取当前时间的毫秒数
		for(int i = 2;i <= 100000;i++){//j:被i去除
			for (int j = 2; j <i; j++) {//优化二:for(int j = 2;j <= Math.sqrt(i);j++)
				if(i % j == 0){//i被j除尽
					isFlag = false;
				break;//优化一：只对本身非质数的自然数是有效的。
				}
			}
			//
			if(isFlag == true){
				//System.out.println(i);
				count++;
			}
			//重置isFlag
			isFlag = true;
		}
		long end = System.currentTimeMillis();
		System.out.println("质数的个数为：" + count);
		//输出所有质素时  ：不优化：15728 - 优化一：break:1397 - 优化二：182,优化一优化二同时：110
		//输出质素个数时  ：不优化：14524 - 优化一：break:1401 - 优化二：94,优化一优化二同时：23  这说明打印占了很大的时间啊
		System.out.println("所花费的时间为：" + (end - start));
	}
}

（5）break和continue关键字
在这里插入图片描述

注：
不同点：break表示结束当前循环；continue表示结束当次循环，开始下一次循环。
相同点：关键字后面不能声明执行语句（执行不了）

package com.chb.day05;
/*
break和continue关键字的使用
			使用范围		循环中使用的作用(不同点)	相同点
break:		switch-case			
			循环结构中		结束当前循环			关键字后面不能声明执行语句	

continue:	循环结构中		结束当次循环			关键字后面不能声明执行语句



*/
public class BreakContinueTest {
	public static void main(String[] args) {
//		for (int i = 1; i < 10; i++) {
//			if(i%4==0) {
//				
//				//break;//123
//				continue;//1235679
//			}
//			System.out.print(i);
//			
//		}
		
		label:for(int i = 1;i <= 4;i++){
			
			for(int j = 1;j <= 10;j++){
				
				if(j % 4 == 0){
					//break;//默认跳出包裹此关键字最近的一层循环。
//					123
//					123
//					123
//					123						     
										   										   
					//continue;
//					123567910
//					123567910
//					123567910
//					123567910

					//break label;//结束指定标识的一层循环结构
					//123
					
					continue label;//结束指定标识的一层循环结构当次循环
					//123123123123
				}
				
				System.out.print(j);
			}
			
			System.out.println();
		}
		
	}
}

在这里插入图片描述