学习（运算符 、键盘录入 、分支语句 、循环语句 、死循环、跳转语句）

一、运算符

运算符可分为：算数运算符、自增自减运算符、赋值运算符、逻辑运算符、比较运算符、位移运算符、三元运算符

算术运算符

1、用于做运算使用的运算符
2、+ 、- 、* 、 / 、 %
3、+：（1）表示一个正数
（2）进行加法运算
（3）拼接字符串
4、-: (1)表示一个负数
（2）：做减法运算
5、*：做乘法运算
6、/：（1）做除法运算
注意：如果是两个整数相除，得到的结果还是一个整数。
如果任意一个整数是小数，那么结果就是小数
7、%:取余运算符（取模运算符）
结果：运算的结果是两个整数相除的余数
注意：取余的结果的符号只和%前面的操作数有关
作用：判断一个数是否被整数，判断一个数的奇偶

public class Demo_1 {
	public static void main(String[] args) {
//		算数运算符
//		+
		System.out.println(+12);
		System.out.println(21 + 2);
		System.out.println("hello" + " java");
//		/
		System.out.println(5 / 2);//两个整数进行相除，得到的结果还是一个整数
		System.out.println(5.0 / 2);//如果任意一个整数是小数，那么结果就是小数
//		%
		System.out.println(5 % -2);// 5 / 2 = 2 ....1
		System.out.println(-2 % 5);// 2 / 5 = 0.....2
		
		int i = 45;
		System.out.println(i % 10);
		System.out.println(i / 10);
	}
}

自增自减运算符

1、++，–
2、++：自增运算符
3、–：自减运算符
作用：在【变量】的基础上进行+1或者-1的操作
4、注意：
（1.1）++，——既可以写在 变量的前面，也可以写在变量的后面
（1.2）当i++和++i作为一条单独的语句存在的时候，++在前在后没有区别都是在变量的基础之上进行+1的操作
（1.3）当i++和++i做为表达式存在的时候，++在前，先运算（先进行+1）再取值，++再变量的后面，先取出变量的值，再进行+1的操作。
（2.1）–，——既可以写在 变量的前面，也可以写在变量的后面
（2.2）当i- -和- -i作为一条单独的语句存在的时候，- -在前在后没有区别都是在变量的基础之上进行-1的操作
（2.3）当 i - -和- - i做为表达式存在的时候，- - 在前，先运算（先进行 - 1）再取值，- -再变量的后面，先取出变量的值，再进行 - 1的操作。

public class Demo_2 {
//	自增自减运算符
	public static void main(String[] args) {
//		45++;在【变量】的基础上进行+1或者-1的操作
		int i = 10;
//		i++;
		++i;
//		i--;
		System.out.println(i);

		int j = 20;
//		System.out.println(j++);// 20,先取值，再运算
//		System.out.println(j);
		
		System.out.println(++j);// 21，先运算（+1），再取值
		System.out.println(j);

	}
}

赋值运算符

1、用于给变量进行赋值的运算符
2、分类：
基础的赋值运算符 : =
扩展的赋值运算符 ： +=， -=， /=, *=, %=
3、基本的赋值运算符
将赋值运算符右边的值，赋值给左边的变量
4、扩展的赋值运算符
将运算的结果赋值给左边的变量

public class Demo_3 {
	public static void main(String[] args) {
//		赋值运算符
//		=
		int i = 10;//将赋值运算符右边的值，赋值给左边的变量
//		 +=， -=， /=, *=, %=
		int j = 20;
		j += 10;//j = j + 10;  为了书写方便， 
		
		System.out.println(j);//30
		
		j %= 3; //j = j % 2;
		System.out.println(j);
	}
}

比较运算符

1、用于做比较运算的运算符，比较两个数据大小关系的运算符
2、分类：
>,<,>=,<=:可以比较两个数据的大小关系
==，!=:比较两个数据是否相等的关系
3、运算结果：
布尔类型，只有true和false两种结果。

public class Demo_4 {
//	比较运算符
	public static void main(String[] args) {
//		>,<,>=,<=
		System.out.println(4 > 3);//true
		System.out.println(4 < 3);//false
		System.out.println(3 >= 3);//true
		System.out.println(4 <= 4);//true
//		注意： 1 < a < 3，是不合法的
		int a = 2;
//		System.out.println(1 < a < 3);//java不支持 这种写法
		System.out.println("0-------------------------");
//		==，!=
		System.out.println(3 == 3);//false
		System.out.println(4 != 3 );//true
	}
}

逻辑运算符

1、用于处理逻辑运算的使用的运算符
2、&&（逻辑与） &（按位与）
||（逻辑或） |（按位与）
3、&&：进行对逻辑值进行处理的时候，没有区别
全真为真，否则为假
true && true true
true && fasle false
false && true false
false && false false
4、||、逻辑或，全假为假，否则为真
true || true true
true || fasle true
false || true true
false || false false
注意：
boolean boo1 = (a > 20) && (b++ > 10);
boolean boo1 = (a > 20) & (b++ > 10);
&&，第一个表达式运算结果为false，那么就不会计算第二个表达式了。效率更高
&,按位与，即使第一个表达式运算结果为false，还会计算第二个表达式。
5、!;逻辑非，遇真为假，遇假为真
!true false
!false true

public class Demo_5 {
	public static void main(String[] args) {
//		逻辑运算符
//		&&  全真为真，否则为假
		System.out.println(true & true);
		System.out.println(true & false);
		System.out.println(false & true);
		System.out.println(false & false);
		System.out.println("------------------------------------");
//		||  全假为假，否则为真
		System.out.println(true || true);
		System.out.println(true || false);
		System.out.println(false || true);
		System.out.println(false || false);
//		逻辑与和按位与的区别
		System.out.println("----------------------");
		int a = 10;
		int b = 20;
//		boolean boo1 = (a > 20) && (b++ > 10);
		boolean boo1 = (a > 20) & (b++ > 10);
//		&&，第一个表达式运算结果为false，那么就不会计算第二个表达式了。效率更高
//		&,按位与，即使第一个表达式运算结果为false，还会计算第二个表达式。
		System.out.println(boo1);
		System.out.println(b);
//		按位与
		System.out.println(8 & 2);
//		1000   8
//		0010   2
//		0000
//		按位或
		System.out.println(8 | 2);
//		1000   8
//		0010   2
//		1010   10
		System.out.println(!true);
		System.out.println(!false);
	}
}

位移运算符

1、对于数据在内存中的表示，进行按照位移进行移动，以此达到进行运算的目的。
2、说明：只能操作整数类型的数据，运算结果还是一个整数
3、<<,>> ,>>>
4、<<;左移运算符，每次移动一位，会将原来的数字扩大2倍
5、>>:右移运算符，每移动一位，会将原来的数字缩小为原来的2分之1
6、>>>:无符号的右移：每移动一位，会将原来的数字缩小为原来的2分之1，这个只能针对正数使用。

	public static void main(String[] args) {
//		位移运算符
		System.out.println(-4 << 2);//向左移动一位,乘以2
		System.out.println(-4 >> 2);
		
		System.out.println(4 >>> 2);
//		无符号右移，不能针对负数进行移动的
//		System.out.println(-4 >>> 2);
	}
}

三元运算符

1、元：可以操作的数据或者表达式
2、三元运算符：同时可以操作三个数据或者三个表达式的运算符
3、运算符： ? : 将三个数据或者三个表达式进行分隔
4、格式：
表达式1（数据） ? 表达式2（数据） : 表达式3（数据）
5、说明
（1）表达式1（数据）运算结果必须是boolean类型，（boolean类型的表达式）
（2）表达式2和表达式3没有任何要求，可以是任意的数据或者表达式
6、运算流程
（1）计算表达式1的结果，结果只有两种，true或者false
（2）如果表达式1为true，就会将表达式2（数据2）作为整个三元表达式的值
（3）如果表达式1为false，就会将表达式3（数据3）作为整个三元表达式的值
7、注意：
（1）三元运算表达式，不能单独作为一条语句存在，除非定义一个变量接收三个运算表达式运算的结果，或者直接打印三元运算表达式的结果
（2）如果表达式2和表达式3,数据类型不一致,不能定义一个具体类型的变量进行接收,但是可以直接打印

public class Demo_7 {
	public static void main(String[] args) {
//		三元运算表达式
//		表达式1（数据） ? 表达式2（数据） : 表达式3（数据）
//		表达式1，必须是boolean类型的
		System.out.println(5 < 4 ? "大于" : "小于");
//		运算流程
//		（1）计算表达式1的结果，结果只有两种，true或者false
//		（2）如果表达式1为true，就会将表达式2（数据2）作为整个三元表达式的值
//		（3）如果表达式1为false，就会将表达式3（数据3）作为整个三元表达式的值
//		注意：
//		（1）三元运算表达式，不能单独作为一条语句存在，除非定义一个变量接收三个运算表达式运算的结果，或者直接打印三元运算表达式的结果
//		5 < 4 ? "大于" : "小于";不正确的写法
//		String str = "小于";
//		System.out.println("小于");
		String str = 5 < 4 ? "大于" : "小于";// 定义一个变量接收一下三运运算表达式的运算结果
		System.out.println(str);
//		（2）如果表达式2和表达式3,数据类型不一致,不能定义一个具体类型的变量进行接收,但是可以直接打印
//		char str1 = 5 < 4 ? "大于" : '小';错误的
		System.out.println(5 < 4 ? "大于" : '小');
	}
}

三个运算符的练习

1、定义四个int类型变量，获取四个变量中的最大值

public class Demo_8 {
//	1、定义四个int类型变量，获取四个变量中的最大值
	public static void main(String[] args) {
		int m = 10;
		int n = 20;
		int x = 5;
		int y = 6;
//		先比较m和n中的最大值
		int maxMn = m > n ? m : n;
//		System.out.println(maxMn);
//		再比较x和y中的较大值
		int maxXy = x > y ? x : y;
//		System.out.println(maxXy);
//		最后再进行比较
		int max = maxMn > maxXy ? maxMn : maxXy;
//		int max = (m > n ? m : n) > (x > y ? x : y) ? (m > n ? m : n) : (x > y ? x : y) ;
		System.out.println(max);
	}
}

二、键盘录入

1、键盘录入：在程序的运行过程中，可以让用户录入一些数据，存储到变量内存中，在后续的过程中，可以对该数据进行一些操作。
2、步骤：
第一步：导包，在类声明的上面，import java.util.Scanner;
第二步：创建键盘录入对象，Scanner sc = new Scanner(System.in);
第三步：调用Scanner中的nextInt()方法，实现键盘录入一个整数
int i = sc.nextInt();
第四步：就是对键盘录入的数据进行处理或者使用

//java.lang下的所有的类，都可以不导包，直接使用

//第一步：导包，在类声明的上面，import java.util.Scanner;
import java.util.Scanner;

public class Demo_9 {
	public static void main(String[] args) {
//		键盘录入 Scanner
//		第二步：创建键盘录入对象，Scanner sc = new Scanner(System.in);
		Scanner sc = new Scanner(System.in);
//		第三步：调用Scanner中的nextInt()方法，实现键盘录入一个整数
		System.out.println("请输入i的值");
		int i = sc.nextInt();// 定义一个变量接收键盘录入的数据
//		调用几次nextInt（）方法就是录入几个整数
		System.out.println("请输入j的值");
		int j = sc.nextInt();
		System.out.println("j = " + j);
//		第四步：就是对键盘录入的数据进行处理或者使用
		i *= 20;
		System.out.println("i * 20 = " + i);
	}
}

键盘录入一个整数，判断录入数字的奇偶

import java.util.Scanner;
public class Demo_10 {
	public static void main(String[] args) {
//		键盘录入一个整数，判断录入数字的奇偶
//		创建键盘录入对象
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一个整数");
		int i = sc.nextInt();
//		判断i的奇偶
		String str = i % 2 == 0 ? "偶数" : "奇数";
		System.out.println(str);
	}
}

三、分支语句

1、顺序结构
从上到下，从左到右
2、程序到达某种状态的时候，可能会有多种情况，对于每种情况提前准备好，所以对于这种情况就成为分支结构
特点：代码写的多，程序运行的少
3、实现格式
if语句：if如果的意思，满足了特点条件，才能执行指定的代码，可以实现不同的逻辑
if()
if…else()
if…else if()…else if()…else if()…else
switch语句:根据指定的变量的值，匹配和该变量值相同的case语句，执行对应的代码

if语句

if语句的第一种格式

1、格式：
if(布尔表达式){
语句体；
}
2、说明：
（1）if语句后面小括号中的内容，只能是一个布尔表达式，也就是说运算结果只能是true或者false
（2）语句体：可以是任意的语句，满足了判断的条件，才能执行。
3、执行流程
（1）计算布尔表达式的值，结果只有两种，要么为true要么为false
（2）如果布尔表达式的值为true的时候，就会执行语句体
（3）如果布尔表达式的值为false，不会执行语句体

public class Demo_11 {
//	分支结构
	public static void main(String[] args) {
//		if语句的第一种格式
		int age = 18;
		
		if(age >= 18) {//能够控制的代码，只限于if语句后的大括号中
			System.out.println("可以谈恋爱了");
		}
		
		
		System.out.println("if语句和我有关系吗");
//		执行流程
//			（1）计算布尔表达式的值，结果只有两种，要么为true要么为false
//			（2）如果布尔表达式的值为true的时候，就会执行语句体
//			（3）如果布尔表达式的值为false，不会执行语句体
	}
}

if语句的第二种格式

1、格式：
if(布尔表达式){
语句体1；
}else{
语句体2；
}
2、执行流程
（1）计算布尔表达式的值，结果只有true和false
（2）如果布尔表达式的值为true，就执行语句体1，if语句就结束了
（3）如果布尔表达式的值为false，就执行语句体2，if
3、注意：
语句体1和语句体2有没有可能够执行?
没有。
语句体1和语句体2有没有可能够不执行?
没有.至少要执行其中的一条语句。

import java.util.Scanner;

public class Demo_12 {
	public static void main(String[] args) {
//		if语句的第二种格式
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入你的年龄");
		int age = sc.nextInt();
		if(age >= 18) { //在if语句中语句体只有一行代码，可以省略大括号的
//			语句体1
			System.out.println("我终于可以去蹦迪了");
			System.out.println("蹦迪开心吗");
		}
		 else {
			语句体2
			System.out.println("你妈喊你回家吃饭");
		 }
//		执行流程
//		计算布尔表达式的值，结果只有true和false
//		如果布尔表达式的值为true，就执行语句体1
//		如果布尔表达式的值为false，就执行语句体2
	}
}

if语句的第三种格式

1、格式：
if(条件表达式1){
语句体1；
}else if(条件表达式2){
语句体2；
}else if(条件表达式3){
语句体3；
}else if(条件表达式4){
语句体4；
}else if(条件表达式5){
语句体5；
}…else if(条件表达式n){
语句体n;
}else{
语句体n+1;
}
2、执行流程
（1）计算条件表达式1的值，如果为true，就执行语句体1，结束if。。。else if语句
（2）如果条件表达式1的值为false，计算条件表达式2的值，如果为true，就执行语句体2
（3）如果条件表达式2的值为false，，就计算条件表达式3的值，。。。以此类推
（4）如果条件表达式1-条件表达式n的值都为false，就会执行else中的内容
3、说明（注意）：
（1）最后的else是可以有，也可以没有的，如果有了else，那么对于if。。 else if语句而言，至少会执行一条语句
如果没有else那么if。。。else if语句就有可能一条语句都不执行
（2） 有没有可能同时执行多个语句体呢？
没有可能的，即使多个条件判断表达式都满足，只会执行第一个满足条件的语句体，执行完语句体后，if。。。else if语句就结束了，就不会向下再进行匹配了

import java.util.Scanner;

public class Demo_13 {
//	if语句的第三种格式
	public static void main(String[] args) {
//		翻牌子
		Scanner sc = new Scanner(System.in);
		System.out.println("请皇上翻牌子");
		int paizi = sc.nextInt();

		if (paizi == 1) {
			System.out.println("皇后准备侍寝");
		} else if (paizi >= 2) {// 如果paizi =3 ，满足该条件之后，就执行对应的语句体，执行完之后就结束分支语句，不会向下匹配
			System.out.println("杨贵妃准备侍寝");
		} else if (paizi == 3) {
			System.out.println("甄嬛准备侍寝");
		} else if (paizi == 4) {
			System.out.println("容嬷嬷准备侍寝");
		} else if (paizi == 5) {
			System.out.println("淑妃准备侍寝");
		} else {
			System.out.println("妃子不够了，该选妃了");
		}
//		执行流程
//		（1）计算条件表达式1的值，如果为true，就执行语句体1，结束if。。。else if语句
//		（2）如果条件表达式1的值为false，计算条件表达式2的值，如果为true，就执行语句体2
//		（3）如果条件表达式2的值为false，，就计算条件表达式3的值，。。。以此类推
//		（4）如果条件表达式1-条件表达式n的值都为false，就会执行else中的内容
	}
}

switch语句

1、switch：切换，开关
2、格式：
swtich(表达式){
case 常量1：
语句体1；
break；
case 常量2：
语句体2；
break；
case 常量3：
语句体3；
break；
case 常量n：
语句体n；
break；
default：
语句体n+1；
}
case：情况
2、执行流程
（1）计算表达式的值，分别和case后的各个常量进行匹配
（2）如果和常量1匹配 ，就执行语句体1；再执行break；switch语句就结束了
（3）如果和常量1不匹配，那么就判断和常量2是否匹配，如果匹配了，就执行语句体2，执行break，结束swtich语句
（4）以此类推，如果常量1-常量n都没有和表达式的运算结果相匹配，那么就会执行default中的内容，遇到右大括号，结束swtich语句

public class Demo_14 {
	public static void main(String[] args) {
//		switch语句
		char c = 'A';
		switch(c) {
		case 'A':
			System.out.println("选项A不正确");
			break;//打断，中断，结束switch语句
		case 'B':
			System.out.println("选项B不确定，不会就蒙B");
			break;
		case 'C':
			System.out.println("选项C不正确");
			break;
		case 'D':
			System.out.println("选项D正确");
			break;
		default://如果c在case中没有相对应的常量相匹配，最终就会执行default中的内容
			System.out.println("没有此选项，你是学生吗");
		}
		执行流程
//			（1）计算表达式的值，分别和case后的各个常量进行匹配
//			（2）如果和常量1匹配 ，就执行语句体1；再执行break；switch语句就结束了
//			（3）如果和常量1不匹配，那么就判断和常量2是否匹配，如果匹配了，就执行语句体2，执行break，结束swtich语句
//			（4）以此类推，如果常量1-常量n都没有和表达式的运算结果相匹配，那么就会执行default中的内容，遇到右大括号，结束swtich语句
	}
}

switch语句的注意事项

1、swtich：开关，切换
case：情况
break：中断，打断
default：默认
2、表达式（变量）：
类型是有要求的，一共只有六中
jdk1.5之前：byte short，char ，int
jdk1.5：枚举类型
jdk1.7：String
3、case后面只能跟的是常量，不能跟变量
4、每个case后面，一定要跟上一个break语句，作用：结束swtich语句，如果在case后面，不跟break语句，那么就无法正常的结束swtich语句。会发生case穿透。case穿透的利用：多个情况是相同的逻辑，那么就可以使用case穿透完成代码的简化。
5、default语句可以放在任意的位置，都是最后进行匹配的，如果不是放在最后，一定要注意case穿透问题，加上break
default，可以写也可以不写，如果写了，swtich语句至少要执行一条语句，如果不写swtich语句就有可能一条都不执行

public class Demo_15 {
	public static void main(String[] args) {
//		switch语句的注意事项
//		（1）表达式的运算结果或者变量的类型是有要求，必须是byte ，short ，char ，int，String ，枚举
//		char c = 'A';
		int i = 1;
//		long l = 2;不可以
		
		String str = "two";
		switch(str) {
//		default，可以写也可以不写
		default://default语句可以放在任意的位置，都是最后进行匹配的，如果不是放在最后，一定要注意case穿透问题，加上break
			System.out.println("没有此选项，你是学生吗");
			break;
//		case 'A':
//		case 1: 
		case "one":
//		case s:case后只能跟的是常量
			System.out.println("one");
//			break;// 如果不加break会发生case穿透，直接就执行到下个case中的语句，并不做匹配
//		case 'B':
//		case 2:
		case "two":
			System.out.println("two");
//			break;
//		case 'C':
//		case 3:
		case "three":
			System.out.println("three");
			break;
//		case 'D':
//		case 4:
		case "four":
			System.out.println("four");
			break;
		
		}
	}
}

swtich语句练习

1、键盘录入一个月份，输出这个月份对应的季节
2、春季 3，4，5 夏季 6，7，8，秋季9，10，11冬季12，1，2

import java.util.Scanner;

public class Demo_16 {
	public static void main(String[] args) {
//		1、键盘录入一个月份，输出这个月份对应的季节
//		2、春季 3，4，5 夏季 6，7，8，秋季9，10，11冬季12，1，2
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一个月份");
		int month = sc.nextInt();
		switch(month) {
		
		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;
		case 12:
		case 1:
		case 2:
			System.out.println("冬季");
			break;
		default:
			System.out.println("你输入的月份不对");
		}
	}
}

四、循环语句

1、日常生活中
日出日落，月圆月缺，花开花落
2、循环语句：对于某些需要重复执行的，相同的或者相似的代码，可以使用某种格式完成对这种重复代码的一种简写格式。
3、实现语句
for语句【常用】
while语句【常用】
do…while语句【不常用】

for语句

1、格式：
for(初始化语句表达式;循环条件判断表达式;初始化语句改变表达式){
循环体语句；
}
2、说明：
初始化语句表达式：声明一个变量，用于记录循环的次数。 int i = 0；
循环条件判断表达式：控制循环的执行条件，结果也是一个boolean类型 i < 10
初始化语句改变表达式：将初始化语句中的变量进行变化，一般是向着循环不能执行的方面进行变化。 i++；
循环体语句：要重复循环执行的代码。
3、执行流程

public class Demo_17 {
	public static void main(String[] args) {
//		老板，让你打印十遍老板娘真漂亮
//		System.out.println("老板娘真漂亮");
//		System.out.println("老板娘真漂亮");
//		System.out.println("老板娘真漂亮");
//		System.out.println("老板娘真漂亮");
//		System.out.println("老板娘真漂亮");
//		System.out.println("老板娘真漂亮");
//		System.out.println("老板娘真漂亮");
//		System.out.println("老板娘真漂亮");
//		System.out.println("老板娘真漂亮");
//		System.out.println("老板娘真漂亮");
//		问题：重复性太高了
//		解决：使用java中提供的循环语句
//		循环语句：对于某些需要重复执行的，相同的或者相似的代码，可以使用某种格式完成对这种重复代码的一种简写格式。
//		使用循环语句完成对重复代码的改造
		for (int i = 0; i <= 10; i++) {
//			要循环执行的代码
			System.out.println("老板娘真漂亮");
		}
	}
}

练习题

package com.quan.day1;
//1、随意定义一个两位数的变量，分别获取这个两位数上的个位数字和十位数字并输出。
//例如：
//int i = 98;
//    打印结果：个位数字为：8,十位数字为：9
public class Lianxi {
	public static void main(String[] args) {
		int a=98;
		System.out.println(a/10);
		System.out.println(a%10);
	}
}

package com.quan.day1;
//2、分析如下代码，写结果
//int x = 10;  /11,10
//int y = 20;	/21,21
//int z = (x++) + (y++) + (--x+y);
//			10		20		10+21
//			=61
//   不运算代码，分析出 x y z的值分别是多少？

public class Lianxi_2 {
	public static void main(String[] args) {
		int x = 10;  
		int y = 20;	
		int z = (x++) + (y++) + (--x+y);
		System.out.println(z);
		System.out.println(x);
		System.out.println(y);
	}
}

package com.quan.day1;


//3、键盘录入一个学生的成绩，int类型的分数，根据录入的分数，输出分数的等级
//[90,100] 优秀
//[80，90）良好
//[60，80）及格
//[0，60） 不及格
 import java.util.Scanner;
public class Linaxi_3 {
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		System.out.print("请输入你的分数:");
		int a=sc.nextInt();
		if(a<=100&&a>=90) {
			System.out.println("优秀");
		}else if(a<90&&a>=80) {
			System.out.println("良好");
		}else if(a<80&&a>=60) {
			System.out.println("及格");
		}else if(a<60&&a>=0) {
			System.out.println("不及格");
		}else {
			System.out.println("输入有误");
		}
	}
}

package com.quan.day1;

public class Lianxi_4 {
//	4、使用循环打印1-5，和5-1
	public static void main(String[] args) {
		for(int i=1;i<=5;i++) {
			System.out.println(i);
		}
		System.out.println("=============");
		for(int i=5;i>=1;i--) {
			System.out.println(i);
		}
	}
	
}

package com.quan.day1;
public class Lianxi_5 {
//	5、使用循环打印1-100之间的偶数
	public static void main(String[] args) {
		for(int i=1;i<=100;i++) {
			if(i%2==0) {
				System.out.println(i);
			}
		}
	}
}