Java的8种基本数据类型是什么？
8种基本数据类型包括: byte,short,int,long,float,double,boolean,char
byte:字节型，用于存储整数的，占用1个字节，范围-128到127
*char:字符型，采用Unicode字符编码格式，存储单个字符，占用2个字节
*short:短整型，用于存储整数的，占用2个字节，范围-32768到32767
int:最常用的整型，用于存储整数的，占用4个字节，范围-2^31到231-1
long:长整型，用于存储较大的整数的，占用8个字节，范围-2^63到2^63-1
float:单精度浮点型，用于存储小数的，占用4个字节，不能表示精确的值
double:双精度浮点型，最常用的存储小数的类型，占用8个字节，不能表示精确的值
boolean:布尔型，存储true或false，占用1个字节
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
1.变量：存数的
int a; int b,c;
int a = 5; int a; a=5;
int b = a+10; System.out.println(a);
a = a+10; //在a本身基础之上增10
1
2
3
4
5
6
7
2.八种基本数据类型：byte,short,int,long,float,double,boolean,char
- int：整型，4个字节，5,10,10000000...
- long：长整型，8个字节，5L,100000000000000L...
- double：浮点型，８个字节，3.14,54.0,5.678...
- boolean：布尔型，1个字节，true,false
- char：字符型，2个字节，'你','y','4','*'...
1
2
3
4
5
6
7
8
9
3.类型间的转换：
两种方式：自动/隐式、强制 (要转换成为的数据类型)变量
两点规则：
shorts1=5;
shorts2=6;
shorts3=(short)(s1+s2);
1
2
3
4
5
6
7
笔记：
1.运算符：运算的符号
(1)算术：+，-，*，/，%，++，
- %:取模/取余，余数为0即为整除
- ++/--：自增1/自减1，可在变量前也可在变量后
- 单独使用时，在前在后都一样
- 被使用时，在前在后不一样
- a++的值为a--------(a--的值为a)
- ++a的值为a+1------(--a的值为a-1)
```java
//%的演示
System.out.println(8%2); //0，商4余0----整除
System.out.println(5%2); //1，商2余1
System.out.println(2%8); //2，商0余2
//++单独使用:
int a=5,b=5;
a++; //相当于a=a+1
++b; //相当于b=b+1
System.out.println(a); //6
System.out.println(b); //6
//++被使用:
int a=5,b=5;
int c = a++; //1)保存a++的值5 2)a自增1变为6 3)将第1步保存的值5赋值给c--底层运算过程
//---粗暴记法:a++的值为5，c就是5
int d = ++b; //1)保存++b的值6 2)b自增1变为6 3)将第1步保存的值6赋值给d--底层运算过程
//---粗暴记法:++b的值为6，d就是6
System.out.println(a); //6
System.out.println(b); //6
System.out.println(c); //5
System.out.println(d); //6
//--单独使用:
int a=5,b=5;
a--; //相当于a=a-1
--b; //相当于b=b-1
System.out.println(a); //4
System.out.println(b); //4
//--被使用:
int a=5,b=5;
int c = a--; //a--的值为5，所以c的值为5
int d = --b; //--b的值为4，所以d的值为4
System.out.println(a); //4
System.out.println(b); //4
System.out.println(c); //5
System.out.println(d); //4
```
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
(2)关系运算符：>，<，>=，<=，==，!
- 关系运算的结果为boolean型，
关系成立则为true，关系不成立则为false
```java
int a=5,b=10,c=5;
boolean b1 = a>b;
System.out.println(b1); //false
System.out.println(c<b); //true
System.out.println(a>=c); //true
System.out.println(a<=b); //true
System.out.println(a==c); //true
System.out.println(a!=c); //false
System.out.println(a+c>b); //false
System.out.println(a%2==0); //false
System.out.println(c++>5); //false-------c自增1变为6
System.out.println(c++>5); //true--------c自增1变为7
```
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
(3)逻辑运算符：&&，||，!
&&：短路与(并且)，两边都为真则为真，见false则false
> 当第1个条件为false时，发生短路(后面的不执行了)
||：短路或(或者)，有真则为真，见true则true
> 当第1个条件为true时，发生短路(后面的不执行了)
!：逻辑非(取反)，非真则假，非假则真
int a=5,b=10,c=5;
//&&的演示:
boolean b1 = b>=a && b<c;
System.out.println(b1); //true&&false=false
System.out.println(b<=c && b>a); //false&&true=false
System.out.println(a==b && c>b); //false&&false=false
System.out.println(b!=c && a<b); //true&&true=true
int age = 25;
System.out.println(age>=18 && age<=50); //看age是否在18到50之间
//||的演示:
System.out.println(b>=a || b<c); //true||false=true
System.out.println(b<=c || b>a); //false||true=true
System.out.println(b!=c || a<b); //true||true=true
System.out.println(a==b || c>b); //false||false=false
int score = 89;
System.out.println(score<0 || score>100); //看score是否不合法
//!的演示
boolean b2 = !(a<b);
System.out.println(b2); //!true=false
System.out.println(!(a>b)); //!false=true
//短路的演示
int a=5,b=10,c=5;
boolean b3 = a>b && c++>2;
System.out.println(b3); //false
System.out.println(c); //5，发生短路了
boolean b4 = a<b || c++>2;
System.out.println(b4); //true
System.out.println(c); //5，发生短路了
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
(4)赋值运算符：=，+=，-=，*=，/=，%
简单赋值运算符：=
扩展赋值运算符：+=，-=，*=，/=，%=
> 注：扩展赋值自带强转功能
int a = 5;
a += 10; //相当于a=(int)(a+10)
System.out.println(a); //15
a *= 2; //相当于a=(int)(a*2)
System.out.println(a); //30
a /= 6; //相当于a=(int)(a/6)
System.out.println(a); //5
//小面试题:
short s = 5;
//s = s+10; //编译错误，需强转: s=(short)(s+10);
s += 10; //相当于s=(short)(s+10)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
(5)字符串连接：+
- 和 +：
- 若两边为数字，则做加法运算
- 若两边出现了字符串，则做字符串连接
- 任何类型与字符串相连，结果都会变为字符串类型----同化作用
//字符串拼接演示
int age = 38;
System.out.println("age="); //age=
System.out.println(age); //38
System.out.println("age="+age); //age=38
System.out.println("我的年龄是"+age); //我的年龄是38
System.out.println("我今年"+age+"岁了"); //我今年38岁了
String name = "WKJ";
System.out.println("name="+name); //name=WKJ
System.out.println("大家好，我叫"+name); //大家好，我叫WKJ
System.out.println("大家好，我叫"+name+"，今年"+age+"岁了"); //大家好，我叫WKJ，今年38岁了
//同化作用演示
System.out.println(10+20+30+""); //60---------String
System.out.println(10+20+""+30); //3030-------String
System.out.println(""+10+20+30); //102030-----String
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
(6)条件/三目：?:
语法： boolean?数1:数2
执行过程： 注：整个表达式是有值的，它的值要么是?号后的数1，要么是:号后的数2
计算boolean的值：
- 若为true，则整个表达式的值为?号后的数1
- 若为false，则整个表达式的值为:号后的数2
int num = 5;
int flag = num>0?1:-1;
System.out.println(flag); //1
int a=8,b=55;
int max = a>b?a:b;
System.out.println("max="+max);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
2.分支结构：基于条件执行某语句
(1)if结构：1条路
语法：
if(boolean){
语句块
}
执行过程：
判断boolean的值:
若为true，则执行语句块1(if整个结束)
若为false，则if直接结束
//1)偶数的判断:
int num = 5; //带数(6,5)
if(num%2==0){
System.out.println(num+"是偶数");
}
System.out.println("继续执行...");
//2)满500打8折:
double price = 300.0; //消费金额 带数(600.0,300.0)
if(price>=500){ //满500
price *= 0.8; //打8折
}
System.out.println("最终结算金额为:"+price);
//3)判断年龄是否在18到50之间，若满足则输出:"满足条件"
int age = 88; //带数(25,5,88)
if(age>=18 && age<=50){
System.out.println("年龄满足条件");
}
System.out.println("继续执行...");
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
(2)if…else结构：2条路
语法：
if(boolean){
语句块1
}else{
语句块2
}
执行过程：
判断boolean的值:
若为true，则执行语句块1(整个结束)
若为false，则执行语句块2(整个结束)
- 说明：
语句块1和语句块2，必走其中之一------------2选1
//1)偶数、奇数的判断:
int num = 5; //带数(6,5)
if(num%2==0){
System.out.println(num+"是偶数");
}else{
System.out.println(num+"是奇数");
}
System.out.println("继续执行...");
//2)满500打8折，不满500打9折:
double price = 300.0; //带数(600.0,300.0)
if(price>=500){ //满500
price *= 0.8;
}else{ //不满500
price *= 0.9;
}
System.out.println("最终结算金额为:"+price);
//3)判断成绩是否合法，合法则输出"该成绩合法"，否则输出"该成绩不合法":
int score = 560; //带数(95,-90,560)
if(score<0 || score>100){
System.out.println("该成绩不合法");
}else{
System.out.println("该成绩合法");
}
System.out.println("继续执行...");
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
精华笔记：
运算符：运算的符号
算术：+，-，*，/，%，++，–
关系：>，<，>=，<=，==，!=
逻辑：&&，||，！
赋值：=，+=，-=，*=，/=，%=
字符串连接：+
条件/三目：?:
分支结构：基于条件执行某语句
if结构：1条路
if…else结构：2条路
补充：
&为不短路与，|为不短路或
任何复杂的程序逻辑都可以通过三种结构来实现：
顺序结构：从上往下逐行执行，每句必走
分支结构：有条件的执行某语句，并非每句必走
循环结构：明天讲
语言基础第三天作业：
运算符的练习：算术、关系、逻辑、赋值、字符串连接、条件运算符
if的练习：
偶数的判断
满500打8折
年龄在18到50之间
if…else练习：
偶数、奇数的判断
满500打8折、不满500打9折
成绩合法性判断
1、运算符的练习：算术、关系、逻辑、赋值、字符串连接、条件运算符。 完整代码：
//运算符的演示
public class OperDemo {
public static void main(String[] args) {
/*
1.算术运算符:+,-,*,/,%,++,–
1)%:取模/取余，余数为0即为整除
2)++/–:自增1/自减1，可在变量前也可在变量后
2.1)单独使用时，在前在后都一样
2.2)被使用时，在前在后不一样
a++的值为a----------(a–的值为a)
++a的值为a+1--------(–a的值为a-1)
/
/
System.out.println(5%2); //1，商2余1
System.out.println(8%2); //0，商4余0----整除
System.out.println(2%8); //2，商0余2
/
/
int a=5,b=5;
a++; //相当于a=a+1
++b; //相当于b=b+1
System.out.println(a); //6
System.out.println(b); //6
/
/
int a=5,b=5;
int c = a++; //1)将a++的值5赋值给c 2)a自增1变为6
int d = ++b; //1)将++b的值6赋值给d 2)b自增1变为6
System.out.println(a); //6
System.out.println(b); //6
System.out.println©; //5
System.out.println(d); //6
*/
/*
int a=5,b=5;
a--; //相当于a=a-1
--b; //相当于b=b-1
System.out.println(a); //4
System.out.println(b); //4
*/
/*
int a=5,b=5;
int c = a--; //1)将a--的值5赋值给c 2)a自减1变为4
int d = --b; //1)将--b的值4赋值为d 2)b自减1变为4
System.out.println(a); //4
System.out.println(b); //4
System.out.println(c); //5
System.out.println(d); //4
*/
/*
2.关系运算符:
1)>(大于),<(小于)
>=(大于或等于),<=(小于或等于)
==(等于),!=(不等于)
2)关系运算的结果为boolean型，
关系成立则为true，关系不成立则为false
*/
/*
int a=5,b=10,c=5;
boolean b1 = b>a;
System.out.println(b1); //true
System.out.println(c<b); //true
System.out.println(a>=c); //true
System.out.println(b<=a); //false
System.out.println(b==c); //false
System.out.println(a!=c); //false
System.out.println(a+c>10); //false
System.out.println(b%2==0); //true
System.out.println(c++>5); //false------c自增1变为6
System.out.println(c++>5); //true-------c自增1变为7
*/
/*
3.逻辑运算符:
1)&&:短路与(并且)，两边都为真则为真，见false则false
---当第1个条件为false时，则发生短路(后面的不执行了)
||:短路或(或者)，有真则为真，见true则true
---当第1个条件为true时，则发生短路(后面的不执行了)
!:逻辑非(取反)，非真则假，非假则真
2)逻辑运算是建立在关系运算的基础之上的，
逻辑运算的结果也是boolean型
*/
/*
boolean b1 = b>=a && b<c;
System.out.println(b1); //true&&false=false
System.out.println(b<=c && b>a); //false&&true=false
System.out.println(a==b && c>b); //false&&false=false
System.out.println(b!=c && a<b); //true&&true=true
System.out.println(b>=a || b<c); //true||false=true
System.out.println(b<=c || b>a); //false||true=true
System.out.println(b!=c || a<b); //true||true=true
System.out.println(a==b || c>b); //false||false=false
boolean b2 = !(a<b);
System.out.println(b2); //!true=false
System.out.println(!(a>b)); //!false=true
*/
/*
int a=5,b=10,c=5;
boolean b3 = a>b && c++>2;
System.out.println(b3); //false
System.out.println(c); //5，发生短路了
boolean b4 = a<b || c++>2;
System.out.println(b4); //true
System.out.println(c); //5，发生短路了
*/
/*
4.赋值运算符:
1)基本赋值运算符:=
2)扩展赋值运算符:+=,-=,*=,/=,%=
---扩展赋值运算符自带强转功能
*/
/*
int a = 5;
a += 10; //相当于a=(int)(a+10)
System.out.println(a); //15
a *= 2; //相当于a=(int)(a*2)
System.out.println(a); //30
a /= 6; //相当于a=(int)(a/6)
System.out.println(a); //5
short s = 5;
//s = s+10; //编译错误，需强转，改为: s=(short)(s+10);
s += 10; //相当于s=(short)(s+10)
*/
/*
5.字符串连接运算符:
1)+:
1.1)若两边为数字，则做加法运算
1.2)若两边出现了字符串，则做字符串连接
*/
/*
int age = 38;
System.out.println("age="); //age=
System.out.println(age); //38
System.out.println("age="+age); //age=38
System.out.println("我的年龄是"+age); //我的年龄是38
System.out.println("我今年"+age+"岁了"); //我今年38岁了
String name = "WKJ";
System.out.println("name="+name); //name=WKJ
System.out.println("大家好，我叫"+name); //大家好，我叫WKJ
System.out.println("大家好，我叫"+name+"，今年"+age+"岁了"); //大家好，我叫WKJ，今年38岁了
System.out.println(10+20+""+30); //3030---------String
System.out.println(""+10+20+30); //102030-------String
System.out.println(10+20+30+""); //60-----------String
*/
/*
6.条件/三目运算符:
1)语法:
boolean?数1:数2
2)执行过程:
整个条件运算的值，要么是?号后的数1，要么是:号后的数2
计算boolean的值:
若为true，则整个条件运算的结果为?号后的数1
若为false，则整个条件运算的结果为:号后的数2
*/
int num = 5;
int flag = num>0?1:-1;
System.out.println(flag); //1
int a=8,b=5;
int max = a>b?a:b;
System.out.println("max="+max);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
}
2、if的练习：
偶数的判断
满500打8折
//if结构的演示
public class IfDemo {
public static void main(String[] args) {
//1)偶数的判断:
int num = 6; //带数(6,5)
if(num%2==0){
System.out.println(num+“是偶数”);
}
System.out.println(“继续执行…”);
//2)满500打8折
//带数(600.0,300.0)
double price = 300.0; //消费金额
if(price>=500){ //满500
price*=0.8; //打8折
}
System.out.println("最终结算金额为:"+price);
}
}
1
2
3
4
5
6
7
8
9
3、if…else的练习：
偶数、奇数的判断
满500打8折，不满500打9折
//if…else结构的演示
public class IfElseDemo {
public static void main(String[] args) {
//1)偶数、奇数的判断:
int num = 5; //带数(6,5)
if(num%2==0){
System.out.println(num+“是偶数”);
}else{
System.out.println(num+“是奇数”);
}
System.out.println(“继续执行…”);
//2)满500打8折，不满500打9折:
double price = 300.0; //带数(600.0,300.0)
if(price>=500){ //满500，打8折
price*=0.8;
}else{ //不满500，打9折
price*=0.9;
}
System.out.println("最终结算金额为:"+price);
}
}
1
2
3
4
5
6
7
8
9
10
语言基础第四天：
回顾：
运算符：
算术：+，-，*，/，%，++，–
关系：>，<，>=，<=，==，!= boolean
逻辑：&&，||，! boolean
赋值：=，+=，-=，*=，/=，%=
字符串连接：+
条件/三目：boolean?数1:数2
分支结构：基于条件执行的语句
if结构：1条路
if…else结构：2条路
笔记：
1、Scanner接收用户输入的数据：共3步，不需要理解，先背下来
在package下：
import java.util.Scanner;
在main中：
Scanner scan = new Scanner(System.in);
在第2步之下：
System.out.println(“请输入年龄:”);
int age = scan.nextInt();
System.out.println(“请输入商品价格:”);
double price = scan.nextDouble();
package day04;
import java.util.Scanner; //1.导入一个扫描仪
//Scanner的演示
public class ScannerDemo {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in); //2.新建一个扫描仪
System.out.println("请输入年龄:");
int age = scan.nextInt(); //3.扫描一个整数给age
System.out.println("请输入商品价格:");
double price = scan.nextDouble(); //3.扫描一个小数给price
System.out.println("年龄为:"+age+"，价格为:"+price);
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
2、分支结构：
if…else if结构：多条路
语法：
if(boolean-1){
语句块1
}else if(boolean-2){
语句块2
}else if(boolean-3){
语句块3
}else{
语句块4
}
执行过程：
判断boolean-1，若为true则执行语句块1(结束)，若为false则
再判断boolean-2，若为true则执行语句块2(结束)，若为false则
再判断boolean-3，若为true则执行语句块3(结束)，若为false则 执行语句块4(结束)
说明：
语句块1/2/3/4，只能执行其中之一------------多选1
public class ScoreLevel {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.println("请输入成绩:");
double score = scan.nextDouble();
//带数(-25,888,95,85,65,45)
if(score<0 || score>100){
System.out.println("成绩不合法");
}else if(score>=90){ //合法
System.out.println("A-优秀");
}else if(score>=80){
System.out.println("B-良好");
}else if(score>=60){
System.out.println("C-中等");
}else{
System.out.println("D-不及格");
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
3、switch…case结构：多条路
优点：效率高、结构清晰
缺点：只能对整数判断相等
break：
若case中有break：打印对应的case语句后，直接跳出switch
若case没有break：从对应命令的case开始往下贯穿打印每一句话
default：可以写在switch中的任何地方；写不写都可以；
若写了:在case没有匹配参数时会按顺序执行(此时不执行case，因为都未匹配成功先执行default再贯穿剩余case)；
:在case匹配了参数时不会执行default
若没写：会按顺序执行case匹配到的语句；若没有匹配的则全部执行
常见面试题：switch可以作用于什么类型的数据上
----byte,short,int,char,String,枚举类型
1
2
3
4
5
6
7
package ooday6.day04.switch0_0;
import java.util.Scanner;
/**
* //命令解析程序
* 创建commandBySwitch类 要求：接收用户输入的命令command(int),并输出
*
* switch…case结构：多条路 只能对整数进行判断
* 优点：效率高、结构清晰
* 缺点：只能对整数判断相等
*
* break：
* 若case中有break：打印对应的case语句后，直接跳出switch
* 若case没有break：从对应命令的case开始往下贯穿打印每一句话
*
* default：可以写在switch中的任何地方；写不写都可以；
* 若写了:在case没有匹配参数时会按顺序执行(此时不执行case，因为都未匹配成功先执行default再贯穿剩余case)；
* :在case匹配了参数时不会执行default
* 若没写：会按顺序执行case匹配到的语句；若没有匹配的则全部执行
*/
public class CommandBySwitch {
public static void main(String[] args) {
// System.out.println("请选择功能：1.取款 2.存款 3.查询余额");//-----注意：要想打印这句话，需放在扫描数的上边。
// Scanner scanner = new Scanner(System.in);
// int command = scanner.nextInt();
// System.out.println("请选择功能：1.取款 2.存款 3.查询余额 4.退卡操作");
// int command = new Scanner(System.in).nextInt();
// switch (command) { //byte,short,int,char,String,枚举类型
// case 1:
// System.out.println("取款操作...");
// break;
// case 2:
// System.out.println("存款操作...");
// break;
// case 3:
// System.out.println("查询余额...");
// break;
// case 4:
// System.out.println("退卡操作...");
// break;
// default:
// System.out.println("操作错误...");
// }
int num = 5;
switch (num) {
case 3:
System.out.println("555");
case 6:
System.out.println("8888");
default://default：可以写在switch中的任何地方；写不写都可以；
// 若写了:在case没有匹配参数时会按顺序执行；
// :在case匹配了参数时不会执行default
//若没写:会按顺序执行case匹配到的语句；若没有匹配的则全部执行
System.out.println("11");
//break;//若有break，直接跳出switch；若没有break，则贯穿执行全部输出语句
case 0:
System.out.println("22");
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
4、 循环：反复多次执行一段相同或相似的代码
循环三要素：
循环变量的初始化
循环的条件(以循环变量为基础)
循环变量的改变(向着循环的结束变)
循环变量：在整个循环过程中所反复改变的那个数
//跑3圈:
循环变量:所跑圈数count
1)int count=0;
2)count<3
3)count++;
count=0/1/2/ 3时结束
圈数为0
够3圈吗？ 不够 跑一圈 圈数为1
够3圈吗？ 不够 跑一圈 圈数为2
够3圈吗？ 不够 跑一圈 圈数为3
够3圈吗？ 够了
//打印机打印6份简历:
循环变量:所打份数num
1)int num=0;
2)num<6
3)num++;
num=0/1/2/3/4/5/ 6时结束
份数为0
够6份吗？ 不够 打印一份 份数为1
够6份吗？ 不够 打印一份 份数为2
够6份吗？ 不够 打印一份 份数为3
够6份吗？ 不够 打印一份 份数为4
够6份吗？ 不够 打印一份 份数为5
够6份吗？ 不够 打印一份 份数为6
够6份吗？ 够了
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
5、循环结构：
while结构：先判断后执行，有可能一次都不执行
语法：
while(boolean){
语句块-------------反复执行的代码
}
执行过程：
判断boolean的值，若为true则执行语句块，
再判断boolean的值，若为true则再执行语句块，
再判断boolean的值，若为true则再执行语句块，
如此反复，直到boolean的值为false时，while循环结束
代码演示：
//1)输出5次"行动是成功的阶梯":
int times = 0; //1)循环变量的初始化
while(times<5){ //2)循环的条件
System.out.println("行动是成功的阶梯");//反复干的事必须放在第三要素之前
times++; //3)循环变量的改变
}
System.out.println("继续执行...");
/*
执行过程:----带数
times=0
true 输出 times=1
true 输出 times=2
true 输出 times=3
true 输出 times=4
true 输出 times=5
false while循环结束
输出继续执行...
*/
//2)输出9的乘法表:
int num = 1; //3*9=27
while(num<=9){
System.out.println(num+"*9="+num*9);
num++; //num+=2;
}
System.out.println("继续执行...");
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
6、猜数字小游戏代码：
package day04;
import java.util.Random;
import java.util.Scanner;
/** 猜数字小游戏 */
public class Guessing {
public static void main(String[] args) {
/*
int num = (int)(Math.random()*1000+1); //1到1000
Math.random()--------------0.0到0.9999999999999999...
*1000----------------------0.0到999.99999999999999...
+1-------------------------1.0到1000.9999999999999...
(int)----------------------1到1000
*/
Scanner scanner = new Scanner(System.in);
// int num = 250;//定死的数
int num = (int)(Math.random()*1000+1);//1~1000的随机数
System.out.println(num);//作弊 直接将生成的随机数显示在控制台
System.out.println("猜吧");
int guess = scanner.nextInt();
while(guess!=num){
if(guess>num){
System.out.println("猜大了！继续猜");
}else{
System.out.println("猜小了！继续猜");
}
guess = scanner.nextInt();
}
System.out.println("猜对了");
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
7、do…while结构：先执行后判断，至少执行一次
要素1与要素3相同时，首选do…while
语法：
do{
语句块
}while(boolean);
1
2
3
执行过程：
先执行语句块，再判断boolean的值，若为true则
再执行语句块，再判断boolean的值，若为true则
再执行语句块，再判断boolean的值，若为true则
再执行语句块，如此反复，直到boolean的值为false，则 do…while结束
猜数字小游戏代码：
public class Guessing {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int num = (int)(Math.random()*1000+1); //1到1000之内的随机数
System.out.println(num); //作弊
//假设num=250
//300(大),200(小),250(对)
int guess;
do{
System.out.println("猜吧!");
guess = scan.nextInt(); //1+3
if(guess>num){
System.out.println("太大了");
}else if(guess<num){
System.out.println("太小了");
}else{
System.out.println("恭喜你猜对了");
}
}while(guess!=num); //2
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
补充：
变量的作用域/范围：
从变量的声明开始，到包含它最近的大括号结束
生成随机数：
int num = (int)(Math.random()*1000+1); //1到1000
Math.random()--------------0.0到0.9999999999999999...
*1000----------------------0.0到999.99999999999999...
+1-------------------------1.0到1000.9999999999999...
(int)----------------------1到1000
1
2
3
4
5
6
任何复杂的程序逻辑都可以通过三种结构来实现：
顺序结构：从上往下逐行执行，每句必走
分支结构：有条件的执行某语句一次，并非每句必走
循环结构：有条件的执行某语句多次，并非每句必走
精华笔记：
Scanner接收用户输入的数据：共3步，不需要理解，先背下来
分支结构：
if…else if结构：多条路
switch…case结构：多条路
优点：效率高、结构清晰
缺点：只能对整数判断相等
break：跳出switch
常见面试题：switch可以作用于什么类型的数据上
-------------------------byte,short,int,char,String,枚举类型
循环：反复多次执行一段相同或相似的代码
循环三要素：
循环变量的初始化
循环的条件(以循环变量为基础)
循环变量的改变(向着循环的结束变)
循环变量：在整个循环过程中所反复改变的那个数
循环结构：
while结构：先判断后执行，有可能一次都不执行
do…while结构：先执行后判断，至少执行一次
要素1与要素3相同时，首选do…while
语言基础第四天作业：
1、ScoreLevel成绩等级判断
2、CommandBySwitch命令解析程序
3、Guessing猜数字之while版
4、Guessing猜数字之do…while版
1、ScoreLevel成绩等级判断。完整代码：
package day04;
import java.util.Scanner;
//成绩等级判断
public class ScoreLevel {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.println("请输入成绩:");
double score = scan.nextDouble();
//带数(888,-45,95,85,65,45)
if(score<0 || score>100){
System.out.println("成绩不合法");
}else if(score>=90){ //合法
System.out.println("A-优秀");
}else if(score>=80){
System.out.println("B-良好");
}else if(score>=60){
System.out.println("C-中等");
}else{
System.out.println("D-不及格");
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
2、CommandBySwitch命令解析程序。完整代码：
package day04;
import java.util.Scanner;
//命令解析程序
public class CommandBySwitch {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.println("请选择功能: 1.取款 2.存款 3.查询余额 0.退卡");
int command = scan.nextInt();
switch(command){
case 1:
System.out.println("取款操作...");
break;
case 2:
System.out.println("存款操作...");
break;
case 3:
System.out.println("查询余额操作...");
break;
case 0:
System.out.println("退出成功");
break;
default:
System.out.println("输入错误");
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
3、Guessing猜数字之while版。完整代码：
package day04;
import java.util.Random;
import java.util.Scanner;
/** 猜数字小游戏 */
public class Guessing {
public static void main(String[] args) {
/*
int num = (int)(Math.random()*1000+1); //1到1000
Math.random()--------------0.0到0.9999999999999999...
*1000----------------------0.0到999.99999999999999...
+1-------------------------1.0到1000.9999999999999...
(int)----------------------1到1000
*/
Scanner scanner = new Scanner(System.in);
// int num = 250;//定死的数
int num = (int)(Math.random()*1000+1);//1~1000的随机数
System.out.println(num);//作弊 直接将生成的随机数显示在控制台
System.out.println("猜吧");
int guess = scanner.nextInt();
while(guess!=num){
if(guess>num){
System.out.println("猜大了！继续猜");
}else{
System.out.println("猜小了！继续猜");
}
guess = scanner.nextInt();
}
System.out.println("猜对了");
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
4、Guessing猜数字之do…while版。。完整代码:
package day04;
import java.util.Scanner;
//猜数字小游戏
public class Guessing {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int num = (int)(Math.random()*1000+1); //1到1000之内
System.out.println(num); //作弊
//假设num=250
//300(大),200(小),250(对)
int guess;
do{
System.out.println("猜吧!");
guess = scan.nextInt(); //1+3
if(guess>num){
System.out.println("太大了");
}else if(guess<num){
System.out.println("太小了");
}else{
System.out.println("恭喜你猜对了");
}
}while(guess!=num); //2
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
语言基础第五天：
回顾：
Scanner接收用户的数据：共3步
分支结构：
if…else if结构：多条路
switch…case结构：多条路
优点：效率高、结构清晰
缺点：只能对整数判断相等
break：跳出switch
循环：反复多次执行一段相同或相似的代码
循环三要素：
循环变量的初始化
循环的条件(以循环变量为基础)
循环变量的改变(向着循环的结束变)
循环变量：在整个循环过程中所反复改变的那个数
循环结构：
while结构：先判断后执行，有可能一次都不执行
do…while结构：先执行后判断，至少执行一次
要素1与要素3相同时，首选do…while
笔记：
循环结构：
for结构：应用率高、与次数相关的循环
语法：
// 1 2 3
for(要素1;要素2;要素3){
语句块/循环体----------------反复执行的代码 4
}
执行过程：
1243243243243243243…2
代码演示：
//for循环中的循环变量i，作用域仅在当前for中
for(int i=1;i<=9;i++){
System.out.println(i+"*9="+i*9);
}
for(int i=1;i<=9;i+=2){
System.out.println(i+"*9="+i*9);
}
for(int i=9;i>=1;i--){
System.out.println(i+"*9="+i*9);
}
for(int times=0;times<5;times++){
System.out.println("行动是成功的阶梯");
}
System.out.println("继续执行...");
/*
执行过程:
times=0 true 输出
times=1 true 输出
times=2 true 输出
times=3 true 输出
times=4 true 输出
times=5 false for循环结束
输出继续执行...
*/
//for的特殊格式:----------了解
int i=1;
for(;i<=9;i++){ //可以把上边那句省略，此行变为： for(int i=1;i<=9;i++)
System.out.println(i+"*9="+i*9);
}
for(int i=1;i<=9;){
System.out.println(i+"*9="+i*9);
i++;
}
for(;;){ //没有条件的循环就是一个死循环
System.out.println("我要学习...");
}
for(int i=1,j=5;i<=5;i+=2,j-=2){
}
/*
i=1,j=5 true
i=3,j=3 true
i=5,j=1 true
i=7,j=-1 false
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
三种循环结构的选择规则：
先看循环是否与次数相关：
若相关----------------------------直接上for
若无关，再看要素1与要素3是否相同：
若相同------------------------直接上do…while
若不同------------------------直接上while
break：跳出循环
for(int i=1;i<=9;i++){
if(i==4){ //在某种特定条件下，提前结束循环
break;
}
System.out.println(i+"*9="+i*9);
}
/*
i=1 true 1*9=9
i=2 true 2*9=18
i=3 true 3*9=27
i=4 true
*/
1
2
3
4
5
6
7
8
9
10
11
12
continue：跳过循环体中剩余语句而进入下一次循环
//输出9的乘法表，只要不能被3整除的
for(int i=1;i<=9;i++){
if(i%3!=0){
System.out.println(i+"*9="+i*9);
}
}
//输出9的乘法表，跳过能被3整除的
for(int i=1;i<=9;i++){
if(i%3==0){
continue; //跳过循环体中剩余语句而进入下一次循环
}
System.out.println(i+"*9="+i*9);
}
/*
i=1 1*9=9
i=2 2*9=18
i=3
i=4 4*9=36
i=5 5*9=45
i=6
i=7 7*9=63
i=8 8*9=72
i=9
i=10
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
随机加法运算器案例：
package day05;
import java.util.Scanner;
//随机加法运算器
public class Addition {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int score = 0; //总分
for(int i=1;i<=10;i++) { //10次
int a = (int)(Math.random()*100); //加数a，0到99之间
int b = (int)(Math.random()*100); //加数b
int result = a+b; //存正确答案
System.out.println("("+i+")"+a+"+"+b+"=?"); //1)出题
System.out.println("算吧!----输入-1可提前结束");
int answer = scan.nextInt(); //2)答题
if(answer==-1){ //3)判题
break;
}
if(answer==result){
System.out.println("答对了");
score += 10; //答对1题，加10分
}else{
System.out.println("答错了");
}
}
System.out.println("总分为:"+score);
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
嵌套循环：
循环中套循环，常常多行多列时使用，一般外层控制行，内层控制列
执行过程：外层循环走一次，内层循环走所有次
建议：嵌套层数越少越好，能用一层就不用两层，能用两层就不用三层，若业务必须通过三层以上的循环才能解决，说明你的设计有问题
break只能跳出当前一层循环
for(int num=1;num<=9;num++){ //控制行
for(int i=1;i<=num;i++){ //控制列
System.out.print(i+"*"+num+"="+i*num+"\t");
}
System.out.println(); //换行
}
/*
执行过程:
num=3
i=1 1*3=3
i=2 2*3=6
i=3 3*3=9
i=4 false
换行
num=2
i=1 1*2=2
i=2 2*2=4
i=3 false
换行
num=1
i=1 1*1=1
i=2 false
换行
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
数组：
是一种数据类型(引用类型)
相同数据类型元素的集合
定义：
//声明int型数组arr，包含10个元素，每个元素都是int型，默认值为0
int[] arr = new int[10];
1
2
初始化：给数组中的元素做初始化
int[] arr = new int[3]; //0,0,0
int[] arr = {1,4,7}; //1,4,7
int[] arr = new int[]{1,4,7}; //1,4,7
int[] arr;
//arr = {1,4,7}; //编译错误
int[] arr2;
arr2 = new int[]{1,4,7}; //正确
1
2
3
4
5
6
7
访问：访问的是数组中的元素
通过(数组名.length)可以获取数组的长度(元素的个数)
int[] arr = new int[3];
System.out.println(arr.length); //3
1
2
通过下标/索引来访问数组中的元素
下标从0开始，最大到(数组的长度-1)
int[] arr = new int[3];
arr[0] = 100; //给第1个元素赋值为100
arr[1] = 200; //给第2个元素赋值为200
arr[2] = 300; //给第3个元素赋值为300
System.out.println(arr[arr.length-1]); //输出最后一个元素的值
1
2
3
4
5
6
遍历/迭代：从头到尾挨个走一遍
int[] arr = new int[10];
for(int i=0;i<arr.length;i++){ //遍历arr数组
//arr[i]代表arr中的每一个元素
//给每个元素赋值为0到99之间的随机数
arr[i] = (int)(Math.random()*100);
System.out.println(arr[i]); //输出每个元素的值
}
1
2
3
4
5
6
7
8
精华笔记：
循环结构：
for结构：应用率高、与次数相关的循环
三种循环结构的选择规则：
先看循环是否与次数相关：
若相关----------------------------直接上for
若无关，再看要素1与要素3是否相同：
若相同------------------------直接上do…while
若不同------------------------直接上while
break：跳出循环
continue：跳过循环体中剩余语句而进入下一次循环
嵌套循环：
循环中套循环，常常多行多列时使用，一般外层控制行，内层控制列
执行过程：外层循环走一次，内层循环走所有次
建议：嵌套层数越少越好，能用一层就不用两层，能用两层就不用三层，若业务必须通过三层以上的循环才能解决，说明你的设计有问题
break只能跳出当前一层循环
数组：
是一种数据类型(引用类型)
相同数据类型元素的集合
定义：
初始化：给数组中的元素做初始化
访问：访问的是数组中的元素
通过(数组名.length)可以获取数组的长度(元素的个数)
通过下标/索引来访问数组中的元素
下标从0开始，最大到(数组的长度-1)
遍历/迭代：从头到尾挨个走一遍
补充：
变量的同名问题：
作用域重叠时，变量不能同名的
\t：水平制表位，固定占8位
ArrayIndexOutOfBoundsException数组下标越界异常
数组下标范围为0到(数组长度-1)，超出范围则发生如上的异常
语言基础第五天作业：
1、Addition随机加法运算器
2、MultiTable九九乘法表
3、数组小代码：声明、初始化、访问、遍历
1、Addition随机加法运算器。完整代码：
package day05;
import java.util.Scanner;
//随机加法运算器
public class Addition {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int score = 0; //得分
for(int i=1;i<=10;i++){ //10次 (1)25+36=?
int a = (int)(Math.random()*100); //加数a(0到99的随机数)
int b = (int)(Math.random()*100); //加数b(0到99的随机数)
int result = a+b; //存正确答案
System.out.println("("+i+")"+a+"+"+b+"=?"); //1)出题
System.out.println("算吧!");
int answer = scan.nextInt(); //2)答题
if(answer==-1){ //3)判题
break;
}
if(answer==result){
System.out.println("答对了");
score+=10; //答对1题加10分
}else{
System.out.println("答错了");
}
}
System.out.println("总分为:"+score);
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
2、MultiType九九乘法表。完整代码：
package day05;
//九九乘法表
public class MultiTable {
public static void main(String[] args) {
for(int num=1;num<=9;num++){ //控制行
for(int i=1;i<=num;i++){ //控制列
System.out.print(i+"*"+num+"="+i*num+"\t");
}
System.out.println(); //换行
}
/*
int num = 9;//----1/2/3/4/5/6/7/8/9
for (int i=1;i<=num;i++) {
System.out.print(i+"*"+num+"="+i*num+"\t");
}
执行过程：
num=1: 1*1=1
num=2: 1*2=2 2*2=4
num=3: 1*3=3 2*3=6 3*3=9
num=4: 1*4=4 2*4=8 3*4=12 4*4=16
num=5: 1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
.
.
.
num=9: 1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
*/
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
3、数组小代码练习：声明、初始化、访问、遍历。 完整代码：
package day05;
//数组的演示
public class ArrayDemo {
public static void main(String[] args) {
/*
//1)数组的定义:
//声明整型数组arr，包含10个元素，每个元素都是int型，默认值为0
int[] arr = new int[10];
//2)数组的初始化:--初始化的是数组中的数据
int[] arr1 = new int[3]; //0,0,0
int[] arr2 = {2,5,8}; //2,5,8
int[] arr3 = new int[]{2,5,8}; //2,5,8
int[] arr4;
//arr4 = {2,5,8}; //编译错误，此方式只能声明同时初始化
arr4 = new int[]{2,5,8}; //正确
*/
/*
//3)数组的访问:--访问的是数组中的数据
int[] arr = new int[3];
System.out.println(arr.length); //3，输出arr的长度
arr[0] = 100; //给arr中第1个元素赋值为100
arr[1] = 200; //给arr中第2个元素赋值为200
arr[2] = 300; //给arr中第3个元素赋值为300
//arr[3] = 400; //运行时发生ArrayIndexOutOfBoundsException数组下标越界异常
System.out.println(arr[arr.length-1]); //输出最后一个元素的值
*/
//4)数组的遍历:
int[] arr = new int[10];
for(int i=0;i<arr.length;i++){ //遍历arr数组
arr[i] = (int)(Math.random()*100); //给每个元素赋值为0到99的随机数
System.out.println(arr[i]); //输出每个元素的值
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
***常见面试题：
面试题1、2、3：
//面试题1：
System.out.println("is"+20+3);//is 203 从左往右碰到字符串参与 后面都为字符模式
System.out.println(20+3+" is");//23 is 从左往右先算加法23
System.out.println("is "+(20+3));//is 23 从左往右，但是先算括号里边的
//面试题2：
int result = 0;
int i = 2;
switch(i){
case 1:
result = result+i;
case 2:
result = result+i*2;
case 3:
result = result+i*3;
}
System.out.println(result);//10
//面试题3：
①do...while先执行再判断
int a=0,b=0;
do{
--b; //b-1=0-1=-1
a--; //a-1=0-1=-1
}while(a>0);
System.out.println(b);//-1
②先判断再执行...
int a=0,b=0;
while(a>0){
--b;
a--;
}
System.out.println(b);
面试题3:
int a=0,b=0;
do{
a--; //a-1=0-1=-1
--b; //b-1=0-1=-1
}while(a>0);
System.out.println(a);//-1 a--;表达式： a先输出(输出本身的值0)，再自减1(0-1等于-1)，最后输出为-1
System.out.println(b);//-1 --b;表达式： b先自减1(本身为0,0-1等于-1)，再输出为-1
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
