Java教程

Week01

本文主要是介绍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

  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) 
这篇关于Week01的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!