java学习基础课（渡一教育）（一）

记录自己看渡一教育免费java基础课的学习过程。

第四课：基本数据类型

数据类型：分为基本数据类型和引用数据类型

基本数据类型 8个
4整型 byte short int long64
2浮点型 float 32 double 64
1字符型 char 16bit 2字节 Unicode编码 0-65535
1布尔型 boolean 1bit true false
引用数据类型
数组[]
类class(抽象类abstract class)
接口interface
枚举enum
注解@interface

基本数据类型

整型
（1）byte 字节型------>8个bit 敏感单元位
1byte为8bit 0 0000000（用第一个bit位置来记录符号 0正数 1负数）
一共256种组合，数值的范围 − 2 7 — — 2 7 − 1 -2^7——2^7-1 −27——27−1（$-128 $ ~ 127）（有一个特殊的0）
（2）short ：2字节为16bit；65526种 -32768 32767
（3）int：4字节为32bit ； -2147483648到2147483647
（4） long：8字节为64bit
浮点型
（1）float：4字节；32bit
0 000000000 00000000000000000000
（2）double ：8字节
字符
‘a’ ‘+’ ‘我’ '5’都是字符型；字符中数字和整数的数字冲突，为了以示区分每一个字符的前后各加单引号。
中文两个字节英文一个字节。

为什么英文和符号和数字是一个字节?为什么中文是两个字节?
ASCII 美国信息交换标准代码
a------00000000------97
a------00000000------97
a------00000000------97
字母数字符号一共也就：26*2 + 10 + 100=256.所以说，字节256种组合描述英文字符肯定够了，所以一个字节就够了，英文是ASCII。但是中文是Unicode编码方式。

布尔型
boolean ：1bit ； true 或者 false
C语言中true和false可以换为1和0，但是在 java中不可以。

第五课：常量与变量

常量

常量代表是程序运行过程中 不能再次改变的值!!!
常量的作用：
（1）固定的值，代表计算过程中经常用到的值，便于程序计算
比如：圆周率 3.1415926…
（2）用来代表一个含义
比如：1 2 3 4分别代表上下左右四个方向
什么样的值算是常量???
（1）固定不变的值算作常量
1 3.14 ‘a’ true
可以认为所有基本类型的值固定不变是常量
（2）特殊的常量
“abc”—>String
String是一个引用数据类型，它的值很特殊可以简单的视为常量
（3）自己创建的空间存储一个值让他固定起来不能改变
final int UP = 1；

变量

变量指的是：程序执行过程中可以改变的
变量是一个内存空间(小容器)
变量空间在创建(声明)的时候，必须指定数据类型，变量空间的名字
变量空间，里面只能存储一个内容(值引用)
变量空间内的内容可以改变。
创建变量时需要注意命名的问题
（1）命名的规则：
字母(大小写敏感)；
数字(0-9不允许开头)；
符号(英文符号 _ $) ；
中文(不推荐)

（2）命名的规约
类名字首字母大写；如果两个以上的单词所有首字母都大写
SuperPerson
变量名首字母小写；如果两个以上的单词之后的首字母大写
superPerson
所有名字都需要见名知义；为了增强程序的可读性。

（3）变量如何创建/声明
数据类型变量名字;
int a;
String b;

需要注意:
变量是一个空间可以只创建空间里面不存放内容
变量空间创建后是没有默认的内容空的
空的变量空间不能拿来使用编译错误
byte x;//声明一个变量空间空间的名字是x 空间内要求存储的类型是byte整数
x = 1;//将一个1赋值到x空间内进行存储
//自己理解：其实计算机每个位置有自己的名字比如：00000x0000是一个地址。然后当你byte x的时候，声明了一个空间，空间的名字别称是x，你在给x赋值，意思就是，你这个地址位置存的数字是一个1。

计算机底层做了什么事情？？？
（1）. x是什么? 变量空间存在哪儿?----栈内存里
（2）. 1是什么? 1是常量存在哪儿?----常量缓冲区
（3）. =是什么? =是赋值做了什么?

计算机做的实际上就是：
(1). 硬盘上创建了一个文件 Test.java
(2). 文件中的内容是我们编写的源代码(跟计算机发送指令)
public class Test{
public static void main(String[] args){
byte x;
x = 1;
}
}
(3).将Test.java源文件---->编译---->Test.class
内容是我们看不懂的 字节码 ，留给计算机识别
(4).执行---->内存中执行
将硬盘上的Test.class内容加载到内存里，这个内存是由JVM为我们开辟的一块内存。
(5).我们写好的指令，执行内存的空间赋值(常量是从常量池中复印一份出来的) ，变化…

写一段代码：

public class Test{public static void main(String[] args){byte a = 1;short b = 2;int c = 3;//-2147483648    2147483647long d = 2147483648L;//内存中数字是int的，你超过了int最大值，程序以为你出错误了，所以编译不过。不超过可以不加L，但是float必须加F//float e = 3.4;//报错float e = 3.4F;double f = 4.5;char g = 'a';boolean h = true;String i = "abc";//String是一个引用数据类型，它的值很特殊  可以简单的视为常量}
}

刚才提到过，变量的值是从常量池中取出来的。
值得注意的是：常量池中的数字：整数存的是32位；浮点型存的是64位。

针对代码有三个问题：

问题1：float e = 3.4;为什么报错
从double转化到float会有损失
1 3.4 常量值
存储在常量缓冲区中的
常量值的存储形式肯定不是十进制是以二进制形式存储
1----> 32bit(int)
3.4–> 64bit(double)
这样你把3.4这个64位，存到32位的float，就会报错。
但是如果你觉得32位就够用了，你就自己手动加一个F。所以改为：float e = 3.4F;

问题2：byte a = 1;为什么不报错呢？1在常量池中也是32位，为什么放到8为byte中却不报错呢？
1—>32bit
00000000 00000000 00000000 00000001
a—>8bit
00000001
=赋值的时候做了一个自动的决定自动类型转化
1byte==8bit 0 0000000
检查你前面都是0了，所以不会出现编译错误，一旦你前面多出来的那几位有1，就会出现编译错误
比如byte a = 129就会报错。因为超出了0 0000000的最大范围，32bit中前面有1了。
那为什么float不能自己识别呢，那是因为float和double有自己的编码方法，
是第1位表示符号，然后的9位就表示整数，也就不会自动类型转化了。记住float要加F就行。

问题3：long d = 2147483648L;为什么加L呢？
-2147483648到2147483647是int类型的取值范围
如果创建的常量值超过以上范围
程序编译检测的时候会认为数字太大
如果我们真的需要那么大的数字必须在后面加L告知

总而言之：long d = 2147483648L;//内存中数字是int的，你超过了int最大值，编译不过。不超过可以不加L，但是float必须加F。

字符字符串
char：基本数据类型；‘a’
String：引用数据类型； “a” “abc” “” null

第六课：类型转换问题

类型之间的转换问题：

同种数据类型之间是可以直接进行赋值操作
例如：int a = 1;int b = a; 或者float x = 3.4;float y = x;
数据类型不同的空间之间的赋值—>转换问题

同种大数据类型之间才能发生转换
(1) 基本类型----基本类型之间可以直接转换(自动强制)（主要关注这个）
(2)引用类型----引用类型之间可以直接转换(自动强制–上转型下转型)
(3)基本类型----引用类型之间不可以直接转换(间接–包装类/封装类)

基本类型----基本类型之间的自动：
byte a = 1; //8bit -128~127
int b = a; //32bit 小的空间放大大的空间，可以通过编译，这是自动类型转换
基本类型----基本类型之间的强制转换：
int a = 1;//编译--运行
byte b = (byte)a;//大空间的值放到小空间，需要强制转换，这种强制转换不会出现问题，因为a的值是1放到小空间中也可以放得下，不会溢出
00000000 00000000 00000000 00000001 只保留最后的8bit位强制只留最后8位，不会出错的。
但是下面这种时候就会有一个问题：
int a = 1000;
byte b = (byte)a;//编译是不会出错，但是值丢了编译好用执行后 b存放的值一定发生变化
首先电脑会把十进制–>二进制除以2取余数余数倒序排列变成比特位，1000就变成00000000 00000000 00000011 11101000这种形式，然后只留最后8个，导致数发生了变化，虽然编译没有问题的，但是实际上是出现了数值发生变化了的问题的。

基本类型—基本类型
（1）小数据类型相同：都是整型都是浮点（比较内存空间的大小）
大空间变量可以直接存储小空间的数据
小空间变量不可以直接存储大空间的数据(需要强制类型转换)
转换过程写法都好用如果转换的过程中数值范围超过边界可能会有损失
byte a = 1; int b = a;//自动直接转化就可以
int a = 1; byte b = (byte)a;//需要强制类型转换
float x = 3.4F; double y = x;//自动直接转化
double x = 3.4; float y = (float)x;//强制转换
如果发现强制转换之前的数值比较大，强制转化可以，但是值会发生变化。
int a = 1000; byte b = (byte)a;//编译好用执行后 b存放的值一定发生变化，但是剩下什么是有他的规则的
（2）小数据类型不同：
整型—浮点型
两个比较精确程度，浮点型精确程度更高，可以直接存放整数，反之需要强制转换
任何一个浮点型都可以直接存放一个整型
int a = 1; float b = a;//自动直接转化
float a =1.0F; int b = (int)a;//强制类型转换直接砍掉小数部分
整型—字符型
每一个字符都对应这一个Unicode码 a–97
char x = 'a'; int y = x;//自动转化 y--97
char x = '5'; int y = x;
char x = '我'; int y = x; //好多类型转换
int x = 97; char y = (char)x;//强制的转化
布尔类型很特殊，不能与其他基本类型之间发生转化
引用类型之间后续…

第七课&第八课：运算符号

Java运算符

运算符 ：用来指明对于操作数的运算方式
按照操作数的数目来进行分类：
单目（a++）；双目（a+b）；三目（(a>b) ? x : y）。
按照运算符的功能来进行分类：
算术运算；赋值运算；关系运算(比较)；逻辑运算；位(bit)运算。

算术运算：+ ； -； *； /； %(取余取模)；++(自增) ； --(自减)。
int x = 1 ;
x = x+1 ;//=是一个赋值运行；x空间内的值加一个从常量池中再拿一个1，相加等于2 ，再把值赋给x
x++;//x空间内的值自增一个
++x;//对于x空间内的值来讲都是一致最终的结果都自增了一个
但是如果后期进行赋值，将这个x++或者++x进行赋值，会影响被赋值的元素的值。

问题1：int x = 1; int y = x++;此时x=??；y=??
答案：x=2；y=1
解析： x++先赋值（把值1赋给y），再自增。

问题2：int x = 1; int y = ++x;此时x=??；y=??
答案：x=2；y=2
解析： ++x先自增，再把值赋给y。

在内存空间中考虑：
int x = 1;
int y = x++;//++在后先赋值后自增(先进行计算后赋值)
x++;//x=x+1;
将x变量空间的内容先取出；常量区取出1；进行计算；再次存回x空间。
x在想要做值交换(计算)的时候，会产生一个临时的副本空间(备份)，
++在变量的前面（++x）先自增后备份； ++在变量的后面（x++）先备份后自增。
会将副本空间内的值赋给别人。
这里是x++，先备份x=1，然后在计算x++为2，将这个值赋给x，将备份的x=1副本空间内的值赋给y。

问题3：int a = 1; a =a++;此时a=??
答案：a= 1
解析：先备份后自增，备份中a‘=1，自增a=2，但是将备份中的值给a，所以a=1。

问题4：
int a = 1; for(int i=1;i<=100;i++){//循环结构 a = a++; }
答案：a= 1
解析：先备份后自增，备份中a’=1，自增a=2，但是将备份中的值给a，所以a=1。

赋值运算

= ： 赋值符号 将=右边的内容(值引用) 存入=左边的变量空间内
+=； -= ； *= ； /= ； %=；复合型赋值运算符。
int x = 1;
x+=10;//相当于是：x=x+10;

问题1：int x = 1;
x+=2;//3
x=x+2;//3 这写代码都不会报错
但是下面的代码会报错：
byte x = 1;//1常量32bit =自动转化
x+=2;// x+2 +自动类型提升 3 =自动转化
x = (byte)(x+2);//编译出错类型从int转化成byte可能有损失出错原因：后面是表达式，所以=自动转化无效报错。
解析：x = (byte)(x+2);为什么会报错？运算过程： x变量空间的值取出，从常量区取过来2 ，加法运算，结果重新存回x变量空间内。
x空间–>1； 8bit
常量区–>2； 32bit
00000001 + 00000000 00000000 00000000 00000010
+自动类型提升 8bit1–32bit
00000000 00000000 00000000 00000001
00000000 00000000 00000000 00000010
+00000000 00000000 00000000 00000011==3但是这个3是32bit，你要把这32位存到x的8bit位，由于后面其实是一个表达式，=不会进行自动转换，所以报错。但是，x+=2;中的+=表示的是一个符号，后面是一个数值，同样也是32bit，但是由于是一个数值，不是表达式，所以可以自动转换，识别为前面24位都是0，所以不会直接结果为3.

关系运算:t通常是一个条件的判定

< ； <= ； >；>= ； != ； == ； (对象 instanceof 类)
区分 = = = 和 = = == == 区别：
= = =赋值符号，将 = = =后面的结果(值引用)存入 = = =左边的变量空间内
= = == ==比较符号，比较 = = == ==前面和 = = == ==后面的元素(值引用)是否一致
比较运算符的最终结果是什么?
boolean ： true ；false。
(3>2)—>true; (3>4)—>false; (3==4)—>false;
(3>=2)—>true; (3>=4)—>false; (3!=4)—>true;

逻辑运算
逻辑运算符前后连接的两个都是boolean的值
逻辑运算最终的结果还是boolean

& 逻辑与 ：可以理解为中文的"和","并且"意思 &前两个条件必须同时满足最终才为true
| 逻辑或 ：可以理解为中文的"或者" | 前后两个条件只要有一个满足最终就为true
^ 逻辑异或 ：前后两个表达式只要结果不相同最终结果就为true(专治强迫生)
! 逻辑非：可以立即为中文的"不"，将原来的结果取反。后面只能放一个表达式，其他的都是连接两个表达式。
&& 短路与：与两个条件同时满足如果当第一个条件已经为false 最终肯定是false
|| 短路或：或两个条件有一个满足如果当第一个条件为true 最终肯定为true

&&短路与
1.短路什么情况下才会发生短路? 当前面的值结果为false的时候会发生短路
2.短路到底短路的是什么? 短路的是&&之后所有计算的过程
3.如果发生了短路情况性能比&稍微好一点
4.&逻辑与和 &&短路与从执行的最终结果来看没有任何区别
5.短路与不一定提高了性能只有当前面为false的时候才会发生短路才会提高性能
开发的时候喜欢使用短路与和短路或，因为有可能会提高效率。

位(bit)运算
&按位与； | 按位或； ^按位异或； ~按位取反
<<按位左位移； >>按位右位移； >>>按位右位移(无符号)

进制转化问题
如何将十进制—>二进制
60十进制---->32个0或1来表示60 60除以2取余数将余数倒叙排列即为有效位
00000000 00000000 00000000 00111100
如何将二进制—>十进制
从右至左开始计算，每一个元素乘以2的位置(0开始)次幂，最终求和。
八进制
每三个bit记录为一个小组–>小组长名字(3个bit计算成十进制)
00000000 000 000 000 000 000 000 111 100
0 7 4
八进制01234567
将三个二进制合并为一个计算成十进制表示八进制表示形式以0开头
074
十六进制
每四个bit记录为一个小组–>小组长名字(4个bit计算成十进制)
00000000 0000 0000 0000 0000 0011 1100
0X表示十六进制开头 3 C
10-A 11-B 12-C 13-D 14-E 15-F
十六进制0123456789ABCDEF
0X3C

3 ^ 5 = ?
1.将3和5转化成二进制表示形式
2.竖着按照对应位置进行 & | ^计算 (1–>true 0–>false)
3.将计算后的二进制结果转化为十进制
00000011
00000101
00000110–>6
所以：3 ^ 5 =6

原码，反码，补码
6：正数的三个码一样。
原码：00000000 00000000 00000000 00000110
反码：00000000 00000000 00000000 00000110
补码：00000000 00000000 00000000 00000110
-6：
原码：10000000 00000000 00000000 00000110
反码：11111111 11111111 11111111 11111001 符号不动其余取反
补码：11111111 11111111 11111111 11111010 反码+1
计算机中不管是整数还是负数存储的形式都是以补码形式来存储
注意：反码是一种表示形式；取反是一个计算过程(每一个位置都取反)

~6 = ?
计算机中不管是整数还是负数存储的形式都是以补码形式来存储，所以计算机中的6的是：00000000 00000000 00000000 00000110
~6，取反是一个计算过程(每一个位置都取反)
对6取反的结果：11111111 11111111 11111111 11111001计算机中的这个补码在算成数，转为反码，再转为原码，应该为-7。

6<<2 =24
整体向左移动两位，前面两个被挤没了，后面补2个0。
00000000 00000000 00000000 00000110
000000 00000000 00000000 0000011000
相当于乘以2的位移次幂

6>>1==3
整体向右移动两位，后面两个被挤没了，前面补2个0。
00000000 00000000 00000000 00000110
0000000000 00000000 00000000 000001
相当于除以2的位移次幂

-6>>>1
11111111 11111111 11111111 11111010
?11111111 11111111 11111111 1111101
两个>>保留符号位置 1 填1
三个>>> 不保留符号不管是什么都填0

第九课：语法结构之if

笔试题：

问题1：考察++ – += ==类似的这种符号

问题2：&和&&的区别
&可以视为逻辑运算 可以视为位运算 &&只能当作逻辑运算来用
如果两个符号都当作逻辑运算符来使用时候如下区别
& 前后两个条件都是true 最终结果就是true
&& 短路与正常情况下&执行结果是一致
当前面条件为false的时候发生短路最终结果false

问题3：最有效率的方式计算2*8的结果
2<<3：相当于2乘以2的3次幂。
00000010
00010000 == 16
乘数刚好是2的次幂
如果不是次幂，只能用普通的乘法来进行计算：
00000010
×00001000
---------------------
00000000
00000000
00000000
00000010
00000010000 == 16
类似普通乘法，第二行最后一个0去乘以第一行每个元素，第二行倒数第二个0去乘以第一行每个元素，记得移位…然后所有数值相加。得到最终结果转为十进制数制。

问题4：两个变量int a = 1; int b = 2;如何将两个变量的值进行交换

int a = 1;
int b = 2;
方式一 ：采用一个中间变量空间
int c = a;
a = b;
b = c;
好处是比较容易理解值也不会出问题不好在于产生一个新的内存空间。
方式二：利用两数之和
a = a+b;//a空间存储的是两个元素之和 a==3 b没有变化 b==2
b = a-b;//利用两个元素的和减原来的b剩下是原来的a 赋值给b b==1 a==3
a = a-b;//利用a空间两个元素的和减原来的a 剩下是原来的b 赋值给a a==2 b==1
好处是省略了一个新的空间不好在于第一个：相对来讲不是很容易理解第二个：c 可能会在+产生值越界
方式三：利用两个数字异或的中间值
a = a^b; //1^2=001^010=011====3 a变成了中间值3
b = a^b; //3^2=011^010=001====1 原理：中间值（a^b）异或b结果为a
a = a^b; // 3^1=011^001=010=====2 原理：中间值（a^b）异或a结果为b
原理：一个数字异或同一个数字两次值不会改变

Java语法结构(流程控制)
顺序结构
分支结构：单分支if ；多分支switch；
循环结构：for ； while ； do…while；

分支结构
结构一 ：

if(值--boolean){执行 单行 多行
}

结构二：

if(条件){代码1}else{代码2}

结构三：

if(明天下雨){在学校}else if(坐过山车){游乐场}else if(看电影){万达影城}else{其他}}

设计一个小程序帮我学习英文(星期七个单词)
用户输入的1–> monday

输入功能：

lib提供好的类库 Scanner引用开发者给我们提供好的一个类文件 Scanner.java
int x = 1;
Scanner y = ???
想要利用Scanner需要如下三步
1.在类上面的第一行 import java.util.Scanner;//导入一个包
2.需要输入之前Scanner y = new Scanner(System.in);//对象
3.通过y.让他来做事 int = nextInt();//读取字 String = nextLine(); //读取字符串。都可以读取输入的信息

import java.util.Scanner;//倒入一个包public class StudyEnglish{public static void main(String[] args){Scanner input = new Scanner(System.in); //对象System.out.println("请您输入一个数字，我来输出对应的英文星期");int day = input.nextInt();//可以读取我们输入的文字   input.nextLine();读取字符串if(day==1){System.out.println("monday");}else if(day==2){System.out.println("tuesday");}else if(day==3){System.out.println("wednesday");}else if(day==4){System.out.println("thursday");}else if(day==5){System.out.println("friday");}else if(day==6){System.out.println("saturday");}else if(day==7){System.out.println("sunday");}else{System.out.println("你不好好玩");}}
}

关于if习题

习题一：利用if语句实现一个判断给定月份对应的季节
month==5 345春天 678夏天 9 10 11秋天 12 1 2冬天

import  java.util.Scanner;
public class Month{public static void main(String[] args){System.out.print("请输入一个月份：");Scanner input = new Scanner(System.in);int month=input.nextInt();if(month==3 || month==4 ||month==5){System.out.print("春天");}else if(month==6 || month==7 ||month==8){System.out.print("夏天");}else if(month==9 || month==10 ||month==11){System.out.print("秋天");}else if(month==1 || month==12 ||month==2){System.out.print("冬天");}else{System.out.print("输入错啦，不是月份");}}
}

实现功能的基础上能不能做优化(代码结构–简单减少冗余性能内存空间)
优化代码如下：

import java.util.Scanner;public class SeasonDemo{public static void main(String[] args){//1.创建一个month变量 用来存储一个月份值(Scanner)Scanner input = new Scanner(System.in);System.out.println("请输入一个月份，我来帮您判断所属的季节");int month = input.nextInt();//帮我们读取输入的数字   input.nextLine();读取字符串//2.通过month存储的值 进行季节的判断if(month<1 || month>12){System.out.println("您输入的数字不符合月份 数据有误");}else if(month>=3 && month<=5){System.out.println("春天");}else if(month>=9 && month<=11){System.out.println("秋天");}else if(month>=6 && month<=8){System.out.println("夏天");}else{System.out.println("冬天");}}
}

习题二：利用if语句实现一个判断学生成绩对应的区间
不及格 60-70及格 70-80中 80-90良 90-100优秀 100满分数据有误

import  java.util.Scanner;
public class Score{public static void main(String[] args){System.out.print("请输入成绩：");Scanner input = new Scanner(System.in);int score=input.nextInt();if(score<60){System.out.print("不及格");}else if(score>=60&&score<70){System.out.print("及格");}else if(score>=70&&score<80){System.out.print("中");}else if(score>=80&&score<90){System.out.print("良");}else if(score>=90&&score<100){System.out.print("优秀");}else if(score==100){System.out.print("满分");}else{System.out.print("输入错啦，不是分数");}}
}

习题三：扩展
利用if实现一个随机摇骰子的小游戏
随机摇一个骰子点数 1-6 123 456
玩家利用Scanner输入猜大小
利用if比较猜对啦猜错啦 Math.random();


import java.util.Scanner;public class DiceGame{public static void main(String[] args){//1.随机摇骰子的过程   随机产生一个骰子点数  1-6整数//Math--->Scanner(1.import 2.new 3.input.next();)double value = Math.random();//有范围[0.0-1.0)  0.0----0.99999999int number = (int)(value*6+1); //强制转换为1-6//2.让玩家猜测大小     大 小Scanner input = new Scanner(System.in);System.out.println("买大买小 买定离手");String choose = input.nextLine();//帮我们读取输入的文字//3.比较点数与猜测结果System.out.println("本次摇出的点数为:"+number);//   (点数1 2 3 同时 小) 或者 (点数4 5 6 同时 大)//   (number<=3 && choose.equals("小")) || (number>3 && choose.equals("大"))//   ==  equals();区别//   "a"=="b"   "a".equals("b");if((number<=3 && choose.equals("小")) || (number>3 && choose.equals("大"))){System.out.println("恭喜您 猜对啦");}else{System.out.println("对不起 猜错啦 给2块钱");}}
}

课时十：switch语句

分支语句
单分支 if
多分支 switch

switch(值){  //  byte  short  int  char    1.5版本之后enum   1.7版本之后Stringcase 值1:代码1;[break;] 可有可无case 值2:代码2;default:代码}

if：好处 (可以写复杂的逻辑) 不好处执行比较慢
switch：好处 (判断的过程效率更高) 不好处只能做 == (固定值)

习题一：输入一个数字—输出对应的英文(星期)

import java.util.Scanner;public class TestSwitch{public static void main(String[] args){Scanner input = new Scanner(System.in);System.out.println("请您输入一个数字，我来帮您输出对应的星期");int day = input.nextInt();switch(day){case 1:System.out.println("monday");break;case 2:System.out.println("tuesday");break;case 3:System.out.println("wednesday");break;case 4:System.out.println("thursday");break;case 5:System.out.println("friday");break;case 6:System.out.println("saturday");break;case 7:System.out.println("sunday");break;default:System.out.println("error");break;}}
}

习题二：利用switch语句实现一个判断学生成绩对应的区间
不及格 60-70及格 70-80中 80-90良 90-100优秀 100满分数据有误

由于switch之后只能是byte short int char 1.5版本之后enum 1.7版本之后String这几个形式，无法写区间，只能写一个值，所以想办法把区间变成值了，这一点我自己没有想到：switch(score/10)

import java.util.Scanner;public class DemoOne{public static void main(String[] args){//1.创建一个变量 score 用来存储学生成绩Scanner input = new Scanner(System.in);System.out.println("请输入一个学生成绩,我来帮您判断区间");int score = input.nextInt();//2.利用成绩的值 来进行判断所在区间switch(score/10){case 0:case 1:case 2:case 3:case 4:case 5:System.out.println("悲催啦 不及格");break;case 6:System.out.println("欧耶 及格万岁");break;case 7:System.out.println("考得还行吧");break;case 8:System.out.println("就比较好啦 也拿不到奖学金");break;case 9:System.out.println("可以拿奖学金啦 请大家吃饭");break;case 10:if(score==100){System.out.println("学霸本ba");break;}default:System.out.println("没你这号人~~");break;}}
}

习题三：利用Scanner输入一个值(代表一个星期几 4 )
为小茗同学制定一个学习计划
1 3 5 学习语文
2 4 6 学习数学
7

import java.util.Scanner;public class DemoTwo{public static void main(String[] args){Scanner input = new Scanner(System.in);System.out.println("请您输入一个星期，我来帮您指定学习计划");int day = input.nextInt();switch(day){case 1:case 3:case 5:System.out.println("应该学习编程");break;case 2:case 4:case 6:System.out.println("应该学习英文");break;case 7:System.out.println("玩儿?想得美，用英文编程序");break;default:System.out.println("想要逃离这七天么?不存在的，好好学习");break;}}
}

第十一课时：循环结构

for
while
do…while

for循环
允许将三个必要条件都写在()内

for(1初始值 ; 258终点判定条件 ; 47变化量 ){36好多好多执行的代码;
}

习题一：

操场上有一百多人让他们排队
三个人一组多一个，四个人一组多两个，五个人一组多两个
求解操场上的人数多少?

解: 设操场的人数 x
x%3== 1; x%4==2 ; x%5 ==2
计算机想要找到x的值不是通过计算得来的 通过最笨拙的方法挨个尝试
想要挨个的尝试需要一个范围
让计算机帮我们在100–200之间挨个的尝试一下哪一个数字符合上述的条件

public class ForDemoOne{public static void main(String[] args){for(int x = 100;x<200;x++){if(x%3==1 && x%4==2 && x%5==2){System.out.println("操场上的人数为:"+x);}}}
}

习题二：

甲乙丙丁四个人加工零件加工的总零件数为370个
如果甲加工的零件数多10
如果乙加工的零件数少20
如果丙加工的零件数乘以2
如果丁加工的零件数除以2
则四个人加工的零件数就相等啦
求四个人加工的零件个数分别是多少?

解: 设四个人相等时的数为x
(x-10) + (x+20) + (x/2) + (x*2) == 370
//我们自己通过草稿纸做一个演算—>最终结果
让计算机帮我们用很多的数字挨个尝试一下看看是否满足上述条件

public class DemoOne{public static void main(String[] args){//可读性  健壮性(严谨)  优化(结构 冗余 效率 内存 复用性 可扩展性)for(int x =1;x<370;x++){if((x-10) + (x+20) + (x/2) + (x*2) == 370){System.out.println("甲加工的零件数为:"+(x-10));System.out.println("乙加工的零件数为:"+(x+20));System.out.println("丙加工的零件数为:"+(x/2));System.out.println("丁加工的零件数为:"+(x*2));}}}
}

习题三：

鸡兔同笼问题
小鸡小兔子关在同一个笼子里小鸡两只脚小兔子四只脚
小鸡+小兔子总数 50只脚的总数160只
求小鸡和小兔子各多少只。

解: 设小鸡x只小兔子 (50-x)
x*2+(50-x)*4 ==160
给计算机一个范围挨个尝试某一个x满足我们的条件

public class DemoTwo{public static void main(String[] args){for(int x=1;x<50;x++){if(x*2+(50-x)*4 ==160){System.out.println("小鸡的个数为:"+x);System.out.println("小兔子个数为:"+(50-x));}}}
}

习题四：

通过循环找寻三位数字的水仙花数
153—> 1 5 3
1 3 + 5 3 + 3 3 = 1^{3}+5^{3}+3^{3}= 13+53+33= 1 + 125 + 27 == 153

100-999之间挨个尝试满足上述规则数字

public class DemoThree{public static void main(String[] args){//double value = Math.pow(double a , double b);//帮我们计算a的b次方/*for(int num=100;num<1000;num++){//int b=(i-a*100)/10;//这一行代码是自己想的方法太麻烦了。新的：b=i%100 /10  一定要记得取余数int b = num/100; //百位int s = num/10%10;//  十 num%100/10; int g = num%10;//个if(b*b*b+s*s*s+g*g*g==num){System.out.println(num+"是水仙花数");}}*/for(int num=100;num<1000;num++){if(Math.pow(num/100,3)+Math.pow(num%100/10,3)+Math.pow(num%10,3)==num){System.out.println(num+"是水仙花数");}}}
}

第十二课时：循环嵌套

控制台输出一行星星随意个数
控制台输出4行星星每一行个数随意
控制台输出4行，第一行一个星星，第二行两个星星，第三行说那个星星，第四行四个星星，左对齐左直角。
控制台输出4行，第一行一个星星，第二行两个星星，第三行说那个星星，第四行四个星星，右对齐右直角。

import java.util.Scanner;public class DrawStar{public static void main(String[] args){//第四题for(int i=1;i<=4;i++){//控制四行//画占位符for(int j=1;j<=4-i;j++){System.out.print(" ");}//画星星for(int j=1;j<=i;j++){System.out.print("*");}//换行System.out.println();}//第三题/*for(int i=1;i<=4;i++){//控制四行//画星星for(int j=1;j<=i;j++){System.out.print("*");}//换行System.out.println();}*///i==5  5<=4  // j==1  j<=3//  *// **//    ***//   ****//  |//第二题/* int count = 4;//每一行星星的个数随意for(int i=1;i<=4;i++){for(int j=1;j<=count;j++){System.out.print("*");}System.out.println();}//让计算机帮我们做4次一样的事情//i j分别控制着什么?    i控制的是行数  j控制的是每一行星星的个数//双层循环嵌套执行的次数是乘机的关系//   i==5   5<=4 false//           j==5  5<=4 true//               ****//             ****//             ****//             ****//             |*///第一题：复用性/*System.out.println("尊敬的客户,您到底要画几个?");Scanner input = new Scanner(System.in);int count = input.nextInt();for(int i=1;i<=count;i++){System.out.print("*");}*/}
}

嵌套实际上可能就是在找规律的变化。

习题一：实现下面的图案

*******
*** ***
**   **
*     *

代码：

import java.util.Scanner;public class Demo1{public static void main(String[] args){//******* 画星星 换行      i==1        4-->7    5-->9//*** ***  画星星  画空格  画星星  换行  i==2    3   1   3//**    **  画星星  画空格  画星星  换行    i==3    2   3   2//*       *  画星星  画空格  画星星  换行   i==4    1   5   1//可读性 健壮性(严谨) 优化(结构 冗余 性能 内存 复用 扩展)  2*i-3    怎么得的？7-（5-i）*2Scanner input = new Scanner(System.in);System.out.println("请您输入行数:");int line = input.nextInt();for(int i=1;i<=line;i++){//控制行数if(i==1){//第一行规则//画星星for(int j=1;j<=2*line-1;j++){System.out.print("*");}}else{//后三行规则//画星星for(int j=1;j<=(line+1)-i;j++){System.out.print("*");}//画空格for(int j=1;j<=2*i-3;j++){System.out.print(" ");}//画星星for(int j=1;j<=(line+1)-i;j++){System.out.print("*");}}//换行System.out.println();}}
}

习题二：

   112112321
1234321

代码：

import java.util.Scanner;
public class Number{public static void main(String[] args){Scanner input = new Scanner(System.in);System.out.println("请您输入行数:");int line = input.nextInt();/*for(int i=1;i<=4;i++){for(int j=1;j<=4-i;j++){System.out.print(' ');}for(int j=1;j<=i;j++){System.out.print(j);}for(int j=i-1;j>=1;j--){System.out.print(j);}for(int j=1;j<=4-i;j++){System.out.print(' ');}System.out.println();*/for(int i=1;i<=line;i++){for(int j=1;j<=line-i;j++){System.out.print(' ');}for(int j=1;j<=i;j++){System.out.print(j);}for(int j=i-1;j>=1;j--){System.out.print(j);}for(int j=1;j<=line-i;j++){System.out.print(' ');}System.out.println();}}
}

习题三：

1*1=1
1*2=2  2*2=4
1*3=3  2*3=6  3*3=9

代码：

import java.util.Scanner;
public class Multiplier{public static void main(String[] args){Scanner input=new Scanner(System.in);System.out.print("请您输入行数:"); //必须放在这，放在其他方，输出不了内容。int line = input.nextInt();for(int i=1;i<=line;i++){for(int j=1;j<=i;j++){System.out.print(j+"*"+i+"="+(i*j)+"\t");}System.out.println();}}
}

补充：

转义字符

\ 转义字符：将身后的一个字符意思发生转换
转换特殊的符号比如 " ’ \
转换几个特殊的字母，比如 \n换行； \r回车； \t制表符；
习题四：
找寻2-100之间的素数(质数) 只能被1和本身整除的数字 2 3 5 7 11
2是素数
3是素数
4不是素数
5是素数
6不是素数
7是素数
8不是素数
9不是素数
代码1：

//典型错误
/*public class Sushu{public static void main(String[] args){for(int i=2;i<=100;i++){ //i=9实验一下for(int j=2;j<i;j++){       if (i%j==0){System.out.print(i+"不是素数");}else{System.out.print(i+"是素数");}}System.out.println();}}
}*/  public class Sushu{public static void main(String[] args){for(int i=2;i<=100;i++){int j=2;for(;j<i;j++){      if (i%j==0){System.out.println(i+"不是素数");break;  //一旦被某个数整除了，立马跳出当前这个循环，只是保证整出一个就是素数，没必要再去整除其他色数字}}//如果j=i了，说明，刚才那个整除的循环执行完毕也没有跳出，也就是他是素数，那么在执行这句if(j==i){  //上面那个循环执行完毕，里面的if从来没有执行过，才是素数，才向下面的输出执行System.out.println(i+"是素数");}}}
}

代码2：进入循环之前定义一个表示符！！！太聪明了吧！

//找一个标识的方法！！！太聪明了吧！！！！怎么判断循环中的if有没有执行成功。
/*for中的if如果执行了，就说明不是素数，就不用执行外面的if
for中的if如果没有执行了，就说明是素数，就执行外面的if
问题是：如何判断if中的语句是否被执行了？？？------------加一个标识符先在进入循环之前，定义一个标识，然后在if中修改标识，
如果if中的内容执行了，那么标识会被修改，循环外对表示符进行判断，决定if中的语句是否被执行。*/
public class Sushu{public static void main(String[] args){//想一个事情   郑中拓  张三我的学生(A大学)//    我 走到A大学学校门口  巧遇张三//    我在学校门口等    张三进学校去钱包//    去钱包的过程中不许做其他的事情    学校的长椅上休息//    张三进入学校   我在门口等  --->出来学校 怎么知道没有座过椅子(椅子刚刷了油漆)//    1.在进学校之前  需要在他的身上放一个标识  (干净的裤子)//    2.如果坐过椅子  标识改变(变脏啦)//    3.出来学校再次看一看标识 (如果跟进学校之前一样 证明没做过 否则做过)// 2-100之间的素数  每一个数字做一个输出for(int num=2;num<=100;num++){//先把1和本身这两个数字  刨除掉//在剩下的数字中挨个找寻一遍  看一看还有没有其他的整除数字boolean x = false;//标识干净的裤子  //内存空间小for(int i=2;i<=num/2;i++){//在其余的数字中挨个找寻 还有没有能整除的if(num%i==0){System.out.println(num+"不是素数");x = true;//相当于标识修改啦 变脏啦 break;//不是中断if  当满足if条件的时候中断循环}}if(x==false){System.out.println(num+"是素数");}}}
}

第十四课时：break；continue；do while

break：中断循环的
continue：终止本次循环，继续下一次循环。
可以给循环起名字：代码：

public class TestBreakAndContinue{public static void main(String[] args){int i=1;int j=1;ok:for(;i<=5;i++){ko:for(;j<=5;j++){if(j==3){continue ok;}//j==3停住一次 继续下一次i++  i=2System.out.println("拓哥再帅一次");}}//执行输出多少次2   执行完毕 i6  j3?System.out.println(i);System.out.println(j);/*ok:for(int i=1;;i<=5;i++){ko:for(int j=1;;j<=5;j++){if(j==3){continue ok;}//j==3停住一次 继续下一次i++  i=2System.out.println("拓哥再帅一次");}}//执行输出多少次2   执行完毕 i6  j3?System.out.println(i);System.out.println(j);*//*int i=1;int j=1;ok:for(;i<=5;i++){ko:for(;j<=5;j++){if(j==3){break ok;}System.out.println("拓哥就是很帅");}}System.out.println(i);System.out.println(j);//输出几次2    i j分别是几?1  3//break为什么终断是里层循环?    不看层次问题    两个循环一模一样//如果j==3时候   break终断外面的循环----???   给循环起名字  循环标记*/}
}

while：while先判断后执行条件不满足不执行啦

初始值;while(终点判定条件){// ()内只允许写一个好多好多执行;变化量;}

我理解就是一个for循环的变体
变量定义在循环外生命周期长了
变化量放在循环内(注意上下的顺序可能对执行产生影响)

do while：do…while先执行后判断条件不满足至少执行一次

初始值;do{好多好多执行;变化量;}while(终点判定条件);

while：while先判断后执行条件不满足不执行啦
do while：do…while先执行后判断条件不满足 至少执行一次
习题1：
while循环小任务
有一个水池已经盛满了120立方米的水
有一个进水管每小时进水18立方米
有一个排水管每小时排水30立方米
两个水管一起开(虽然很浪费)
经过多少小时水池的水排放干净?

习题2：画一个星星

   * i==1  3    1***   i==2  2    3***** i==3  1    5
******* i==4  0    7

代码：

public class TestWhile{public static void main(String[] args){//习题2int i = 1;while(i<=4){//画空格占位int j = 1;while(j<=4-i){System.out.print(" ");j++;}//画星星int k = 1;while(k<=2*i-1){System.out.print("*");k++;}//换行System.out.println();i++;}/*  //习题1int sum = 120;//表示水池中的水int hour = 0;//记录经过小时数 ?while(sum>0){sum+=18;sum-=30;hour++;//记录一次小时数System.out.println("本次循环完毕:"+sum);} System.out.println("经过"+hour+"小时排水完毕");/*/*  //上课2int i = 10;do{System.out.println("执行ing:"+i);//12345i++;}while(i<=5);*//*  //上课1int i = 10;while(i<=5){System.out.println("执行ing:"+i);//12345i++;}System.out.println("执行完毕:"+i);//执行输出什么? 执行完毕后 i==？*/}
}

任务3：
小茗同学从A点以7km/h的速度向B点出发
哥哥从B点以18km/h的速度向A点出发
A和B之间的距离是1000km
求解小茗同学和哥哥经过多少个小时才能相遇?

//计算机其实就是一个不断试数的过程
public class Time{public static void main(String[] args){int t=0;int s=0; do{t++;s=25*t;}while(s!=1000);System.out.println("经过t="+t+"小时相遇");}
}

习题4 ：
有一个瓜农卖西瓜一车西瓜总共1020个
每天卖掉总数的一半多两个
求解瓜农几天才能把所有的西瓜都卖完?

public class Water{public static void main(String[] args){int sum=1020;int t=0;do{sum=sum-(sum/2+2);t++;}while(sum!=0);System.out.println("需要"+t+"天把瓜卖完");      }
}