Day1

软件开发基础

什么是JavaEE

接收来自客户端的请求信息，并通过响应返回给客户端数据

常用开发语言

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-d2HcrLQz-1644159186929)(D:\2113java_workspace\Day01\开发语言的讲解.png)]

C/C++：嵌入式、智能机器人的底层、智能家具的底层

Java：移动端、服务器开发

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bJahp8Xs-1644159186929)(D:\2113java_workspace\Day01\JavaEE理解图.png)]OC：移动端

HTML：网页

Python：大数据分析

Java开发环境搭建

什么是JDK和JRE

JDK：Java开发工具包

JRE：Java运行环境

安装JDK

1. 如果你仅仅运行java程序，只用安装JRE即可，但是你要编写Java程序，就必须安装JDK和JRE
2. JDK的安装包，安装完JDK后会自动的提示你安装JRE（JDK安装包中包含了JRE）
3. 安装路径建议用默认路径（如果自定义路径需注意不要有中文的出现）
4. 安装后不会像QQ有开启软件的图标（可以在控制面板中查看是否安装）

配置环境变量

目的：让当前系统识别到JDK

目的地：计算机右键属性 -> 高级系统设置 -> 高级卡页 -> 环境变量

注意用户变量和系统变量的区别

用户变量配置的内容只能在当前用户中使用

系统变量配置的内容可以在所有用户中使用

一般都在用户变量中设置即可

名	值
JAVA_HOME（需要新建）	C:\Program Files\Java\jdk1.8.0_144
Path	%JAVA_HOME%\bin

注意：

1. 大小写
2. Path中的路径往往是多个，多个路径之间用英文的;隔开
3. 配置好了以后就点确定

检测环境变量是否配置成功

打开cmd窗口/黑窗口/命令行：搜索cmd

输入java -version和javac -version

配置错误的原因：环境变量的路径有误

注意：配置错误，修改后，重新开启cmd

编写Java程序

1.常用命令

命令	描述
cd…	返回上一级目录
cd/	返回根目录
cd 文件夹名	进入此文件夹
d:	进入到d盘
cls	清空cmd

2.在记事本编写代码

工作空间 - workspace：存放代码的文件夹

注意：

1. 何老师按照每一天一个文件夹（Day01），你们（MyDay01）的形式命名
2. 不要隐藏文件的扩展名

3.cmd命令窗口编译、执行

javac Hello.java – 将Hello.java文件编译成Hello.class文件

java Hello – 运行Hello.class文件

4.程序编译执行过程

Java先编译后运行

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-U6Pa1qSK-1644159186930)(D:\2113java_workspace\Day01\Java编译运行图.png)]

Day2

变量的使用

变量声明：数据类型 变量名 [= 值];
注意：在同一个作用域中变量名不能重复

注意：变量未初始化，就不能使用

	//声明一个int类型的变量age，并把18赋值给变量age
	int age = 18;
	//打印变量age中的值
	System.out.println(age);//18
	
	//把19赋值给变量age
	age = 19;
	//打印变量age中的值
	System.out.println(age);//19

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lzLuBpsh-1644159186930)(D:\2113java_workspace\Day02\变量使用内存图.png)]

Java的基本数据类型

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-262mSCJz-1644159186931)(D:\2113java_workspace\Day02\Java数据类型图.png)]

数字字面量：数字字面量
整数数字：默认是int类型
小数数字：默认是double类型

	//整数类型 -- 字节型
	byte b = 10;
	System.out.println(b);//10
	b = 20;
	System.out.println(b);//20
	
	//整数类型 -- 短整型
	short s = 30;
	System.out.println(s);//30
	s = 40;
	System.out.println(s);//40
	
	//整数类型 -- 整型
	int i = 50;
	System.out.println(i);//50
	i = 60;
	System.out.println(i);//60
	
	//整数类型 -- 长整型
	long l = 70;
	System.out.println(l);//70
	l = 80;
	System.out.println(l);//80
	
	//浮点类型 -- 单精度浮点型
	//加上F，直接让系统认为该数字字面量为float类型
	float f = 111.111F;
	System.out.println(f);//111.111
	f = 222.222F;
	System.out.println(f);//222.222
	
	//浮点类型 -- 双精度浮点型
	double d = 333.333;
	System.out.println(d);//333.333
	d = 444.444;
	System.out.println(d);//444.444
	
	//字符类型
	char c = 'A';
	System.out.println(c);//A
	c = '我';
	System.out.println(c);//我
	
	//布尔类型
	boolean bool = true;//true-对的/真的
	System.out.println(bool);
	bool = false;//false-错的/假的
	System.out.println(bool);

基本数据类型的转型

数值型的取值范围：byte<short<int<long<float<double

自动转型

规则：取值范围小 转 取值范围大

	byte b = 10;
	short s = b;
	int i = s;
	long l = i;
	float f = l;
	double d = f;
	System.out.println(d);//10.0
	
	byte b1 = 100;
	double d1 = b1;
	System.out.println(d1);//100.0

强制转型/强转

规则：取值范围大 转 取值范围小
语法规则：数据类型 变量名 = (目标类型)要转型的变量;

	double d = 123.123;
	float f = (float)d;//1.将double类型的变量d强转为float类型 2.再赋值给float类型的变量f
	long l = (long)f;
	int i = (int)l;
	short s = (short)i;
	byte b = (byte)s;
	System.out.println(b);

	double d1 = 100.123;
	byte b1 = (byte)d1;
	System.out.println(b1);

特殊的几个案例

案例一：
byte b1 = 1;//1为int类型的数字字面量，但是1在byte类型的取值范围里，所以可以直接赋值
byte b2 = 128;//报错原因：128为int类型的数字字面量，但是128不在byte类型的取值范围里，所以必须强转
//128 -- int -- 4字节 -- 32位
//0000,0000,0000,0000,0000,0000,1000,0000
//(byte)128 -- byte -- 1字节 -- 8位
//1000,0000
byte b2 = (byte)128;
System.out.println(b1);
System.out.println(b2);//-128				
案例二：
//报错原因：12345678901为int类型的数字字面量，但是该数字超过了int类型的取值范围所以报错
int i = 12345678901;	
案例三：
//报错原因：12345678901为int类型的数字字面量，但是该数字超过了int类型的取值范围所以报错
long l1 = 12345678901;
//12345678901L为long类型的数字字面量，该数字没有超过了long类型的取值范围所以不报错
long l2 = 12345678901L;
案例四：
float f1 = 1;//int类型转float -- 自动转型
float f2 = 1.0;//double类型转float -- 强制转型
//解决方案1：直接将1.0认为是float类型，效率高
float f2 = 1.0F;
//解决方案2：将64位double类型强转为32位的float类型，效率低
float f2 = (float)1.0;
System.out.println(f1);
System.out.println(f2);
案例五：
char c = 'a';
int i = c;
System.out.println(i);//97 -- ASCII

扩展第一个Java程序

1.代码详解

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ci0Nwjgr-1644159186931)(D:\2113java_workspace\Day02\Hello细节图.png)]

/**
	编写人：何老师
	编写时间：2021年12月14日
*/

//公有的类叫做Hello
public class Hello{

	//主方法：运行该类，系统就会自动找到该方法并运行方法中的代码块
	public static void main(String[] args){
		
		//输出语句("内容");
		System.out.println("HelloWorld...1");
		System.out.println("HelloWorld...2");
		System.out.println("HelloWorld...3");

	}
}

/*
	public	公有的
	class	类
	Hello	类名
	static	静态的
	void	无返回值的
	main	方法名
	String	字符串
	String[]字符串数组
	args	字符串数组名字
*/

2.代码细节

1. public修饰的类名必须和文件名一致
2. Java是一门大小写敏感的语言
3. 括号都是成双成对的
4. 方法里的代码都是从上往下执行-顺序执行
5. 方法中的代码又叫做执行语句/代码块/方法体，执行语句用分号结束

Java编码规范

1.书写规范

注意：

1. 运用tab让代码更有层次感，可读性提高
2. 类名使用帕斯卡命名法（大驼峰命名法–单词首字母大写）

2.代码注释

含义：将较难理解的代码用我们能理解的文字叙述出来

注释类别	描述
//注释内容	单行注释
/*注释内容*/	多行注释
/**注释内容*/	文档注释

注意：注释只在编码阶段有效，代码编译成.class后，注释不会编译进去

path的作用

%JAVA_HOME%/bin --> javac.exe 和 java.exe

在path中配置了某个文件夹，代表在其他任何文件夹里都可以打开配置的文件夹中的文件

Java的跨平台特性

见Java跨平台特性.jpg

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ya8QI6bL-1644159186933)(D:\2113java_workspace\Day02\Java跨平台特性.png)]

Java体系的划分

JavaSE – J2SE – 基础/标准版本

JavaEE – J2EE – 企业版本（服务器开发）

JavaME – J2ME – 微型版本（客户端开发 – 已弃用）

客户端开发（Android开发）：JavaSE -> SDK

后端开发（服务器开发）：JavaSE --> JavaEE（JavaWeb、框架、微服务/分布式）

Java的发展历史

雇主：SUN（Stanford University Network）— 2009年74亿美金卖给Oracle公司

Java之父：詹姆斯·高斯林 (James Gosling)

版本变更

1995年5月23日，Java语言诞生；

1996年1月，第一个JDK-JDK1.0诞生；

1996年4月，10个最主要的操作系统供应商申明将在其产品中嵌入JAVA技术；

1996年9月，约8.3万个网页应用了JAVA技术来制作；

1997年2月18日，JDK1.1发布；

1997年4月2日，JavaOne会议召开，参与者逾一万人，创当时全球同类会议规模之纪录；

1997年9月，JavaDeveloperConnection社区成员超过十万；

1998年2月，JDK1.1被下载超过2,000,000次；

1998年12月8日，JAVA2企业平台J2EE发布；

1999年6月，SUN公司发布Java的三个版本：标准版、企业版和微型版；

2000年5月8日，JDK1.3发布；

2000年5月29日，JDK1.4发布；

2001年6月5日，NOKIA宣布，到2003年将出售1亿部支持Java的手机；

2001年9月24日，J2EE1.3发布；

2002年2月26日，J2SE1.4发布，自此Java的计算能力有了大幅提升；

2004年9月30日18:00PM，J2SE1.5发布，成为Java语言发展史上的又一里程碑。为了表示该版本 的重要性，J2SE1.5更名为Java SE 5.0；

2005年6月，JavaOne大会召开，SUN公司公开Java SE 6。此时，Java的各种版本已经更名，以取 消其中的数字“2”：J2EE更名为Java EE，J2SE更名为Java SE，J2ME更名为Java ME；

2006年12月，SUN公司发布JRE6.0；

2009年4月7日Google App Engine开始支持Java；

2009年04月20日，甲骨文74亿美元收购Sun。取得Java的版权；

2010年11月，由于甲骨文对于Java社区的不友善，因此Apache扬言将退出JCP;

2011年7月28日，甲骨文发布Java 7.0的正式版；

2014年3月19日，甲骨文公司发布Java 8.0的正式版

什么是IDE

含义：编写代码的工具

记事本 --> Notepad++/EditPlus --> eclipse --> IDEA

编码问题

乱码出现的原因：编码和解码不是使用的同一编码格式

解决方案：两个端口设置一样的编码格式

ps：javac -encoding UTF-8 Hello.java(告诉cmd以UTF-8的编码格式去处理Hello.java文件)

注意：NotePad++安装完成后，在设置 ->首选项->新建->ANSI（使用当前系统的编码格式）

注意：设置成功后，删除原有.java文件，再新建文件即可

作业

1.请实现两个整数变量的交换

int a = 1;
int b = 2;
int temp = a;//temp-1
a = b;//a-2
b = temp;//b-1
System.out.println(a);//2
System.out.println(b);//1

2.求长方形的周长 和 面积 长为1.5 宽为 4

double length = 1.5;
double width = 4;
double girth = (length+width)*2;
double area = length*width;
System.out.println("周长为：" + girth);
System.out.println("面积为：" + area);

3.一辆汽车 以40km/h的速度行驶,行驶了45678.9km,求所用的时间

double length = 45678.9;
double speed = 40;
double time = length/speed;
System.out.println("时间为：" + time);

4.定义字符变量赋值为 ‘A’ -->输出 ‘a’

char c = 'A';//A - ASCII - 65
c = (char)(c+32);
System.out.println(c);//a - ASCII - 97

5.键盘录入两个整数 求 两个整数的 乘积

Scanner scan = new Scanner(System.in);
System.out.println("请输入第一个数字：");
int num1 = scan.nextInt();
System.out.println("请输入第二个数字：");
int num2 = scan.nextInt();
int result = num1*num2;
System.out.println("乘积为：" + result);

Day3

算数运算符的使用

符号：+、-、*、/、%、++、–

int num1 = 50;
int num2 = 30;
int result = num1 + num2;
System.out.println(result);//80
System.out.println(num1 - num2);//20
System.out.println(num1 * num2);//1500
System.out.println(num1 / num2);//1
System.out.println(num1 % num2);//20
//++:自身加1
//++a:先自增1，再使用
int a = 10;
System.out.println(++a);//11
System.out.println(a);//11
//b++:先使用，再自增1
int b = 10;
System.out.println(b++);//10
System.out.println(b);//11
//--:自身减1
//--c:先自减1，再使用
int c = 10;
System.out.println(--c);//9
System.out.println(c);//9
//d--:先使用，再自减1
int d = 10;
System.out.println(d--);//10
System.out.println(d);//9

算数运算符的深入

案例1：
//byte类型做运算会先向上转型成int类型，再做运算
//原因：CPU每次去获取32位的数据，所以没有32位就向上补成32位
byte b = 10;
//byte 10 : 0000,1010
//int  10 :0000,0000,0000,0000,0000,0000,0000,1010(向上转型使用最高位补位)
byte b2 = 20;
//byte 20 : 0001,0100
//int  20 : 0000,0000,0000,0000,0000,0000,0001,0100(向上转型使用最高位补位)
byte result1 = (byte)(b1 + b2);
System.out.println(result1);		
案例2：
//short类型做运算会先向上转型成int类型，再做运算
//原因：CPU每次去获取32位的数据，所以没有32位就向上补成32位
short s1 = 10;
//short10 : 0000,0000,0000,1010
//int  10 : 0000,0000,0000,0000,0000,0000,0000,1010(向上转型使用最高位补位)
short s2 = 20;
//short20 : 0000,0000,0001,0100
//int  20 : 0000,0000,0000,0000,0000,0000,0001,0100(向上转型使用最高位补位)
short result2 = (short)(s1 + s2);
System.out.println(result2);
案例3：
//byte和short做运算会向上转型成int类型（补成32位）
byte b = 10;
short s = 20;
int result3 = b + s;
System.out.println(result3);	
案例4：
//除了byte和short一起做运算，其余的数值型按照取值范围大的类型进行类型提升
byte b = 1;
short s = 2;
int i = 10;
float f = 20;
double d = 30;
System.out.println(b + s);//3 int类型的结果
System.out.println(b + i);//11 int类型的结果
System.out.println(b + f);//21.0 float类型的结果
System.out.println(i + f);//30.0 float类型的结果
System.out.println(i + f);//30.0 float类型的结果
System.out.println(i + d);//40.0 double类型的结果
System.out.println(f + d);//50.0 double类型的结果	
案例5：
//char类型可以做运算，将字符转换为ASCII表中的数值
char c = 'a';//ASCII -- 97
int i = c + 1;
System.out.println(i);//98	
案例6：
int num = 10;
//++num; 和 num++; 没有区别
//原因： ;表示一行执行语句的结束，不管先加还是后加，都自增1
//++num;
num++;
System.out.println(num);//11
案例7：
byte num = 10;
++num;//底层实现：num = (byte)(num+1);
System.out.println(num);//11
			
经典面试题一：输出结果为？
int a = 8;
int b = (a++)+(++a)+(a*10);
// a = 10
// b = 8 + 10 + 10*10
System.out.println(b);//118
经典面试题二：输出结果为？
int i = 0;   
i = ++i; 
//底层实现：i= (int)(i+1);i = i;
System.out.println(i);//1
经典面试题三：输出结果为？			
int i = 0;   
i = i++;  
//底层实现：
//int temp = i;//temp记录了i最初的值 --- 0
//i= (int)(i+1);//i是自增了
//i = temp;//把i最初的值(0) 重新赋值给i
System.out.println(i);//0

赋值运算符

符号：=、+=、-=、*=、/=、%=

int num = 10;
System.out.println(num += 5);//num = (int)(num+5); -- 15
System.out.println(num -= 5);//num = (int)(num-5); -- 10
System.out.println(num *= 5);//num = (int)(num*5); -- 50
System.out.println(num /= 5);//num = (int)(num/5); -- 10
System.out.println(num %= 3);//num = (int)(num%3); -- 1
经典面试题一：输出结果为？
int a,b; //一次性声明两个变量
a = b = 100;//将100赋值给b，再把b赋值给a
System.out.println(a); //100
System.out.println(b); //100	
经典面试题二：下面的两种写法结果分别是？
short s = 1; 
s = s+1; //会报错，s+1的结果是int类型
short s = 1; 
s += 1;// s = (short)(s+1); -- 底层实现有个强转的过程
赋值规则：
 s+= 1	
 s = (T)(s+1)
复合赋值 E1 op= E2等价于简单赋值 E1 = (T)((E1) op 	(E2))，其中T是E1的类型。

关系运算符

符号：==、!=、>、<、>=、<=

注意：
= 赋值号
== 判断两个值是否相等
!= 判断两个值是否不相等
总结：关系运算符的结果都是boolean类型
int num1 = 10;
int num2 = 20;
boolean bool = num1 == num2;
System.out.println(bool);//false
System.out.println(num1 != num2);//true	
System.out.println(num1 > num2);//false
System.out.println(num1 < num2);//true		
System.out.println(num1 >= num2);//false		
System.out.println(num1 <= num2);//true	
经典面试题一：输出结果为？
int x = 10;
int y = 10;
boolean flag = (x == y);
System.out.println(flag);//true
flag = (x = y);//会报错：boolean不能和其他类型兼容
System.out.println(flag);
经典面试题二：输出结果为？
boolean b1 = true;
boolean b2 = false;
boolean b3 = (b1 == b2);
System.out.println(b3);//false
boolean b4 = (b1 = b2);
System.out.println(b4);//false

逻辑运算符

符号：
& 与 &&短路与
| 或 ||短路或
^ 异或
! 非

//&与：两侧都是boolean，两侧都成立(true)，结果才为true
System.out.println(true & true);//true
System.out.println(true & false);//false
System.out.println(false & true);//false
System.out.println(false & false);//false
//&&短路与：两侧都是boolean，两侧都成立(true)，结果才为true
System.out.println(true && true);//true
System.out.println(true && false);//false
System.out.println(false && true);//false
System.out.println(false && false);//false
//& vs &&
// &：判断前者为false后，还会判断后者
//&&：判断前者为false后，不会判断后者，效率更高
//ArithmeticException -- 算数异常
System.out.println(false && 10/0>6);
//|或：两侧都是boolean，两侧有一侧成立(true)，结果就为true
System.out.println(true | true);//true
System.out.println(true | false);//true
System.out.println(false | true);//true
System.out.println(false | false);//false
//|| 短路或：两侧都是boolean，两侧有一侧成立(true)，结果就为true
System.out.println(true || true);//true
System.out.println(true || false);//true
System.out.println(false || true);//true
System.out.println(false || false);//false
//| vs ||
// |：判断前者为true，还会判断后者
//||：判断前者为true，不会判断后者，效率更高
System.out.println(true || 10/0>6);
//^ 异或：两侧都是boolean，两侧不一样，结果为true
System.out.println(true ^ true);//false
System.out.println(true ^ false);//true
System.out.println(false ^ true);//true
System.out.println(false ^ false);//false
//! 非:置反
boolean bool1 = true;
System.out.println(!bool1);//false
boolean bool2 = false;
System.out.println(!bool2);//true
注意：
1.逻辑运算符运行结果都是boolean类型
2.&、&&、|、||、^ 两侧都是boolean类型数据
			
练习题：在dos窗口输入一个数字，判断是否在50~100的区间内
//创建Scanner类的对象
Scanner scan = new Scanner(System.in);
//在黑窗口输入数字
System.out.println("请输入一个数字：");
int num = scan.nextInt();
//判断是否在50~100的区间内
boolean bool = num>50 && num<100;
System.out.println(bool);

字符串拼接符

符号：+

+号两侧都是数值，此符号为算数运算符
+号一侧是字符串或者两侧都是字符串，此符号为字符串拼接符
	System.out.println(1+2+"abc"+"def"+1+2);
	//				    3 +"abc"+"def"+1+2
	//					 "3abc" +"def"+1+2
	//					 	"3abcdef" +1+2
	//						  "3abcdef1"+2
	//							"3abcdef12"

三目运算符的使用

语法结构： 数据类型 变量 = (表达式)?值1:值2;

理解：
表达式的结果必须是boolean类型
true -将值1赋值给变量
false-将值2赋值给变量

案例1：在控制台输入两个数字，输出最大值
Scanner scan = new Scanner(System.in);
System.out.println("请输入第一个数字：");
int a = scan.nextInt();
System.out.println("请输入第二个数字：");
int b = scan.nextInt();			
int max = (a > b)?a:b;
System.out.println("最大值为：" + max);
案例2：在控制台输入三个数字，输出最大值
Scanner scan = new Scanner(System.in);
System.out.println("请输入第一个数字：");
int a = scan.nextInt();
System.out.println("请输入第二个数字：");
int b = scan.nextInt();
System.out.println("请输入第三个数字：");
int c = scan.nextInt();			
int max = (a > b)?a:b;
max = (max > c)?max:c;
System.out.println("最大值为：" + max);			
案例3：在控制台输入两个数字，输出最小值
Scanner scan = new Scanner(System.in);
System.out.println("请输入第一个数字：");
int a = scan.nextInt();
System.out.println("请输入第二个数字：");
int b = scan.nextInt();			
int min = (a < b)?a:b;
System.out.println("最小值为：" + min);			
案例4：在控制台输入三个数字，由小到大输出（1<2<3）
Scanner scan = new Scanner(System.in);
System.out.println("请输入第一个数字：");
int a = scan.nextInt();
System.out.println("请输入第二个数字：");
int b = scan.nextInt();
System.out.println("请输入第三个数字：");
int c = scan.nextInt();
//最大值
int max = (a>b)?a:b;
max = (max>c)?max:c;
//最小值
int min = (a<b)?a:b;
min = (min<c)?min:c;
//中间值
int mid = a+b+c-max-min;
//输出
System.out.println(min + "<" + mid + "<" + max);

三目运算符深入

扩展面试题1：
扩展知识点：数字字面量是常量（常量：在程序运行过程中不可改变的量）
int a = 5;
System.out.println((a<5)?10.9:9);//9.0
扩展面试题2：
char x = 'x';//ASCII - 120
int i=10;
System.out.println(false?i:x);//120
扩展面试题3：			
char x = 'x';//ASCII - 120
System.out.println(false?100:x);//x
System.out.println(false?65536:x);//120
			
三目运算符的返回值规则：
值1和值2都是常量的情况：输出结果后，要将结果的数据类型转型成取值范围较大的那个数据的数据类型
值1和值2都是变量的情况：输出结果后，要将结果的数据类型转型成取值范围较大的那个数据的数据类型
值1和值2一个是常量一个是变量的情况：
如果值1在值2类型的取值范围内：就按照值2的类型进行返回数据
如果值1不在值2类型的取值范围内：就按照值1的类型进行返回数据

位运算符

</video

含义：把十进制转化为二进制进行运算
符号：&、|、^、>>、<<、<<<

//&:同位比较，两者为1，结果才为1
byte b1 = 27;//0001,1011
byte b2 = 28;//0001,1100
			 //0001,1000
//b1 - 27:0001,1011
//b2 - 28:0001,1100
//int - 27:0000,0000,0000,0000,0000,0000,0001,1011
//int - 28:0000,0000,0000,0000,0000,0000,0001,1100
//int - 24:0000,0000,0000,0000,0000,0000,0001,1000
//byte- 24:0001,1000
byte result = (byte)(b1 & b2);//注意：两个byte类型做运算，会先向上转型成int
System.out.println(result);//24 - 0001,1000
		
//|:同位比较，两者有1，结果就为1
		byte b1 = 27;//0001,1011
		byte b2 = 28;//0001,1100
					 //0001,1111
System.out.println(b1 | b2);//31 - 0001,1111
		
//^:同位比较，两者不同，结果就为1
		byte b1 = 27;//0001,1011
		byte b2 = 28;//0001,1100
					 //0000,0111
System.out.println(b1 ^ b2);//7 - 0000,0111
		
&、|、^:两侧都是数值，该符号为位运算符
&、|、^:两侧都是boolean值，该符号为逻辑运算符
		
//<<左移：整体向左移动n位，末尾就用n个0补位
		byte b1 = 8;//0000,1000
					//0100,0000
System.out.println(b1<<3);//64 - 0100,0000	
		
//>>右移：整体向右移动n位，前面就用n个最高位(符号位)补位
		byte b1 = 64;//0100,0000	
					 //0000,1000	
System.out.println(b1>>3);//8 - 0000,1000	
		
		byte b2 = -18;//1110,1110
					  //1111,1101
System.out.println(b2>>3);//-3 - 1111,1101
		
//>>>无符号位右移：整体向右移动n位，前面就用n个0补位
//总结：正整数>>或>>>没有区别，区别在于负数
		byte b1 = 64;//0100,0000	
					 //0000,1000	
System.out.println(b1>>>3);//8 - 0000,1000	
		
byte b2 = -18;//byte - 1110,1110
//int  - 1111,1111,1111,1111,1111,1111,1110,1110
//>>>3 - 0001,1111,1111,1111,1111,1111,1111,1101
System.out.println(b2>>>3);//536870909

面试题1：用最有效率的方式计算2*8
		System.out.println(2<<3);
			
面试题2：描述下列代码输出结果
//int -1:1111,1111,1111,1111,1111,1111,1111,1111
//(byte):1111,1111
//(char):1111,1111,1111,1111(考点：char没有负数，所以向上转型用0补位)
//(int) :0000,0000,0000,0000,1111,1111,1111,1111
System.out.println((int)(char)(byte)-1);//65535

ASCII表

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-flyzCfZf-1644159186933)(D:\2113java_workspace\Day03\ASCII.png)]

作业

1.键盘输入两个数字，获取出最大值

	Scanner scan = new Scanner(System.in);
	System.out.println("请输入第一个数字：");
	int num1 = scan.nextInt();
	System.out.println("请输入第二个数字：");
	int num2 = scan.nextInt();
	int result = (num1>num2)?num1:num2;
	System.out.println("最大值为：" + result);

2.用最有效率的方式计算出4*8的结果

	System.out.println(4<<3);

3.int a = 21，获取出(a++) + (–a) * (a+=2)的结果

	int a = 21;
	int b = (a++) + (--a) * (a+=2);
	//a = 23
	//b = 21 + 21 * 23
	System.out.println(b);//504
}

Day4 &5

转义字符

含义：表示具有特殊意义的字符本身

\'：表示一个单引号字符
\"：表示一个双引号字符
\\：表示一个斜杠字符
\n：表示换行
\t：表示水平制表
System.out.println("何老师说：\'用良心做教育\'");
System.out.println("何老师说：\"用良心做教育\"");
System.out.println("何老师说：\\用良心做教育\\");
注意：
System.out.println(""); -- 输出并换行
System.out.print(""); -- 输出				
System.out.print("用良心做教育\n");
System.out.print("做真实的自己");		System.out.println("2*3=6\t2*4=8\t2*5=10\t2*6=12");	System.out.println("3*3=9\t3*4=12\t3*5=15\t3*6=18");

常量

含义：在程序执行过程中不可变的量

分类：
1.数字字面量 ps：100、200、300
2.字面值常量 ps：“用良心做教育”
3.final(最终的)修饰的变量
final int I = 100;
System.out.println(I);
命名规范：全大写，单词与单词之间用下划线隔开

Java的执行语句

1.顺序语句

含义：在方法中的代码是从上往下顺序执行的

2.分支语句

含义：按照条件执行不同的功能
分类：

2.1 if分支

简单的if分支

语法结构：
if(表达式){
...代码块...
}	
理解：
表达式的结果必须是boolean
true - 执行代码块
false- 跳过if，执行if以外的代码
做实验：
if(false){
System.out.println("...代码块...");
}
System.out.println("if以外的代码");
案例：如果麻生希的Java考试成绩大于98分，麻生希就能获得一辆法拉利作为奖励
Scanner scan = new Scanner(System.in);
System.out.println("请输入Java成绩：");
double score = scan.nextDouble();
if(score > 98){
System.out.println("奖励麻生希一辆法拉利玩具赛车");
}
总结：简单if分支可以判断某个条件是否成立

复杂的if分支

案例一： 人类的健康值在20-25的数值内为健康（健康值算法为：体重（Kg） / 身高（米）的平方）
//输入体重和身高
Scanner scan = new Scanner(System.in);
System.out.println("请输入体重(Kg)：");
double weight = scan.nextDouble();
System.out.println("请输入身高(M)：");
double height = scan.nextDouble();
//计算健康值
double health = weight/(height*height);
//判断健康值的区间
if(health > 20 && health < 25){
System.out.println("小护士说：\"健康，请保持现有状态\"");
}
案例二：桃谷绘里香Java成绩大于98分，而且音乐成绩大于80分，老师奖励他；或者Java成绩等于100分，音乐成绩大于70分，老师也可以奖励他。
Scanner scan = new Scanner(System.in);
System.out.println("请输入Java成绩：");
double javaScore = scan.nextDouble();
System.out.println("请输入音乐成绩：");
double musicScore = scan.nextDouble();
if((javaScore>98 && musicScore>80) ||(javaScore==100 && musicScore>70)){
System.out.println("奖励桃谷绘里香劳斯莱斯玩具赛车一辆");
}	
总结：
1.if可以判断区间
2.if可以判断复杂的条件

if…else…

语法结构：
if(表达式){
…代码块…
}else{
…else代码块…
}

理解：
表达式的结果必须是boolean类型
true - 执行代码块
false- 执行else代码块
做实验：
if(false){
System.out.println("...代码块...");
}else{
System.out.println("...else代码块...");
}
System.out.println("if以外的代码");
案例：如果小峰由衣Java考试成绩大于98分，老师就奖励他一个劳斯莱斯，否则老师就罚他进行编码
Scanner scan = new Scanner(System.in);
System.out.println("请输入Java成绩：");
double score = scan.nextDouble();
if(score > 98){
System.out.println("奖励小峰由衣劳斯莱斯玩具赛车一辆");
}else{
System.out.println("何老师给小峰由衣通宵补课");
}
总结：
if...else... 二选一的需求下使用

多重if分支 – if…else if…

语法结构：
if(表达式1){
…代码块1…
}else if(表达式2){
…代码块2…
}else if(表达式n){
…代码块n…
}else{
…else代码块…
}

理解：
表达式的结果必须是boolean类型
从上往下判断表达式，哪个表达式先成立，就执行对应的代码块
如果都不成立，就执行else代码
注意：else{}根据需求可写可不写
做实验：
if(false){
System.out.println("...代码块1...");
}else if(false){
System.out.println("...代码块2...");
}else if(false){
System.out.println("...代码块n...");
}else{
System.out.println("...else代码块...");
}
System.out.println("if以外的代码");
案例一：人类的健康值在
				15-20的数值内为偏瘦
				20-25的数值内为健康
				25-30的数值内为偏胖
（健康值算法为：体重（Kg） / 身高（米）的平方）
//输入体重和身高
Scanner scan = new Scanner(System.in);
System.out.println("请输入体重(Kg)：");
double weight = scan.nextDouble();
System.out.println("请输入身高(M)：");
double height = scan.nextDouble();
//计算健康值
double health = weight/(height*height);		
//判断健康值的区间
if(health > 15 && health <= 20){
System.out.println("小护士说：\"偏瘦，喝酒、吃垃圾食品、熬夜\"");
}else if(health > 20 && health <= 25){
System.out.println("小护士说：\"健康，请保持现有状态\"");
}else if(health > 25 && health <= 30){
System.out.println("小护士说：\"偏胖，多做运动，嘿嘿嘿~~~\"");
}else{
System.out.println("小护士说：\"健康值异常，请到医院进行详细检查\"");
}			
案例二：通过键盘录入学生成绩
如果在90-100之间，则打印“A”，
否则如果在80-90之间，则打印“B”，
否则如果在70-80之间，则打印“C”
否则如果在60-70之间，则打印“D”
否则如果在0-60之间，则打印“E”
否则打印“成绩异常”
Scanner scan = new Scanner(System.in);
System.out.println("请输入成绩：");
double score = scan.nextDouble();
if(score >= 90 && score <= 100){
System.out.println("A");
}else if(score >= 80 && score < 90){
System.out.println("B");
}else if(score >= 70 && score < 80){
System.out.println("C");
}else if(score >= 60 && score < 70){
System.out.println("D");
}else if(score >= 0 && score < 60){
System.out.println("E");
}else{
System.out.println("成绩异常");
}
总结：
多重if分支 多选一的需求下使用

嵌套if分支

需求：千锋组织百米赛跑，跑入15秒内的同学进入到总决赛 根据性别分别输出"恭喜进入到男子组决赛"或者是"恭喜进入到女子组决赛"

Scanner scan = new Scanner(System.in);
System.out.println("请输入成绩：");
double second = scan.nextDouble();
if(second > 0 && second < 15){
	System.out.println("请输入性别：");
	String sex = scan.next();//输入字符串
		if(sex.equals("男")){//判断两个字符串是否相等
		System.out.println("恭喜进入到男子组决赛");
		}else if(sex.equals("女")){//判断两个字符串是否相等
		System.out.println("恭喜进入到女子组决赛");
		}else{//用户可能乱输入性别
			System.out.println("性别异常");
		}
}else if(second >= 15){
	System.out.println("重在参与");
}else{//用户可能输入负数
	System.out.println("成绩异常");
}

if总结：

1.if可以判断简单条件
2.if可以判断区间
3.if可以判断复杂条件
4.if可以二选一（if…else…）
5.if可以多选一（if…else if…）
6.if可以嵌套

2.2 switch分支

语法结构：
switch(表达式){
case 值1:
…代码块1…
break;
case 值2:
…代码块2…
break;
case 值n:
…代码块n…
break;
default:
…default代码块…
break;
}
理解：
表达式的结果可以是：byte、short、int、char、字符串(JDK1.7)、枚举(JDK1.5)
分别和值1、值2、值n比较，哪个相等，就执行对应的代码块
如果都不相等，就执行default代码块
注意：
1.default代码块根据需求可写可不写 - 类似于else{}
2.break表示跳出整个switch分支

做实验：
			switch(1000){
				case 10:
					System.out.println("10");
				break;
				case 50:
					System.out.println("50");
				break;
				case 100:
					System.out.println("100");
				break;
				default:
					System.out.println("default代码块");
				break;
			}
			System.out.println("switch分支以外的代码");
			
案例：小西满里惠参加计算机编程大赛
如果获得第一名，将参加千锋组织的1个月马尔代夫旅游
如果获得第二名，将奖励苹果Pro笔记本电脑一部
如果获得第三名，将奖励移动硬盘一个
否则，何老师晚上给小西满里惠通宵补课
	Scanner scan = new Scanner(System.in);
	System.out.println("请输入小西满里惠的比赛名次：");
	String str = scan.next();
	
	switch(str){
		case "第一名":
			System.out.println("和何老师一起参加千锋组织的1个月马尔代夫旅游");
		break;
		case "第二名":
			System.out.println("奖励苹果Pro笔记本电脑一部");
		break;
		case "第三名":
			System.out.println("奖励移动硬盘一个");
		break;
		default:
			System.out.println("何老师晚上给小西满里惠通宵补课");
		break;
	}

switch分支深入

case的值可以相同吗？
不可以，语法错误
default可以省略吗？
可以省略，default类似于if中else{}
break可以省略吗？
可以省略
default的位置一定要在最后吗？
不一定
表达式值的类型可以是什么？
byte、short、int、char、字符串(JDK1.7)、枚举(JDK1.5)
case后的值可以是不同类型？
可以，但是要看是否兼容
switch底层运行原理是什么？
switch表达式的类型可以是：byte、short、int、char、字符串(JDK1.7)、枚举(JDK1.5)
但是底层是认int类型
byte可以自动转型成int
short可以自动转型成int
char把ASCII取出，也是int
字符串是把每个字符的ASCII取出，进行运算得到的int
枚举的每个对象系统会给默认的int

案例：输入年和月，输出当月的天数
分析：
1、3、5、7、8、10、12 -- 31天
4、6、9、11 -- 30天
2 -- 闰年29天 平年28天
注意：被4整除并且不能被100整除 或者 被400整除的年份是闰年
Scanner scan = new Scanner(System.in);
System.out.println("请输入年：");
int year = scan.nextInt();
System.out.println("请输入月：");
int month = scan.nextInt();
int day = 0;//当月天数
switch(month){
	case 1:case 3:case 5:case 7:case 8:case 10:case 12:
		day = 31;
	break;
	case 4:case 6:case 9:case 11:
		day = 30;
	break;
	case 2:
		if(year%4==0&&year%100!=0 || year%400==0){//闰年
		day = 29;
		}else{//平年
		day = 28;
		}
	break;
	}
System.out.println(year + "年" + month + "月的天数为：" + day);	

if vs switch

表达式的区别：
if：boolean
switch：byte、short、int、char、字符串(JDK1.7)、枚举(JDK1.5)
应用场景的区别：
if：判断单个值、区间、复杂条件
switch：判断单个值

3.循环语句

含义：条件满足就重复的执行某个功能,

为什么要使用循环？
减少代码量
什么时候用循环？
做重复的功能时，就可以考虑使用循环

3.1 for循环

语法结构：
for(表达式1;表达式2;表达式3){
…代码块/循环体…
}
理解：
表达式1：初始化变量
表达式2：判断条件（结果必须是boolean类型）
表达式3：更新变量
执行步骤：
1.初始化变量
2.判断条件（结果必须是boolean类型）
2.1 true - 执行代码块，再更新变量，再到第2步
2.2 false- 跳出for循环

做实验：
for(int i = 0;i<5;i++){
System.out.println(“钟燕小可爱，皇冠给你带”);
}

for循环变形记：
int i = 0;
for(;i<5;){
	System.out.println("钟燕小可爱，皇冠给你带 " + i);
	i++;
}	
System.out.println(i);
注意：
1.在for循环中定义的变量不能在循环外使用（变量的作用域问题）
2.在for循环的更新变量的位置i++和++i没有区别
需求1：从1打印到10
for(int i = 1;i<=10;i++){
System.out.println(i);
}
需求2：打印1~10之间的偶数
解决方案1：
for(int i = 1;i<=10;i++){
	if(i % 2 == 0){
	System.out.println(i);
	}
}
解决方案2：
for(int i = 2;i<=10;i+=2){
	System.out.println(i);
}
需求3：从10打印到1
for(int i = 10;i>0;i--){
	System.out.println(i);
}
需求4：打印10~1之间的偶数
解决方案1：
for(int i = 10;i>0;i--){
	if(i % 2 == 0){
		System.out.println(i);
		}
	}
解决方案2：
for(int i = 10;i>0;i-=2){
	System.out.println(i);
}
总结：
1.初始化变量不一定每次都是0
2.更新变量不一定每次都是++
死循环：
for(;;){
	System.out.println("死循环");
}
注意：死循环尽量避免
案例1：循环录入5次int类型的数字，输出总和
			Scanner scan = new Scanner(System.in);
			int sum = 0;//总和
			for(int i = 1;i<=5;i++){
				System.out.println("请输入第" + i + "个数字：");
				int num = scan.nextInt();		
				sum += num;
			}
			System.out.println("总和为：" + sum);
案例2：循环录入麻生希同学的5门课成绩，计算平均分
			Scanner scan = new Scanner(System.in);
			double sum = 0;//总和
			for(int i = 1;i<=5;i++){
				System.out.println("请输入第" + i + "个数字：");
				double num = scan.nextDouble();
				sum += num;
			}
			double avg = sum/5;
			System.out.println("平均分为：" + avg);
案例3：循环录入5次int类型的数字，输出最大值
			Scanner scan = new Scanner(System.in);	
			System.out.println("请输入第1个数字：");
			int max = scan.nextInt();//把第一个数字认为是最大值	
			for(int i = 2;i<=5;i++){
				System.out.println("请输入第" + i + "个数字：");
				int num = scan.nextInt();
				if(num > max){//说明用户输入的数字比max更大
					max = num;
				}
			}
			System.out.println("最大值为：" + max);	

for循环嵌套

ublic class Test01{
	public static void main(String[] args){
				*		i=0
				**		i=1
				***		i=2
				****	i=3
				*****	i=4
				for(int i = 0;i<5;i++){
					for(int j = 0;j<=i;j++){
						System.out.print("*");
					}
					System.out.println();
				}
        
			*****
			****
			***
			**
			*
			for(int i = 0;i<5;i++){
				for(int j = 0;j<5-i;j++){
					System.out.print("*");
				}
				System.out.println();
			}        
    
			*****
			 ****
			  ***
			   **
			    *
			for(int i = 0;i<5;i++){
				for(int k = 0;k<i;k++){
					System.out.print(" ");
				}
				for(int j = 0;j<5-i;j++){
					System.out.print("*");
				}
				System.out.println();
			}
    
			   *
			  **
		     ***
		    ****
		   *****
			for(int i = 0;i<5;i++){
				for(int k = 0;k<4-i;k++){
					System.out.print(" ");
				}
				for(int j = 0;j<i+1;j++){
					System.out.print("*");
				}
				System.out.println();
			}
    
			   *	  i=0   i*2+1
			  ***     i=1   i*2+1
			 *****    i=2   i*2+1
			*******   i=3   i*2+1
			for(int i = 0;i<4;i++){
				for(int k = 3;k>i;k--){
					System.out.print(" ");
				}
				for(int j = 0;j<i*2+1;j++){
					System.out.print("*");
				}
				System.out.println();
			}

			*******
			 *****
			  ***
			   *
			for(int i = 0;i<4;i++){
				for(int k = 0;k<i;k++){
					System.out.print(" ");
				}
				for(int j=0;j<7-2*i;j++){
					System.out.print("*");
				}
				System.out.println();
			}
    
			   *
			  * *
			 *   *
			*******
		for(int i = 0;i<4;i++){
			for(int k = 3;k>i;k--){
				System.out.print(" ");
			}
			for(int j = 0;j<i*2+1;j++){
				//第一行、最后一行、每一行的第一列、每一行的最后一列
				if(i==0 || i==3 || j==0 || j==i*2){
					System.out.print("*");
				}else{
					System.out.print(" ");
				}
			}
			System.out.println();
		}

			*******
			 *   *
			  * *
			   *
		for(int i = 0;i<4;i++){
			for(int k = 0;k<i;k++){
				System.out.print(" ");
			}
			for(int j=0;j<7-2*i;j++){
				//第一行、最后一行、每一行的第一列、每一行的最后一列
				if(i==0 || i==3 || j==0 || j==7-2*i-1){
					System.out.print("*");
				}else{
					System.out.print(" ");
				}
			}
			System.out.println();
		}
打印空心菱形
		for(int i = 0;i < 5;i++){	//i表示空心菱形上半部分行数;类似于金字塔行数
			for(int j = 0;j < (5-1-i);j++){//j控制每行"*"前面的空格数
				System.out.print(" ");
			}
			for(int k = 0;k < (2*i+1);k++){	//k控制要打印的"*"的个数
				if(i == 0){//如果是第一行则将"*"全部打印
					System.out.print("*");
				}else if(k == 0||k == (2*i)){//如果要打印的"*"是第一个或最后一个则    								//打印出来
					System.out.print("*");
				}else{//如果要打印的"*"不是第一个或最后一个则打印空格
					System.out.print(" ");
				}
			}
			System.out.println();
		}//以上打印的是空心菱形的上半部分。
		for(int i = 0;i < 4;i++){	//空心菱形的下半部分的行数比上半部分少一行；比如上半部分是5行，下半部分为4行才能构成菱形
			for(int j = 0;j < (i+1);j++){//j控制每行"*"前面的空格数
				System.out.print(" ");
			}
			for(int k = 0;k < 2*(4-i)-1;k++){	//k控制要打印的"*"的个数
				if(i == 3){//如果是最后一行则将"*"全部打印
					System.out.print("*");
				}else if(k == 0||k == 2*(3-i)){//如果要打印的"*"是第一个或最后一个则打印出来
					System.out.print("*");
				}else{//如果要打印的"*"不是第一个或最后一个则打印空格
					System.out.print(" ");
				}
			}
			System.out.println();
		}
	}
}
九九乘法表
public class Test01{
	public static void main(String[] args){
//版本1
	for(int i = 1;i<=9;i++){
		for(int j = 1;j<=i;j++){
			System.out.print(j + "x" + i + "=" + (i*j) + "\t");
		}
		System.out.println();
	}
				
//版本2
	for(int i = 1;i<=9;i++){
		for(int k = 1;k<i;k++){
			System.out.print("\t");
		}
		for(int j = i;j<=9;j++){
			System.out.print(i + "*" + j + "=" + (i*j) + "\t");
		}
		System.out.println();
	}	

3.2 while循环

语法结构：
while(表达式){
…代码块/循环体…
}
理解：
表达式的结果必须是boolean
true - 循环
false- 跳出循环

死循环：
			while(true){
				System.out.println("死循环");
			}
			
扩展：while循环 替换 for循环
			int i = 0;
			while(i<5){
				System.out.println(i);
				i++;
			}
			
案例：我有个梦想，每月存3000，每年递增1000元，多少个月后存满20万
	int allMoney = 0;//当前存款
	int money = 3000;//当月应存入的金额
	int month = 0;
	while(allMoney < 200000){
		month++;
		allMoney += money;
		if(month % 12 == 0){
			money += 1000;
		}
	}
	System.out.println(month + "个月后存满20万 " + money);

3.3 do-while循环

知识点：do-while循环

语法结构：
do{
…代码块/循环体…
}while(表达式);
理解：
第一次直接运行代码块
运行完毕再去判断表达式
表达式的结果必须是boolean
true - 循环
false- 跳出循环

死循环：
			do{
				System.out.println("死循环");
				
			}while(true);
			
需求：周世伟参加学校组织的歌咏比赛，大赛在即，老师建议：先彩排一次，如果很令人满意，以后就不用彩排了,否则每天都排，直到现场表现满意为止！
			Scanner scan = new Scanner(System.in);
			String str;
			do{
				System.out.println("周世伟:\"旋转、跳跃，我闭着眼\"");
				
				System.out.println("请输入是否满意:");
				str = scan.next();

			}while(str.equals("不满意"));

3.4 for vs while vs do-while

	语法结构的区别：
		for(初始化变量;判断条件;更新变量){}
		while(判断条件){}
		do{}while(判断条件);
		共同点：都有判断条件，true-循环 ，false-跳出循环
	
	执行循序的区别：
		for：先判断，再执行
		while：先判断，再执行
		do-while：先执行一次，再判断
		
	应用场景的区别：
		循环次数确定时：for
		循环次数不确定时，先判断再执行：while
		循环次数不确定时，先执行一次再判断：do-while

4.特殊的流程控制语句

4.1 break

break：作用在循环中，表示跳出整个循环
break - 结束整个循环
当执行循环体的时候遇到了break，整个循环直接结束。（这次循环循环体后面的代码不执行，也不进入下次循环）

做实验理解：
					while(true){
						System.out.println("111");
						System.out.println("222");
						if(true){
							break;
						}
						System.out.println("333");
						System.out.println("444");
					}
需求：循环录入爱田奈奈同学5门课的成绩并计算平均分，如果某分数录入为负，停止录入并提示。
Scanner scan = new Scanner(System.in);				
boolean flag = true;//true-正常录入 false-非正常录入
				double sum = 0;
				for(int i = 1;i<=5;i++){
					System.out.println("请输入第" + i + "门成绩：");
					double score = scan.nextDouble();
					if(score < 0){//分数为负数，结束当前循环
						flag = false;
						break;
					}
					sum += score;
				}
				
				if(flag){
					double avg = sum/5;
					System.out.println("平均分为：" + avg);
				}else{
					System.out.println("录入的分数为负数，停止录入");
				}  

4.2 continue

作用在循环中，表示跳过循环体剩余的部分，进入到下一次循环中
continue - 结束一次循环(结束当次循环)
当执行循环体的时候遇到了continue，这一次循环结束，马上进入下次循环。

做实验理解：
					while(true){
						System.out.println("111");
						System.out.println("222");
						if(true){
							continue;
						}
						System.out.println("333");
						System.out.println("444");
					}
案例：循环录入5名Java课的学生成绩，统计分数大于等于80分的学生比例。	
					解决方案1：
						Scanner scan = new Scanner(System.in);
						int num = 0;//记录大于等于80分学生的人数
						for(int i = 1;i<=5;i++){
							System.out.println("请输入第" + i + "名学生的成绩：");
							double score = scan.nextDouble();
							if(score >= 80){
								num++;
							}
						}
						System.out.println("大于等于80分学生的比例为：" + num/5.0*100 + "%");				
解决方案2：
					Scanner scan = new Scanner(System.in);
					int num = 0;//记录大于等于80分学生的人数
					for(int i = 1;i<=5;i++){
						System.out.println("请输入第" + i + "名学生的成绩：");
						double score = scan.nextDouble();
						if(score < 80){
							continue;
						}
						num++;
					}
					System.out.println("大于等于80分学生的比例为：" + num/5.0*100 + "%");

4.3 return

return：作用在方法中，表示结束该方法

System.out.println("111");
				System.out.println("222");
				if(true){
					return;
				}
				System.out.println("333");
				System.out.println("444");			

4.4 lable

含义：给循环做标记

面试题：以下代码会在编译时报错还是运行时报错还是不会报错？
不会报错

for(int i = 0;i<5;i++){
		System.out.println("用良心做教育，做真实的自己...");
	}

需求：
嵌套循环，外层循环5次，内层循环4次
当外层循环到第3次时，在内层循环中结束掉外层循环

	a:for(int i = 1;i<=5;i++){
		for(int j = 1;j<=4;j++){
			System.out.println(i + " -- " + j);
			if(i == 3){
				break a;
			}
		}						

万年历

import java.util.Scanner;
public class Test07{
public static void main(String[] args){
	//输入年和月
	Scanner scan = new Scanner(System.in);
	System.out.println("请输入年份：");//2021
	int year = scan.nextInt();
	System.out.println("请输入月份：");//12
	int month = scan.nextInt();
	
	//计算1900年到输入年的总天数
	int allDayOfYear = 0;
	for(int i = 1900;i<year;i++){
		if(i%4==0&&i%100!=0 || i%400==0){//闰年
			allDayOfYear += 366;
		}else{//平年
			allDayOfYear += 365;
		}
	}
	
	//计算1月到输入月的总天数
	int allDayOfMonth = 0;
	for(int i = 1;i<month;i++){
		switch(i){
			case 1:case 3:case 5:case 7:case 8:case 10:case 12:
				allDayOfMonth += 31;
			break;
			case 4:case 6:case 9:case 11:
				allDayOfMonth += 30;
			break;
			case 2:
				if(year%4==0&&year%100!=0 || year%400==0){//闰年
					allDayOfMonth += 29;
				}else{//平年
					allDayOfMonth += 28;
				}
			break;
		}
	}
		//计算总天数
	int allDay = allDayOfYear + allDayOfMonth + 1;
	
	//计算星期
	int week = allDay%7;
	if(week == 0){//说明输入月的第一天是星期天
		week = 7;
	}
	
	//获取当月的天数
	int day = 0;
	switch(month){
		case 1:case 3:case 5:case 7:case 8:case 10:case 12:
			day = 31;
		break;
		case 4:case 6:case 9:case 11:
			day = 30;
		break;
		case 2:
			if(year%4==0&&year%100!=0 || year%400==0){//闰年
				day = 29;
			}else{//平年
				day = 28;
			}
		break;
	}
	
	//打印日历
	
	//打印日历 -- 头部信息
	System.out.println("--- " + year + "年" + month + "月 ---");
	System.out.println("一\t二\t三\t四\t五\t六\t日");
	
	//打印日历 -- 空格
	int num = 0;
	for(int i = 1;i<week;i++){
		System.out.print("\t");
		num++;
	}
	
	//打印日历 -- 日期
	for(int i = 1;i<=day;i++){
		System.out.print(i + "\t");
		num++;
		if(num % 7 == 0){
			System.out.println();//换行
		}
	}
}
}

作业

Work01.java

Work02.java

Work03.java

Work04.java

Work05.java

Work01.java

Work02.java

Work03.java

Work04.java

Work05.java

Work06.java
3:case 5:case 7:case 8:case 10:case 12:
allDayOfMonth += 31;
break;
case 4:case 6:case 9:case 11:
allDayOfMonth += 30;
break;
case 2:
if(year%40&&year%100!=0 || year%4000){//闰年
allDayOfMonth += 29;
}else{//平年
allDayOfMonth += 28;
}
break;
}
}
//计算总天数
int allDay = allDayOfYear + allDayOfMonth + 1;

//计算星期
int week = allDay%7;
if(week == 0){//说明输入月的第一天是星期天
	week = 7;
}

//获取当月的天数
int day = 0;
switch(month){
	case 1:case 3:case 5:case 7:case 8:case 10:case 12:
		day = 31;
	break;
	case 4:case 6:case 9:case 11:
		day = 30;
	break;
	case 2:
		if(year%4==0&&year%100!=0 || year%400==0){//闰年
			day = 29;
		}else{//平年
			day = 28;
		}
	break;
}

//打印日历

//打印日历 -- 头部信息
System.out.println("--- " + year + "年" + month + "月 ---");
System.out.println("一\t二\t三\t四\t五\t六\t日");

//打印日历 -- 空格
int num = 0;
for(int i = 1;i<week;i++){
	System.out.print("\t");
	num++;
}

//打印日历 -- 日期
for(int i = 1;i<=day;i++){
	System.out.print(i + "\t");
	num++;
	if(num % 7 == 0){
		System.out.println();//换行
	}
}

}
}

### 作业  

<video src="D:\2113java_workspace\Day05\02_评讲作业.mp4"></video>

 [Work01.java](D:\2113java_workspace\Day05\Work01.java) 

 [Work02.java](D:\2113java_workspace\Day05\Work02.java) 

 [Work03.java](D:\2113java_workspace\Day05\Work03.java) 

 [Work04.java](D:\2113java_workspace\Day05\Work04.java) 

 [Work05.java](D:\2113java_workspace\Day05\Work05.java) 

<video src="D:\2113java_workspace\Day06\Day06上午\02_评讲作业.mp4"></video>

 [Work01.java](D:\2113java_workspace\Day06\Day06下午\Work01.java) 

 [Work02.java](D:\2113java_workspace\Day06\Day06下午\Work02.java) 

 [Work03.java](D:\2113java_workspace\Day06\Day06下午\Work03.java) 

 [Work04.java](D:\2113java_workspace\Day06\Day06下午\Work04.java) 

 [Work05.java](D:\2113java_workspace\Day06\Day06下午\Work05.java) 

 [Work06.java](D:\2113java_workspace\Day06\Day06下午\Work06.java)