Week01
作者：互联网
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
- 如果你仅仅运行java程序，只用安装JRE即可，但是你要编写Java程序，就必须安装JDK和JRE
- JDK的安装包，安装完JDK后会自动的提示你安装JRE（JDK安装包中包含了JRE）
- 安装路径建议用默认路径（如果自定义路径需注意不要有中文的出现）
- 安装后不会像QQ有开启软件的图标（可以在控制面板中查看是否安装）
配置环境变量
目的：让当前系统识别到JDK
目的地：计算机右键属性 -> 高级系统设置 -> 高级卡页 -> 环境变量
注意用户变量和系统变量的区别
用户变量配置的内容只能在当前用户中使用
系统变量配置的内容可以在所有用户中使用
一般都在用户变量中设置即可
名 值 JAVA_HOME（需要新建） C:\Program Files\Java\jdk1.8.0_144 Path %JAVA_HOME%\bin 注意：
- 大小写
- Path中的路径往往是多个，多个路径之间用英文的;隔开
- 配置好了以后就点确定
检测环境变量是否配置成功
打开cmd窗口/黑窗口/命令行：搜索cmd
输入java -version和javac -version
配置错误的原因：环境变量的路径有误
注意：配置错误，修改后，重新开启cmd
编写Java程序
1.常用命令
命令 描述 cd… 返回上一级目录 cd/ 返回根目录 cd 文件夹名 进入此文件夹 d: 进入到d盘 cls 清空cmd
2.在记事本编写代码
工作空间 - workspace：存放代码的文件夹
注意：
- 何老师按照每一天一个文件夹（Day01），你们（MyDay01）的形式命名
- 不要隐藏文件的扩展名
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.代码细节
- public修饰的类名必须和文件名一致
- Java是一门大小写敏感的语言
- 括号都是成双成对的
- 方法里的代码都是从上往下执行-顺序执行
- 方法中的代码又叫做执行语句/代码块/方法体，执行语句用分号结束
Java编码规范
1.书写规范
注意：
- 运用tab让代码更有层次感，可读性提高
- 类名使用帕斯卡命名法（大驼峰命名法–单词首字母大写）
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)
标签：case,Week01,0000,int,System,println,out 来源： https://blog.csdn.net/yl060917520/article/details/122802811