第二章 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类型。
————————————————
版权声明：本文为CSDN博主「TheVan373」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_48492846/article/details/122331736
1211
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
