第二章 Java基础语法
1、关键字
被Java语言赋予特定含义的单词,组成关键字的字母全部小写,goto和const作为保留字存在,目前并不使用。
(1)用于定义数据类型的关键字:class interface byte short int long float double char boolean void
(2)用于定义数据类型值的关键字:true false null
(3)用于定义流程控制的关键字:if else switch case default while do for break continue return
(4)用于定义访问权限修饰符的关键字 :private protected public
(5)用于定义类,函数,变量修饰符的关键字 :abstract final static synchronized
(6)用于定义类与类之间关系的关键字 : extends implements
(7)用于定义建立实例及引用实例,判断实例的关键字 :new this super instanceof
(8)用于异常处理的关键字 : try catch finally throw throws
(9)用于包的关键字 : package import
(10)其他修饰符关键字 : native strictfp transient volatile assert
2、标识符
就是给类,接口,方法,变量等起名字时使用的字符序列。
(1)英文大小写字母 (2)数字字符 (3)$和_
注意事项:A.不能以数字开头
B.不能有除$和_以外的特殊字符出现
C.不能是Java关键字
D.区分大小写
常见命名规则(Java开发规范):
A.包
单级文件夹(所有字母全部小写) 如:shujia
多级文件夹(所有字母全部小写,文件夹之间用.分开) 如:com.shujia.zzb
B.类或者接口
一个单词组成(首字母大写其余字母小写) 如:Hello
多个单词组成(所有单词的首字母大写,其余字母小写)如:HelloWorld
C.方法和变量
一个单词组成(所有字母小写) 如:eat
多个单词组成(第一个单词全部小写,从第二个单词开始,首字母大写,其余字母小写)
如:playGame
D.常量
一个单词组成(所有字母全部大写) 如:NAME
多个的那次组成(所有字母全部大写,单词与的单词之间用_连接) 如:FIRST_NAME
3、注释
(1)单行注释 //...
(2)多行注释 /*...*/
(3)文档注释 /**...*/
4、进制
(1)二进制 由0,1组成。以0b开头
(2)八进制 由0,1,…7组成。以0开头
(3)十进制 由0,1,…9组成。整数默认是十进制的
(4)十六进制 由0,1,…9,a,b,c,d,e,f(大小写均可)。以0x开头
(5)各进制直接相互转换
A.二进制、八进制、十六进制转十进制:略
B.二进制转八进制:由低位向高位三位一组,不够补0
eg:二进制: 001 001 100 1*2^6+1*2^3+1*2^2=64+8+4=76
八进制: 1 1 4 1*8^2+1*8^1+4*8^0=64+8+4=76
C.八进制转二进制同理
D.二进制转十六进制:由低位向高位四位一组,不够补0
eg:二进制: 0100 1100 1*2^6+1*2^3+1*2^2=64+8+4=76
十六进制: 4 c 4*16^1+12*16^0=64+12=76
E.十六进制转二进制同理
F.十进制转其他进制:除基取余,直到商为0,余数反转
eg: a.转二进制:76/2=38......0 | 低位
38/2=19......0 |
19/2=9........1 |
9/2=4.........1 |
4/2=2.........0 |
2/2=1.........0 |
1/2=0.........1 \/ 高位
=>二进制 1001100
b.转八进制:76/8=9.....4 | 低位
9/8=1.......1 |
1/8=0.......1 \/ 高位
=>八进制 114
c.转十六进制:76/16=4......12 | 低位
4/16=0........4 \/ 高位
=>十六进制: 4c
5、原码,反码,补码
“0”表示正,“1”表示负,其余位表示数值的大小。 计算机内部数据参与运算的时候都是采用补码进行运算的。
(1)原码:正数的原码就是二进制,最高位是0;负数的原码是二进制的最高位是1。
(2)反码:正数的反码与原码一致,负数的反码符号位不变,数值位按位取反,1变成0,0变成1。
(3)补码:正数补码与原码一致,负数的补码是反码末位+1。
6、数据类型
(1)基本数据类型
byte 1字节 -2^7~2^7-1
short 2字节 -2^15~2^15-1
int 4字节 -2^31~2^31-1
long 8字节 -2^63~2^63-1
float 4字节 -3.403*10^38~3.403*10^38
double 8字节 -1.798*10^308~1.798*10^308
char 2字节
boolean 1字节
(2)引用数据类型
类class 接口interface 数组[ ]
注意事项:A.整数默认是int类型
B.如果要定义一个long类型的数据,末尾要加上L或者l,推荐L
C.小数默认是double类型
D.如果要定义一个float类型的数据,末尾要加上F或者f,推荐F
(3)定义变量注意事项:
A.作用域:变量在同一个大括号内有效,出了大括号外无效。
B.相同的作用域中不能定义两个同名变量。
C.没有初始化值不能直接使用,在使用之前赋值即可。
(4)boolean类型的变量不能转换或赋值给其他数据类型。
(5)默认转换:byte,short,char—>int—>long—>float—>double
byte,short,char相互之间不转换,他们参与运算首先转换为int类型。
(6)强制转换:目标类型 变量名=(目标类型)(被转换的数据)
不建议大量使用强制类型转换,因为可能会损失精度。
(7)面试题
byte b1=3,b2=4,b;
b=b1+b2; (×)
b=3+4; (√)
哪句是编译失败的呢?为什么呢?
答:变量相加和常量相加不一样:
A.变量相加首先会提升数据类型,然后再相加赋值,如果接收的数据类型范围小于计算结果后的数据类型范围,报错,不能赋值
B.常量相加,会先进行计算,计算完后看看在不在接收的数据类型范围内,如果在,直接赋值,如果不在,报错。
(8)思考题
byte b = 130;
有没有问题?如果我想让赋值正确,可以怎么做?结果是多少呢?
解:我们知道数据在计算机种运算的时候是采用补码的形式参数运算的,
所以要知道130的补码 而想要知道补码,就得知道反码,原码,所以得求出130的二进制的表示:
130的二进制:10000010
由于整数默认是int类型,所以扩大字节
130的原码为:00000000 00000000 00000000 10000010
又由于最高位是0,所以它的原码,反码,补码都一样
130的补码:00000000 00000000 00000000 10000010
做截取操作:10000010 这是补码
已知补码,求原码: 符号位 数值位
补码: 1 0000010
反码: 1 0000001
原码: 1 1111110
最终结果为:11111110
将它换算成十进制就是我们看到的结果:-126
7、运算符
(1)算术运算符:+ ,- ,* ,/ ,% ,++ ,--
A.+ 的用法
a.当加号两边都是数字或者是数字和字符的时候,这时候的+号做的是加法运算 。
b.当加号两边其中是字符串的时候,做的是字符串拼接,拼接后是一个新的字符串。
c.字符串与任何数值做加法,做的是字符串拼接,拼接后是一个新的字符串。
eg:System.out.println("hello"+'a'+1); // helloa1
System.out.println('a'+1+"hello"); // 98hello
System.out.println("5+5="+5+5); // 5+5=55
System.out.println(5+5+"=5+5"); // 10=5+5
B./ 的注意事项
整数相除,只能得到整数 ,要想得到小数,可以*1.0。
C. % 的注意事项
%的左右两边被除数和除数必须是整数类型。
D.++和--的应用
a.++:自加1
当++在前的时候,先自加1,再做赋值操作,当++在后的时候,先做赋值操作,再做自加1
b.--:自减1
当--在前的时候,先自减1,再做赋值操作,当--在后的时候,先做赋值操作,再做自减1
eg:int m = 10;
int n = m++;
System.out.println(m); //11
System.out.println(n); //10
int m1 = 10;
int n1 = ++m1;
System.out.println(m1); //11
System.out.println(n1); //11
int a = 10;
int b = a--;
System.out.println(a); //9
System.out.println(b); //10
int a1 = 10;
int b1 = --a1;
System.out.println(a1); //9
System.out.println(b1); //9
(2)赋值运算符:= ,+= ,-= ,*= ,/= ,%=
A.=为基本的赋值运算符,其他的为扩展的赋值运算符
eg:a += 20; //这里实际上可以看作为a的值加上了一个20再赋值给a,但是不能完全等于 a = a + 20;其余同理
B.面试题
short s=1, s = s+1; (×)
short s=1, s+=1; (√)
上面两个代码有没有问题,如果有,那里有问题
答:第一个有问题,因为变量参与运算,首先会提升数据类型,然后做运算。所以 s = s+1;s会提升到int类型然后再做加法运算,最终的 结果是int类型,所以拿short类型接收会报错,所以要想成功赋值,就得强制类型转换。
第二个代码没有问题,是因为内部自动包含了强制类型转换,s+=1 => s = (s的数据类型)(s+1)。
(3)关系运算符:== , > , < , >= ,
注意事项:A.关系运算符的表达式的结果是一个boolean类型,要么是true,要么是false。
B.==不能少写,一个=是赋值运算符,==才是关系运算符。
C.赋值的时候要注意类型问题,关系运算符表达式的结果是boolean类型,所以接收的时候只能是boolean类型的变量接收。
(4)逻辑运算符:& , | , ^ , ! , && , ||
A.&(与): 参与运算的时候,两边有false,则false,两边都做运算。
B.|(或): 参与运算的时候,两边有true,则true,两边都做运算。
C.^(异或): 参与运算的时候,相同为false,不同为true,两边都做运算。
D.!(非): 将true变成false,false变成true。
E.&&(短路与): 有false则false,当&&左边的表达式结果为false的时候,右边不执行,结果是false。
F.||(短路或):有true则true, 当||左边是true的时候,右边不执行,结果是true.。
G.注:逻辑运算符用于连接布尔型表达式,逻辑运算符的两边放的是boolean类型的值,计算的结果也是一个boolean类型的值。
(5)位运算符:& ,| ,^ ,~ ,> , >>>
A.&(与运算):任何二进制位和0进行&运算,结果是0; 和1进行&运算结果是原值。
B.|(或运算):任何二进制位和0进行 | 运算,结果是原值; 和1进行 | 运算结果是1。
C.^(异或运算):任何相同二进制位进行 ^ 运算,结果是0; 不相同二进制位 ^ 运算结果是1。
D.~(反码):1变成0,0变成1。
E.
F.>>(右移):二进制右移,最左边最高位是0用0补齐,最高位是1就用1补齐,多出来的丢弃。
G.>>>(无符号右移):二进制右移,被移位二进制最高位无论是0或者是1,空缺位都用0补。
eg:byte a = 3;
byte b = 4;
System.out.println(a&b); //0
System.out.println(a|b);//7
System.out.println(a^b);//7
System.out.println(~a); //-4
由于数据在计算机中参与运算的都是补码,而想要知道补码,就得知道反码,原码,就得求出二进制
3的二进制:00000011
4的二进制:00000100
又由于3和4都是正数
3的补码:00000011
4的补码:00000100
a.& 运算:有0则0
00000011
&
00000100
---------------
00000000
结果是 : 0
====================================
b.| 运算:有1则1
00000011
|
00000100
--------------
00000111
结果是:7
====================================
c.^ 运算:相同则0,不同则1
00000011
^
00000100
--------------
00000111
结果是:7
====================================
d.~ 运算:1变成0,0变成1
00000011
~
-------------
补码: 11111100
已知补码求原码:
反码: 11111011
原码: 10000100
结果是:-4
eg: System.out.println(3
System.out.println(24>>2); //6 = 24/(2*2)
System.out.println(-24>>2);// -6
System.out.println(-24>>>2);//1073741818
a.
3的二进制:00000000 00000000 00000000 00000011
由于3是正数,所以原码,反码,补码都一样
3的补码: 00000000 00000000 00000000 00000011
左移: 00000000 00000000 00000000 00000011
(00)00000000 00000000 00000000 00001100 (补码)
由于最高位是0,既是补码也是原码,所以结果是:12 ================================================================
b.>>: 右移,最左边最高位是0用0补齐,最高位是1就用1补齐,多出来的丢弃。
24的二进制:00000000 00000000 00000000 00011000
由于24是正数,所以原码,反码,补码都一样
24的补码:00000000 00000000 00000000 00011000
右移: 00000000 00000000 00000000 00011000
00000000 00000000 00000000 00000110(00) (补码)
由于最高位是0,既是补码也是原码,所以结果是 :6
================================================================
c.>>: 右移,最左边最高位是0用0补齐,最高位是1就用1补齐,多出来的丢弃。
-24的二进制:10000000 00000000 00000000 00011000
已知原码求补码: 原码:10000000 00000000 00000000 00011000
反码:11111111 11111111 11111111 11100111
补码:11111111 11111111 11111111 11101000
右移:11111111 11111111 11111111 11111010(00) (补码)
已知补码求原码:
补码:11111111 11111111 11111111 11111010
反码:11111111 11111111 11111111 11111001
原码:10000000 00000000 00000000 00000110
最终结果是:-6
==============================================================
d.>>>: 无符号右移,无论左边最高是0还是1,都用0补齐,多出来的丢弃。
-24的二进制:10000000 00000000 00000000 00011000
已知原码求补码: 原码:10000000 00000000 00000000 00011000
反码:11111111 11111111 11111111 11100111
补码:11111111 11111111 11111111 11101000
无符号右移2位: 00111111 11111111 11111111 11111010(00) (补码)
由于最高位是0,所以它的原码,反码,补码都是一样的。
最终结果位:0011111111 11111111 11111111 111010 = 1073741818
(6)三目运算符:(关系表达式)?表达式1:表达式2;
A.格式:(关系表达式)?表达式1:表达式2;
如果关系表达式的结果为true,运算后的结果是表达式1;
如果关系表达式的结果为false,运算后的结果是表达式2;
B.注意事项:a.三目运算符表达式的结果数据类型由三目运算符表达式1和表达式2中最大的数据类型决定的。
b.关系表达式一定只能是boolean类型。