1、關鍵字
關鍵字 ：被Java語言賦予特定含義的單詞
特點 ：組成關鍵字的字母全部小寫
注意事項 ：goto和const作為保留字存在,目前并不使用 ，類似IDEA這樣的集成工具,針對關鍵字有特殊的顏色標記，非常直觀，加上下列50個共有52個關鍵字：
2、常見命名規則
2.1、識別符號
識別符號：給類，介面，方法，變數等起名字時使用的字符序列
組成：1、英文大小寫字母
2、數字
3、$和_
注意事項：
1、不能以數字開頭
2、不能有除$和_以外的特殊字符出現
3、不能是java關鍵字
2.2、其他
2.2.1、包（理解為一個檔案夾/目錄）
單級檔案夾（所有字母全部小寫）
舉例：bigdata
多級檔案夾（所有字母全部小寫，檔案夾之間用 . 分開）
舉例：com.bigdata.rz
2.2.2、類或者介面
一個單詞組成（首字母大寫其余字母小寫）
舉例：Hello
多個單詞組成（所有單詞的首字母大寫，其余字母小寫）
舉例：HelloWorld
2.2.3、方法和變數
一個單詞組成（所有字母小寫）
舉例：eat
多個單詞組成（第一個單詞全部小寫，從第二個單詞開始，首字母大寫，其余字母小寫）
舉例：playGame
2.2.4、常量
一個單詞組成（所有字母全部大寫）
舉例：NAME
多個單詞組成（所有字母全部大寫，單詞與單詞之間用下劃線連接）
舉例：FIRST_NAME
3、注釋
注釋 ：用于解釋說明程式的文字 Java中注釋分類格式
單行注釋格式： // 注釋文字
多行注釋格式： /* 注釋文字 */
檔案注釋格式：/** 注釋文字 */
注釋是一個程式員必須要具有的良好編程習慣， 初學者撰寫程式可以養成習慣：先寫注釋再寫代碼， 將自己的思想通過注釋先整理出來，在用代碼去體現， 因為代碼僅僅是思想的一種體現形式而已，
// 宣告一個類，類名為HelloWoeld
class HelloWorld {
// 定義main函式，使程式能被jvm呼叫
public static void main(String[] args){
// 呼叫輸出函式，輸出:HelloWorld!
System.out.println("HelloWorld!");
}
}4、常量
常量：在程式執行的程序中其值不可以發生改變 ，Java中常量分為字面值常量和自定義常量
4.1、常量的分類
（1）字面值常量
字串常量 用雙引號括起來的內容 "abc"
整數常量 所有整數 12,23
小數常量 所有小數 12.34,56.78
字符常量 用單引號括起來的內容 ‘a’,’A’,’0’
布爾常量 較為特有，只有true和false
空常量 null(陣列部分講解)
（2）自定義常量（面向物件部分講解）
4.2、進制
4.2.1、不同進制的資料組成
二進制：由0，1組成，以0b開頭
八進制：由0，1，...，7組成，以0開頭
十進制：由0，...，9組成，整數默認是十進制的
十六進制：有0，1，...，9，a，b，c，d，e，f組成，以0x開頭
4.2.2、進制轉換
其他進制轉十進制：系數*基數^權的和
十進制轉其他進制：除基取余，直到商為0，余數反轉
二進制與十進制的快速轉換：8421碼
任意進制之間的轉換：1、以十進制為橋梁
2、拆分組合法
a: 八進制3位為一組
b: 十六進制4位為一組
/*
Java針對整數常量提供了4種表現形式:
二進制
由0，1組成，以0b開頭
八進制
由0，1，2，3，4，5，6，7組成，以0開頭
十進制
由0，1，2，3，4，5，6，7，8，9組成，整數默認就是十進制的
十六進制
由0，1，2，3，4，5，6，7，8，9，a，b，c，d，e，f組成，以0x開頭
1、求32的二進制，八進制，十六進制，
32的二進制：
32/2 = 16 ..... 0
16/2 = 8 ..... 0
8/2 = 4 ..... 0
4/2 = 2 ..... 0
2/2 = 1 ..... 0
1/2 = 0 ..... 1
32的二進制為：0b100000
32的八進制：
32/8 = 4 ..... 0
4/8 = 0 ..... 4
32的八進制為：040
32的十六進制：
32/16 = 2 ..... 0
2/16 = 0 ..... 2
32的十六進制為：0x20
2、0b10010的十進制
二進制： 十進制：18
0b10010 = 1*2^4 + 0*2^3 + 0*2^2 + 1*2^1 + 0*2^0
= 16 + 0 + 0 + 2 + 0
= 18
3、求下面各進制對應的十進制
0b10101 = 1*2^4 + 0*2^3 + 1*2^2 + 0*2^1 + 1*2^0
= 16 + 0 + 4 + 0 + 1
= 21
0123 = 1*8^2 + 2*8^1 + 3*8^0
= 64 + 16 + 3
= 83
0x3c = 3*16^1 + 12*16^0
= 48 + 12
= 60
4、0b100110的八進制 046
100 110
4 6
5、0b100110的十六進制 0x26
10 0110
2 6
*/4.3、有符號資料表示法
在計算機內，有符號數有3種表示法：原碼、反碼和補碼，所有資料的運算都是采用補碼進行的，
原碼：就是二進制定點表示法，即最高位為符號位，“0”表示正，“1”表示負，其余位表示數值的大小，
反碼：正數的反碼與其原碼相同；負數的反碼是對其原碼逐位取反，但符號位除外，
補碼：正數的補碼與其原碼相同；負數的補碼是在其反碼的末位加1，
5、資料型別
5.1、基本資料型別（從小到大）
整數型別：
byte 1個位元組 -2^7~2^7-1
short 2個位元組 -2^15~2^15-1
int 4個位元組 -2^31~2^15-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個位元組
5.2、參考資料型別（面向物件部分講解）
5.3、資料型別轉換
自動型別轉換：
byte,short,char在參與運算的時候會自動提升到int型別
由大的資料型別接收小的資料型別，會自動轉換，不會報錯，
強制型別轉換
由小的資料型別接收大的資料型別，會報錯，接收不了，這時候需要強制型別轉換
格式：目標資料型別 目標變數名 = (目標資料型別)要轉換的數值/變數
/*
byte b = 130;有沒有問題?如果我想讓賦值正確，可以怎么做?結果是多少呢?
有問題，因為byte資料型別的范圍是在-128~127之間，而130超出了范圍，
*/
public class DataTypeDemo{
public static void main(String[] args) {
// byte b = 130;
byte b = (byte)130;
System.out.println(b); // -126
b = (byte)131;
System.out.println(b);
byte b1 = (byte)300;
System.out.println(b1); // 44
}
}
/*
我們知道資料在計算機中運算的時候是采用補碼的形式引數運算的，所以要知道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
*/
6、運算子
6.1、算數運算子
6.1.1、+，-，*，/，%
/*
System.out.println(“hello”+’a’+1);
System.out.println(‘a’+1+”hello”);
System.out.println(“5+5=”+5+5);
System.out.println(5+5+”=5+5”);
+號的用法：
1、當加號兩邊都是數字或者是數字和字符的時候，這時候的+號做的是加法運算
2、當加號兩邊其中是字串的時候，做的是字串拼接，拼接后是一個新的字串
3、字串與任何數值做加法，做的是字串拼接，拼接后是一個新的字串
*/
public class DataTypeDemo{
public static void main(String[] args) {
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
//System.out.println("5+5="+5+5); // 5+5=55 我想先計算后面的5+5怎么辦？
//小括號可以改變運算的順序優先級
System.out.println("5+5="+(5+5));
}
}
/*
運算：
對常量和變數進行操作的程序稱為運算，
運算子：
對常量和變數進行操作的符號稱為運算子
運算元：
參與運算的資料
運算式：
用運算子把常量或者變數連接起來符號并且符合java語法的式子就可以稱為運算式，
不同運算子連接的式子體現的是不同型別的運算式，
算術運算子：
+，-，*，/，%，++，--
*/
public class OptArithmeticDemo{
public static void main(String[] args) {
//+ 加法運算
System.out.println(1+1); //2
//-減法運算
System.out.println(5-2); //3
//* 乘法運算
System.out.println(2*2); //4
// / 整除運算,只獲取整數部分
System.out.println(5/2); //2
// 我就想獲取小數怎么辦？將其中的某一個數的資料型別變成double
System.out.println((5*1.0)/2); // 2.5
// % 取余運算
// 5/2=2 .... 1
System.out.println(5%2); //1
}
}
6.1.2、++，--
/*
1:基本小題目
int a = 10;
int b = 10;
int c = 10;
a = b++;
c = --a;
b = ++a;
a = c--;
請分別計算出a,b,c的值
*/
public class OptArithmeticDemo{
public static void main(String[] args) {
int a = 10;
int b = 10;
int c = 10;
a = b++; // a=10 ,b=11 ,c=10
c = --a; // a=9 ,b=11 ,c=9
b = ++a; // a=10 ,b=10 ,c=9
a = c--; // a=9 ,b=10 ,c=8
System.out.println(a); // 9
System.out.println(b); // 10
System.out.println(c); // 8
}
}
/*
int a = 4;
int b = (a++)+(++a)+(a*10);
*/
public class OptArithmeticDemo{
public static void main(String[] args) {
int a = 4;
int b = (a++)+(++a)+(a*10);
// 4 6 60
// a=5 a=6 a=6
System.out.println(a);//6
System.out.println(b);//70
}
}
6.2、賦值運算子
short s=1, s = s+1;
short s=1, s += 1;
上面兩個代碼有沒有問題，如果有，那里有問題？
第一個有問題，因為變數參與運算，首先會提升資料型別，然后做運算，所以 s = s+1;s會提升到int型別然后再做加法運算，最終的結果是int型別，所以拿short型別接識訓報錯，所以要想成功賦值，就得強制型別轉換，
第二個代碼沒有問題，是因為內部自動包含了強制型別轉換，s+=1 ===> s = (s的資料型別)(s+1)
/*
賦值運算子： = , +=, -=, *=, /=, %=
其中我們一直在使用的也是最常用的：=
*/
public class OptFuZhiDemo{
public static void main(String[] args) {
// int a = 10;
// int b = a;
// System.out.println(a);
// System.out.println(b);
// +=
// int a += 10;
int a = 10;
a += 20; //這里實際上可以看作為a的值加上了一個20再賦值給a
//但是不能完全等于 a = a + 20
//因為a += 20等價于a = (int)(a + 20)
System.out.println(a);
//-=
a-=10;
System.out.println(a); //20
//*=
a*=2;
System.out.println(a); //40
// /=
a/=2;
System.out.println(a); //20
// %=
a%=3;
System.out.println(a); //2
}
}
6.3、關系運算子
關系運算子： ==,!=,>,<,>=,<=
注意事項：
1、關系運算子的運算式的結果是一個boolean型別，要么是true，要么是false
2、==不能少寫，一個=是賦值運算子，==才是關系運算子
3、賦值的時候要注意型別問題,關系運算子運算式的結果是boolean型別，所以接收的時候只能是boolean型別的變數接收，
public class OptGuanXiDemo{
public static void main(String[] args) {
int a = 3;
int b = 4;
boolean flag = (a == b);
System.out.println(flag); //false
//!=
System.out.println(a != b); //true
//>
System.out.println(a>b); //false
//<
System.out.println(a<b); //true
//>=
a = 4;
System.out.println(a>=b); //true
//<=
System.out.println(a<=b); //true
System.out.println(a==b); //true
System.out.println(a=b); //4
}
}
6.4、邏輯運算子
邏輯運算子： &,|,^,!,&&,||
邏輯運算子的兩邊放的是boolean型別的值，計算的結果也是一個boolean型別的值
&: 參與運算的時候，有false,則false,兩邊都做運算
|: 參與運算的時候，有true,則true,兩邊都做運算
^: 參與運算的時候，相同為false，不同為true,兩邊都做運算
!: 將true變成false,false變成true
&&: 短路與，結果和單個與結果一樣，有false則false，但是執行的東西不一樣,
當&&左邊的運算式結果為false的時候，結果是false，右邊不執行
||: 短路或，結果和單個或結果一樣，有true則true,但是執行的東西不一樣,
當||左邊是true的時候，右邊不執行，結果是true.
邏輯運算子用于連接布爾型運算式，在Java中不可以寫成3<x<6，應該寫成x>3 & x<6
6.5、三目運算子
三目運算子：又稱之為三元運算子
格式：(關系運算式)?運算式1:運算式2;
如果關系運算式的結果為true，運算后的結果是運算式1；
如果關系運算式的結果為false，運算后的結果是運算式2；
注意事項：
1、三目運算子運算式的結果資料型別由三目運算子運算式1和運算式2中最大的資料型別決定的，
2、關系運算式一定只能是boolean型別
public class OptSanMuDemo{
public static void main(String[] args) {
//求出a,b中的最大值
int a = 10;
int b = 30;
//三目運算子解決
int c = (a>b)?a:b;
System.out.println(c); //30
/*面試題：
int a1 = 20;
double b1 = 30.0;
double c1 = (a1>b1)?a1:b1;
System.out.println(c1); //30.0,資料型別取決于a1,b1最大的資料型別
*/
}6.6、位運算子
/*
位運算子：
<<,>>,>>>,&,|,^,~
*/
public class OptWeiDemo{
public static void main(String[] args) {
byte a = 3;
byte b = 4;
System.out.println(a&b);
System.out.println(a|b);
System.out.println(a^b);
System.out.println(~a); //-4
}
}
/*
由于資料在計算機中參與運算的都是補碼，而想要知道補碼，就得知道反碼，原碼，就得求出二進制
3的二進制：00000011
4的二進制：00000100
又由于3和4都是正數
3的補碼：00000011
4的補碼：00000100
& 運算：有0則0
00000011
&
00000100
---------------
00000000
結果是 ： 0
====================================
| 運算：有1則1
00000011
|
00000100
--------------
00000111
結果是：7
====================================
^ 運算：相同則0，不同則1
00000011
^
00000100
--------------
00000111
結果是：7
====================================
~ 運算：1變成0，0變成1
00000011
~
-------------
補碼： 11111100
已知補碼求原碼：
反碼： 11111011
原碼： 10000100
結果是：-4
*/
/*
位運算子：
<<: 左移，二進制左移，右邊用0補齊,多出來的丟棄
>>: 右移，最左邊最高位是0用0補齊，最高位是1就用1補齊，多出來的丟棄，
>>>: 無符號右移，無論左邊最高是0還是1，都用0補齊，多出來的丟棄，
*/
public class OptWeiDemo2 {
public static void main(String[] args) {
System.out.println(3<<2); //12 = 3*4 = 3*2^2
System.out.println(24>>2); //6 = 24/(2*2)
System.out.println(-24>>2);// -6
System.out.println(-24>>>2);//1073741818
System.out.println(3<<3); // 3*2^3
}
}
/*
<<: 左移，二進制左移，右邊用0補齊
3的二進制：00000000 00000000 00000000 00000011
由于3是正數，所以原碼，反碼，補碼都一樣
3的補碼：00000000 00000000 00000000 00000011
左移：
00000000 00000000 00000000 00000011
(00)00000000 00000000 00000000 00001100 （補碼）
由于最高位是0，既是補碼也是原碼，所以結果是： 12
================================================================
>>: 右移，最左邊最高位是0用0補齊，最高位是1就用1補齊，多出來的丟棄，
24的二進制：00000000 00000000 00000000 00011000
由于24是正數，所以原碼，反碼，補碼都一樣
24的補碼：00000000 00000000 00000000 00011000
右移：
00000000 00000000 00000000 00011000
0000000000 00000000 00000000 000110(00) (補碼)
由于最高位是0，既是補碼也是原碼，所以結果是：6
================================================================
>>: 右移，最左邊最高位是0用0補齊，最高位是1就用1補齊，多出來的丟棄，
-24的二進制：10000000 00000000 00000000 00011000
已知原碼求補碼：
原碼：10000000 00000000 00000000 00011000
反碼：11111111 11111111 11111111 11100111
補碼：11111111 11111111 11111111 11101000
右移：
11111111 11111111 11111111 11101000
1111111111 11111111 11111111 111010(00) (補碼)
已知補碼求原碼：
補碼：11111111 11111111 11111111 11111010
反碼：11111111 11111111 11111111 11111001
原碼：10000000 00000000 00000000 00000110
最終結果是：-6
==============================================================
>>>: 無符號右移，無論左邊最高是0還是1，都用0補齊，多出來的丟棄，
-24的二進制：10000000 00000000 00000000 00011000
已知原碼求補碼：
原碼：10000000 00000000 00000000 00011000
反碼：11111111 11111111 11111111 11100111
補碼：11111111 11111111 11111111 11101000
無符號右移2位：
11111111 11111111 11111111 11101000
0011111111 11111111 11111111 111010(00) (補碼)
由于最高位是0，所以它的原碼，反碼，補碼都是一樣的，
最終結果位：0011111111 11111111 11111111 111010 = 1073741818
*/
面試題： 請用最有效率的方式寫出計算2乘以8的結果
a<<b == a*2^b
a>>b == a/2^b
/*錯誤答案：System.out.println(2*8);
正確答案：System.out.println(2<<3);
*/--2022.1.4
轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/404098.html
標籤：其他