第02章:随堂复习与企业真题(变量与运算符)
一、随堂复习
1.1 关键字、保留字
关键字:被Java赋予特殊含义的字符串。
- 官方规范中有50个关键字
- true、false、null虽然不是关键字,但是可以当做关键字来看待。
保留字:goto 、 const
1.2 标识符
- 标识符:凡是可以自己命名的地方,都是标识符。
- 比如:类名、变量名、方法名、接口名、包名、常量名等
- 记住:标识符命名的规则(必须要遵守的,否则编译不通过)
1 2 3 4 5
| > 由26个英文字母大小写,0-9 ,_或 $ 组成 > 数字不可以开头。 > 不可以使用关键字和保留字,但能包含关键字和保留字。 > Java中严格区分大小写,长度无限制。 > 标识符不能包含空格。
|
- 记住:标识符命名的规范(建议遵守。如果不遵守,编译和运行都能正常执行。只是容易被人鄙视)
1 2 3 4 5 6 7 8 9 10 11
| > 包名:多单词组成时所有字母都小写:xxxyyyzzz。 例如:java.lang、com.atguigu.bean > 类名、接口名:多单词组成时,所有单词的首字母大写:XxxYyyZzz 例如:HelloWorld,String,System等 > 变量名、方法名:多单词组成时,第一个单词首字母小写,第二个单词开始每个单词首字母大写:xxxYyyZzz 例如:age,name,bookName,main,binarySearch,getName > 常量名:所有字母都大写。多单词时每个单词用下划线连接:XXX_YYY_ZZZ 例如:MAX_VALUE,PI,DEFAULT_CAPACITY
|
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
| class IdentifierTest{ public static void main(String[] args){ int abc = 12; int age = 12;
char gender = '男';
char c1 = '女';
int myAge = 12; }
public static void main1(String[] args){ } }
class _a$bc{ }
class Public{ }
class publicstatic{ }
class BiaoShiFuTest{ }
|
1.3 变量的基本使用(重点)
- 变量的理解:内存中的一个存储区域,该区域的数据可以在同一类型范围内不断变化
- 变量的构成包含三个要素:数据类型、变量名、存储的值
- Java中变量声明的格式:数据类型 变量名 = 变量值
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
| class VariableTest { public static void main(String[] args) { char gender; gender = '男';
gender = '女'; int age = 10;
System.out.println(age); System.out.println("age = " + age); System.out.println("gender = " + gender);
gender = '男';
byte b1 = 127;
}
public static void main123(String[] args) {
char gender = '女'; } }
|
说明:
- 定义变量时,变量名要遵循标识符命名的规则和规范。
- 说明:
① 变量都有其作用域。变量只在作用域内是有效的,出了作用域就失效了。
② 在同一个作用域内,不能声明两个同名的变量
③ 定义好变量以后,就可以通过变量名的方式对变量进行调用和运算。
④ 变量值在赋值时,必须满足变量的数据类型,并且在数据类型有效的范围内变化。
1.4 基本数据类型变量的使用(重点)
1、Java中的变量按照数据类型来分类:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
| 基本数据类型(8种): 整型:byte \ short \ int \ long 浮点型:float \ double 字符型:char 布尔型:boolean
引用数据类型: 类(class) 数组(array) 接口(interface)
枚举(enum) 注解(annotation) 记录(record)
|
测试整型和浮点型:
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
|
class VariableTest1 { public static void main(String[] args) {
byte b1 = 12; byte b2 = 127;
short s1 = 1234;
int i1 = 123234123; long l1 = 123123123L;
double d1 = 12.3; float f1 = 12.3f; System.out.println("f1 = " + f1);
System.out.println(0.1 + 0.2);
float ff1 = 123123123f; float ff2 = ff1 + 1; System.out.println(ff1); System.out.println(ff2); System.out.println(ff1 == ff2); } }
|
测试字符型和布尔型:
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
|
class VariableTest2 { public static void main(String[] args) {
char c1 = 'a'; char c2 = '中'; char c3 = '1'; char c4 = '%'; char c5 = 'γ';
char c8 = '\u0036'; System.out.println(c8);
char c9 = '\n'; char c10 = '\t'; System.out.println("hello" + c10 + "world");
char c11 = 97; System.out.println(c11);
char c12 = '1'; char c13 = 1;
boolean bo1 = true; boolean bo2 = false; boolean isMarried = true; if(isMarried){ System.out.println("很遗憾,不能参加单身派对了"); }else{ System.out.println("可以多谈几个女朋友或男朋友"); } } }
|
1.5 基本数据类型变量间的运算规则(重点)
1.5.1 自动类型提升
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
|
class VariableTest3 { public static void main(String[] args) { int i1 = 10; int i2 = i1;
long l1 = i1;
float f1 = l1;
byte b1 = 12; int i3 = b1 + i1;
byte b3 = 12; short s1 = 10; i3 = b3 + s1;
byte b4 = 10;
char c1 = 'a'; int i4 = c1 + b3;
long l2 = 123L; long l3 = 123;
long l5 = 123123123123L; float f2 = 12.3F;
byte b5 = 10; int ii1 = b5 + 1; double dd1 = b5 + 12.3;
} }
|
1.5.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 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
|
class VariableTest4 { public static void main(String[] args) { double d1 = 12;
int i2 = (int)d1; System.out.println(i2);
long l1 = 123; short s2 = (short)l1; System.out.println(s2);
int i3 = 12; float f1 = i3; System.out.println(f1);
float f2 = (float)i3; double d2 = 12.9; int i4 = (int)d2; System.out.println(i4);
int i5 = 128; byte b1 = (byte)i5; System.out.println(b1);
byte b2 = 12; method(b2);
long l2 = 12L; method((int)l2); }
public static void method(int num){ System.out.println("num = " + num); } }
|
1.6 String类的使用、与基本数据类型变量间的运算(重点)
- String的认识:字符串。使用一对””表示,内部包含0个、1个或多个字符。
- String与8种基本数据类型变量间的运算:+。运算的结果是String类型。
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
|
class StringTest { public static void main(String[] args) { String str1 = "Hello World!"; System.out.println("str1"); System.out.println(str1);
String str2 = ""; String str3 = "a";
int num1 = 10; boolean b1 = true; String str4 = "hello";
System.out.println(str4 + b1);
String str5 = str4 + b1; String str6 = str4 + b1 + num1; System.out.println(str6);
String str8 = "abc";
int num2 = 10; String str9 = num2 + "";
int num3 = Integer.parseInt(str9); System.out.println(num3 + 1); } }
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
|
class StringExer { public static void main(String[] args) { String name = "李进"; int age = 24; char gender = '男'; double weight = 130.5; boolean isMarried = false; String phoneNumber = "13012341234";
String info = "name = " + name + ",age = " + age + ",gender = " + gender + ",weight = " + weight + ",isMarried = " + isMarried + ",phoneNumber = " + phoneNumber;
System.out.println(info); } }
|
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
| class StringExer1 { public static void main(String[] args) { String str2 = 3.5f + ""; System.out.println(str2); System.out .println(3+4+"Hello!"); System.out.println("Hello!"+3+4); System.out.println('a'+1+"Hello!"); System.out.println("Hello"+'a'+1);
System.out.println("* *"); System.out.println("*\t*"); System.out.println("*" + "\t" + "*"); System.out.println('*' + "\t" + "*"); System.out.println('*' + '\t' + "*"); System.out.println('*' + "\t" + '*'); System.out.println("*" + '\t' + '*'); System.out.println('*' + '\t' + '*');
} }
|
1.7 常识:进制的认识
- 熟悉:二进制(以0B、0b开头)、十进制、八进制(以0开头)、十六进制(以0x或0X开头)的声明方式。
- 二进制的理解
- 正数:原码、反码、补码三码合一。
- 负数:原码、反码、补码不相同。了解三者之间的关系。
- 计算机的底层是以
补码
的方式存储数据的。
- 熟悉:二进制与十进制之间的转换
- 了解:二进制与八进制、十六进制间的转换
1.8 运算符(较常用的是重点)
1.8.1 算术运算符
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
|
class AriTest { public static void main(String[] args) { int m1 = 12; int n1 = 5; int k1 = m1 / n1; System.out.println(k1);
System.out.println(m1 / n1 * n1); int i1 = 12; int j1 = 5; System.out.println(i1 % j1);
int i2 = -12; int j2 = 5; System.out.println(i2 % j2);
int i3 = 12; int j3 = -5; System.out.println(i3 % j3);
int i4 = -12; int j4 = -5; System.out.println(i4 % j4);
int a1 = 10; int b1 = ++a1; System.out.println("a1 = " + a1 + ",b1 = " + b1);
int a2 = 10; int b2 = a2++; System.out.println("a2 = " + a2 + ",b2 = " + b2);
int i = 10; ++i; System.out.println("i = " + i);
short s1 = 10;
s1++; System.out.println(s1);
} }
|
练习1:
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
|
class AriExer { public static void main(String[] args) { int num = 153; int ge = num % 10; int shi = num / 10 % 10; int bai = num / 100;
System.out.println("个位是:" + ge); System.out.println("十位是:" + shi); System.out.println("百位是:" + bai);
} }
|
练习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 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47
|
class AriExer1 { public static void main(String[] args) {
int hours = 89;
int day = hours / 24; int hour = hours % 24;
System.out.println("共奋战了" + day + "天零" + hour + "小时");
System.out.println("5+5=" + 5 + 5); System.out.println("5+5=" + (5 + 5));
byte bb1 = 127; bb1++; System.out.println("bb1 = " + bb1);
int i = 2; int j = i++; System.out.println(j);
int k = 2; int z = ++k; System.out.println(z);
int m = 2; m = m++; System.out.println(m);
} }
|
1.8.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 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
|
class SetValueTest { public static void main(String[] args) {
int i = 5;
long l = 10;
byte b = (byte)i;
int a1 = 10; int b1 = 10;
int a2; int b2; a2 = b2 = 10;
System.out.println(a2 + "," + b2);
int a3 = 10,b3 = 20; System.out.println(a3 + "," + b3);
int m1 = 10; m1 += 5; System.out.println(m1);
byte by1 = 10; by1 += 5; System.out.println(by1);
int m2 = 1; m2 *= 0.1; System.out.println(m2);
int n1 = 10; n1 = n1 + 2;
int n2 = 10; n2 += 2;
int i1 = 10; i1 = i1 + 1;
int i2 = 10; i2 += 1;
int i3 = 10; i3++;
} }
|
1.8.3 比较运算符
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
|
class CompareTest { public static void main(String[] args) { int m1 = 10; int m2 = 20; boolean compare1 = m1 > m2; System.out.println(compare1);
int n1 = 10; int n2 = 20; System.out.println(n1 == n2); System.out.println(n1 = n2);
boolean b1 = false; boolean b2 = true; System.out.println(b1 == b2); System.out.println(b1 = b2);
} }
|
1.8.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 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
|
class LogicTest { public static void main(String[] args) {
boolean b1 = true; b1 = false;
int num1 = 10;
if(b1 & (num1++ > 0)){ System.out.println("床前明月光"); }else{ System.out.println("我叫郭德纲"); } System.out.println("num1 = " + num1);
boolean b2 = true; b2 = false;
int num2 = 10;
if(b2 && (num2++ > 0)){ System.out.println("床前明月光"); }else{ System.out.println("我叫郭德纲"); } System.out.println("num2 = " + num2);
boolean b3 = false; b3 = true;
int num3 = 10;
if(b3 | (num3++ > 0)){ System.out.println("床前明月光"); }else{ System.out.println("我叫郭德纲"); } System.out.println("num3 = " + num3);
boolean b4 = false; b4 = true;
int num4 = 10;
if(b4 || (num4++ > 0)){ System.out.println("床前明月光"); }else{ System.out.println("我叫郭德纲"); } System.out.println("num4 = " + num4); } }
|
练习:
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
|
class LogicExer { public static void main(String[] args) { int a,b; a = b = 20; boolean bo1 = (++a % 3 == 0) && (a++ % 7 == 0);
System.out.println("a = " + a + ",bo1 = " + bo1);
boolean bo2 = (b++ % 3 == 0) && (++b % 7 == 0); System.out.println("b = " + b + ",bo2 = " + bo2);
} }
|
1.8.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
|
class BitTest { public static void main(String[] args) { int num1 = 7; System.out.println("num1 << 1 : " + (num1 << 1)); System.out.println("num1 << 2 : " + (num1 << 2)); System.out.println("num1 << 3 : " + (num1 << 3)); System.out.println("num1 << 28 : " + (num1 << 28)); System.out.println("num1 << 29 : " + (num1 << 29));
int num2 = -7; System.out.println("num2 << 1 : " + (num2 << 1)); System.out.println("num2 << 2 : " + (num2 << 2)); System.out.println("num2 << 3 : " + (num2 << 3));
System.out.println(~9); System.out.println(~-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 28 29 30 31 32 33 34 35
|
class BitExer { public static void main(String[] args) { int m = 10; int n = 20;
System.out.println("m = " + m + ",n = " + n);
m = m ^ n; n = m ^ n; m = m ^ n;
System.out.println("m = " + m + ",n = " + n);
} }
|
1.8.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 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47
|
class ConditionTest { public static void main(String[] args) { String info = (2 > 10)? "表达式1" : "表达式2"; System.out.println(info);
double result = (2 > 1)? 1 : 2.0; System.out.println(result);
int m = 10; int n = 20;
int max = (m > n)? m : n; System.out.println("较大值为:" + max);
int i = 20; int j = 30; int k = 23;
int tempMax = (i > j)? i : j; int finalMax = (tempMax > k)? tempMax : k; System.out.println(finalMax);
int finalMax1 = (((i > j)? i : j) > k)? ((i > j)? i : j) : k; System.out.println(finalMax1); } }
|
1.8.7 运算符的优先级
- 如果想体现优先级比较高,使用()
- 我们在编写一行执行语句时,不要出现太多的运算符。
二、企业真题
1. 高效的方式计算2 * 8的值 (文**辉、轮*科技)
使用 <<
2. &和&&的区别?(恒*电子、*度)
略
3. Java中的基本类型有哪些?String 是最基本的数据类型吗?(恒*电子)
8种基本数据类型。(略)
String不是,属于引用数据类型。
4. Java中的基本数据类型包括哪些?(*米)
1 2
| 类似问题: > Java的基础数据类型有哪些?String是吗?(贝壳)
|
略
5. Java开发中计算金额时使用什么数据类型?(5*到家)
不能使用float或double,因为精度不高。
使用BigDecimal类替换,可以实现任意精度的数据的运算。
6. char型变量中能不能存储一个中文汉字,为什么?(*通快递)
可以的。char c1 = ‘中’;
char c2 = ‘a’。
因为char使用的是unicode字符集,包含了世界范围的所有的字符。
7. 代码分析(君*科技、新*陆)
8. int i=0; i=i++执行这两句化后变量 i 的值为(*软)
0。
9. 如何将两个变量的值互换(北京*彩、中外*译咨询)
1 2 3 4 5 6
| String s1 = "abc"; String s2 = "123";
String temp = s1; s1 = s2; s2 = temp;
|
10. boolean 占几个字节(阿**巴)
1 2 3 4 5 6 7
| 编译时不谈占几个字节。
但是JVM在给boolean类型分配内存空间时,boolean类型的变量占据一个槽位(slot,等于4个字节)。 细节:true:1 false:0
>拓展:在内存中,byte\short\char\boolean\int\float : 占用1个slot double\long :占用2个slot
|
11. 为什么Java中0.1 + 0.2结果不是0.3?(字*跳动)
在代码中测试0.1 + 0.2,你会惊讶的发现,结果不是0.3,而是0.3000……4。这是为什么?
几乎所有现代的编程语言都会遇到上述问题,包括 JavaScript、Ruby、Python、Swift 和 Go 等。引发这个问题的原因是,它们都采用了IEEE 754标准
。
IEEE是指“电气与电子工程师协会”,其在1985年发布了一个IEEE 754计算标准,根据这个标准,小数的二进制表达能够有最大的精度上限提升。但无论如何,物理边界是突破不了的,它仍然不能实现“每一个十进制小数,都对应一个二进制小数”
。正因如此,产生了0.1 + 0.2不等于0.3的问题。
具体的:
整数变为二进制,能够做到“每个十进制整数都有对应的二进制数”,比如数字3,二进制就是11;再比如,数字43就是二进制101011,这个毫无争议。
对于小数,并不能做到“每个小数都有对应的二进制数字”。举例来说,二进制小数0.0001表示十进制数0.0625 (至于它是如何计算的,不用深究);二进制小数0.0010表示十进制数0.125;二进制小数0.0011表示十进制数0.1875。看,对于四位的二进制小数,二进制小数虽然是连贯的,但是十进制小数却不是连贯的。比如,你无法用四位二进制小数的形式表示0.125 ~ 0.1875之间的十进制小数。
所以在编程中,遇见小数判断相等情况,比如开发银行、交易等系统,可以采用四舍五入
或者“同乘同除
”等方式进行验证,避免上述问题。