Java基礎
在開始學習Java基礎之前，我們先來學習一下IDEA
打開IDEA，新建一個專案(New Project)，選擇空專案(Empty Project)，填寫專案名(Project name)比如我的JavaSE，填寫路徑(Project localtion)比如我的D:/代碼/JavaSE，最后選擇結束Finish；這樣我們的空專案就建好了；加載好后如果提示就選擇This Windows
在IDEA左上角選擇檔案(File)，選擇新(New)，選擇新建模塊(New Module)，選擇Java，保證模塊的SDK與我們安裝的版本一致，選擇下一步(Next)，模塊名(Module name)比如我的基礎語法，選擇根路徑(Content root)比如我的D:\代碼\JavaSE\基礎語法，最后選擇結束(Finish)l；這樣新的模塊就建好了
最后來配置Java的環境，這一步不做的話Java在IDEA上是無法運行的，在左上角選擇檔案(File)，選擇專案結構(project Structure)，再選擇專案(project)，名字(Name
)填專案名即可，比如我的JavaSE，SDK選擇我們對應的版本，語言等級(Language level)選擇8，因為我們裝的是8，編譯器輸出的內容保持路徑(Compiler output)比如我的D:\代碼\JavaSE\out，然后應用(Apply)，最后ok
這樣我們就可以新建class了，我一般習慣在src下面新建
如果代碼class檔案多的話可以新建一個包(也就是檔案夾來存放代碼)，在src這里右鍵，選擇new，選擇package，輸入名字，然后就能把包拖進去；不過需要注意，每個java檔案開頭都會多一句(package 包名;)這一句不能刪，刪了就會報錯，這句是用來宣告，這個java檔案是在這個包里面
注釋、識別符號、關鍵字
注釋
? 平時我們撰寫代碼，在代碼量較少的時候，我們還可以看懂自己寫的，但是當專案結構一旦復雜起來，我們就需要用到注釋
? 注釋并不會被執行，是給我們寫代碼的人看的
- 重點書寫注釋是一個非常好的習慣，利于自己也利于別人！
? 這里我在這里吐槽一下：我一個學了一年多Python的同事，為了便利 作業寫了一個自動化腳本，跟我說運行起來老是報錯，檢查過了很多遍，想讓我幫忙看一眼，我覺得也沒有多大事，就讓他發來，下載后我打開一看，整篇下來一個注釋都沒有，，，我直接傻眼，想著畢竟話都放出去了，而且代碼量不是很龐大，硬著頭皮給他看完了，我還給他加上了注釋！在此我奉勸各位仁兄，為了我們的頭發也為了自己的頭發，一定要好好寫注釋！一定要好好寫注釋！一定要好好寫注釋！
Java中的注釋有三種
- 單行注釋（// 注釋）
public class Hello{
public static void main(String[] ages){
// 輸出一個Hello,World!
System.out.println("Hello,World!")
}
}
- 多行注釋（/星號開頭星號/結尾，中間都為注釋）
public class Hello{
public static void main(String[] ages){
/*
輸出一個Hello,World!
輸出一個Hello,World!
輸出一個Hello,World!
*/
System.out.println("Hello,World!")
}
}
- 檔案注釋
? 這個后面JavaDoc再講，一般很少寫檔案注釋
關鍵字
在學習識別符號之前我們先了解一下關鍵字
? 在我們使用IDEA寫java程式的時候那些高亮的單詞就是關鍵字，比如：public class等
常用的關鍵字有下面這些
? 以后就要記住取名字就不能使用關鍵字里面有的了，比如你創建一個類
public class class{
......
}
這樣是會報錯的！
識別符號
- Java 所有的組成部分都需要名字，比如：類名、變數以及方法名都被稱為識別符號
? 類名：我們寫Hello程式的時候，其中和檔案名一樣的那個就是類名；是識別符號
? 變數：String a = "小迪"; 我們定義一個變數就是這樣，其中a是變數名；是識別符號
? 方法：public static void main(String[] args) {}其中main就是我們的方法名；是識別符號
如果上面這些變數這些看的不是很懂的話沒關系，我這里只是告訴你上面是識別符號，其他的后面會講
識別符號的注意點
- 所有的識別符號都應該以字母（A-Z或a-z），美元符($)、或者下劃線(_)開始
- 首字符之后可以是字母（A-Z或a-z），美元符($)、或者下劃線(_)或數字的任何字符組合
- 不能使用關鍵字作為識別符號
- 識別符號是大小寫敏感的(意思就是區分大小寫)
- 合法識別符號舉例：age、$xiaodi、_China、__2_value
- 非法舉例：1value、%salary、^open
- 可以使用中文命名，但是一般不建議這樣去使用，也不建議使用拼音(不過我不精通英語有時候也會用)
什么是位元組
位（bit）：是計算機 內部資料 儲存的最小單位，11001100是一個八位二進制數
位元組（byte）：是計算簡中 資料處理 的基本單位，習慣用大寫的B來表示
1B （byte，位元組）= 8bit （位）
字符：是指計算機中使用的字母、數字、字和符號
1bit表示1位
1Byte表示一個位元組 1B=8b
1024B=1kb
1024kb=1M
1024M=1G
資料型別
強型別語言
- Java是一種強型別語言；要求變數的使用要嚴格符合規定，所有變數都必須先定義后才能使用；也就是說一旦定義了一個變數，指定了某個資料型別，如果你不經過轉換的話他就永遠是這個型別了；安全性高相對的弊端速度會變慢；
如下代碼：
public class Demo01{
public static void main(String[] args){
String name=1;
int num="XiaoDi";
}
}
? 這是錯誤示范：
? 我們定義name為字串型別的變數卻把數字型別的值賦值給它
? 定義num為數值型別卻把字串型別的值賦值給它
以上這種書寫是錯誤的，我們必須嚴格符合規定的書寫，將name的值改為字串型別、num的值改為數字型別；如下代碼：
public class Demo01{
public static void main(String[] args){
String name="XiaoDi";
int num=1;
}
}
弱型別語言
? 與強型別語言相反，這里就不做演示了！
Java的資料型別分為兩大類
基本資料型別（primitive type）
? 數值型別
? 整數型別
? byte占一個位元組范圍：-128-127 超過位元組范圍就會報錯
? short占兩個位元組范圍：-32768-32767
? int占4個位元組范圍：-2147483648-2147483647 一般這個就夠用了
? long占8個位元組范圍：-9223372036854775808-9223372036854775807
? 浮點型別
? float占4個位元組
? double占8個位元組 常用
? 字符型別
? char占兩個位元組
? boolean型別
? 占1位其值只有true和false兩個
public class Demo02{
public static void main(String[] args){
//八大基本資料型別
//整數
int num1 = 10; //最常用
byte num2 = 20;
short num3 = 30;
long num4 = 30L; //long型別要在數字后面加個L
//小數：浮點數
float num5 = 50.1F; //float型別要在數字后面加個F
double num6 = 3.1415926535;
//字符
char name = 'A'; //只能寫一個字符，超過就報錯
//字串,String不是關鍵字，是類
//String namea = "小迪";
//布林值：是，非 1，0
boolean flag = true;
//boolean flag = false;
}
}
參考資料型別 (reference type)
? 類、介面、數組；后面學
資料型別擴展及面試題講解
整數、浮點型別擴展
public class Demo03{
public static void main(String[] args){
//整數擴展： 進制 二進制用0b表示 十進制 八進制0表示 十六進制0x表示
int i = 10;
int i2 = 010; //八進制0表示
int i3 = 0x10; //十六進制0x 0~9 A~F F為16
//浮點數擴展
float f = 0.1F; //0.1
double d = 1.0/10; //0.1
System.out.println(f==d); //輸出結果false
//明明兩個是相等的應該輸出true才對啊
//再來看一下下面這個更詭異的
float d1 = 231313123123123113F;
float d2 = d1 + 1;
System.out.println(d1==d2); //輸出結果true
//兩個值完全是不相等的，但是判斷時卻回傳true
}
}
那么為什么會出現上面這種情況呢？首先，我們這個浮點數表現的字長是有限的，一般會存在一個舍入誤差的東西，因為有很多數字它沒辦法精確表示，所以它的結果只能是個大約數，（接近但不等于）
所以總結出一句話：
- 最好完全避免使用浮點數進行比較
- 最好完全避免使用浮點數進行比較
- 最好完全避免使用浮點數進行比較
那么有人就會問：我們如果一定需要用到浮點數進行比較怎么辦？比如銀行的業務怎么表示？錢
? 我們后面會學到一個類：BigDecimal 數學工具類
字符型別擴展
public class Demo04{
public static void main(String[] args){
//字符型擴展
char c1 = 'a';
char c2 = '中';
System.out.println((int)c1); //強制轉換 輸出結果為97
System.out.println((int)c2); //強制轉換 輸出結果為20013
}
}
以上這種情況，我們是使用了型別轉換，將字符轉換成了數字，那為什么a是97，中是20013呢？
記住下面這句話：
- 所有的字符本質還是數字
char型別會涉及到編碼問題：Unicode編碼 可以處理各種語言的文字，占2位元組
我們也可以像下面這樣直接給變數c3賦值Unicode編碼，再進行輸出 （其中\是轉義不懂沒關系下面會講）
char c3 = '\u0061';
System.out.println(c3); //輸出結果為：a
//這個是一些底層的原理，了解一下就ok，萬一以后大家面試被問到了就懂了！
轉義字符
- \t：制表符：轉義成tab鍵
- \n：換行：相當于回車鍵
如圖下：
這里我給大家留一個懸念
String sa = new String(original:"hello world");
String sb = new String(original:"hello world");
System.out.println(sa==sb); //輸出結果為false
? 為什么兩個值是一樣的，卻回傳false
? 等后面學到物件的時候，再給大家從記憶體級別分析一下為什么
布林值擴展
if陳述句我們還沒有學我們也留一個懸念在這！
public class Demo05{
public static void main(String[] args){
boolean flag = true;
//我們一般會通過布林值做一些判斷；如下
if (flag==true){} //新手
//有的代碼它不會把==true寫出來它會像下面這種寫法
if (flag){} //老手
//只是寫法不一樣但是意思和作用是一樣的
}
}
這兩種寫法可以看出寫代碼的人是新手還是老手；
java中有一個概念叫做：Less is More！(少即是多)；我的理解是：代碼要精簡易讀
型別轉換
由于Java是強型別語言，所以要進行有些運算的時候，需要用到型別轉換，
底--------------------------------------------->高
byte,short,char -> int -> long -> float -> double
//有人會問float才4個位元組32位，為什么會比long8個位元組64位高
//整型的優先級比浮點型低是因為，浮點型別的資料如果轉換成整型就會損失精度，就是小數點后面的數會被省略
運算中，不同型別的資料，必須先轉化為同一型別，然后進行運算，
強制型別轉換
高轉低的時候使用的轉換方式
強制型別轉換格式：(型別)變數名
public class Demo06{
public static void main(String[] args){
//int i = 128;
//byte b = i;
//上面這種寫法是錯誤會報錯的，因為i是int型別，b是byte型別，而且int的型別的優先級比byte的優先級高，是不能進行自動型別轉換的；我們需要把i進行強制轉換成byte型別才能進行賦值操作，如下：
int i = 128;
byte b = (byte)i;
System.out.println(i); //輸出結果為：128
System.out.println(b); //輸出結果為：-128
}
}
i輸出結果為128沒問題，那么為什么b的輸出結果會等于-128呢？
? 我們在IDEA輸入Byte按住Crte雙擊這個會打開這個函式的幫助檔案;在幫助檔案可以看到byte最大值是127，然而我們卻給它b賦值了128，就導致了記憶體溢位的問題了；記憶體溢位的話你就不知道這個值會變成什么了，
- 所以我們在轉換的程序中盡量避免這種記憶體溢位的情況
自動型別轉換
底轉高的時候使用的轉換方式
自動型別轉換是可以直接轉的
public class Demo07{
public static void main(String[] args){
int i = 128;
double b = i;
}
}
注意點總結：
- 不能對布林值進行轉換
- 不相干的型別不能進行轉換
- 高優先級型別轉換為低優先級型別需要使用強制轉換；反之不需要進行多余操作
- 轉換的時候可能存在記憶體溢位，或者精度問題
public class Demo08{
public static void main(String[] args){
//精度問題，存在于浮點型
System.out.println((int)23.7); //輸出結果為：23
System.out.println((int)-45.89F); //輸出結果為：-45
}
}
型別轉換例子：
public class Demo09{
public static void main(String[] args){
char c = 'a'; //這里注意一下，字符型要使用單引號，字串使用雙引號；
int d = c+1;
System.out.println(d); //輸出結果為：98
System.out.println((char)d); //輸出結果為：b
}
}
常見問題
public class Demo10{
public static void main(String[] args){
//操作較大的數的時候，注意溢位問題；順便介紹一下JDK7的新特性：數字之間可以使用下劃線分割，且不被輸出
int money = 10_0000_0000; //大家一年賺的錢
//System.out.println(money); //輸出結果為：1000000000
int years = 20; //大家比較勤奮干了20年
int total = money*years; //全部的錢
//System.out.println(total);
//輸出結果為：-1474836480；怎么還倒賠了？噢原來是 記憶體溢位；那么我用long試試
long tota2 = money*years;
//System.out.println(tota2);
//輸出結果還是：-1474836480；難道真的虧了？不不不，是因為money和years是int型別，money*years先計算好之后才把它轉換為long型別，轉換之前已經存在問題了，這個時候我們就不能這樣去做
//正確操作
long tota3 = money*((long)years);
System.out.println(tota3); //輸出結果：20000000000
//這才是大家總共賺的錢，我寫的那么辛苦多多少少也拿點分我花哈哈
}
}
好習慣
long num4 = 30L; //long型別要在數字后面加個L，雖然小寫的l也可以，但是容易看成1，最好使用大寫的L
float num5 = 50.1F; //float也是一樣最好使用大寫
//像上面這種代碼中賦值操作=兩邊最好也是加一個空格，這樣代碼看起來會比較整潔，養成好習慣從小迪做起
變數、常量、作用域
變數
- 變數是什么：就是可以變化的量！
- Java是一種強型別語言，每個變數都必須宣告其型別，
- Java變數是程式中最基本的存盤單元，其要素包括變數名，變數型別和作用域
type varName [=value] [{,varName[=value]}];
資料型別 變數名 = 值；可以使用逗號隔開來宣告多個同型別變數，但是我是不建議在一行里定義多個值的，因為這樣看起來會很亂，
public class Demo11{
public static void main(String[] args){
//宣告變數
//格式：資料型別 變數名 = 值
String name = "XiaoDi";
char x = 'X';
int num = 123;
}
}
注意事項
- 每個變數都有型別，型別可以是基本型別，也可以是參考型別
- 變數名必須是合法的識別符號
- 變數宣告是一條完整的陳述句，因此每一個宣告都必須以分號結束
變數作用域
新認知
public class Demo12{
//Demo12{}，這是我們定義的一個類
//類里面可以定義方法、屬性(大家可以先理解為變數)
public static void main(String[] args){
//main(String[] args){}，這是我們的一個main方法
}
//除了main方法我們還可以定義其他方法
public void add(){
}
}
有了上面的這些新認知我們來看一下區域變數：
區域變數是在我們方法和陳述句塊里面的；（陳述句塊還沒學先不管）
public class Demo12{
public static void main(String[] args){
//區域變數：必須宣告和初始化值
// int i;
// System.out.println(i); 你會發現這樣是輸出不了的，因為他沒有初始化值
int i = 10;
System.out.println(i); //輸出結果：10 且它的作用域只限于main的方法里面
}
public void add(){
// System.out.println(i); //我在這里輸出main方法里面的i是不行的，會報錯
}
}
我們再來看一下實體變數：
實體變數在我們的方法外面，類的里面；而且你需要通過這個類才能使用
public class Demo12{
//實體變數：從屬于物件；(我們還沒有學物件，你只要知道我們需要通過Demo12這個類才能去使用它)
//需要宣告，可無須初始化值
String name;
int agr;
public static void main(String[] args){
//實體變數的使用：這一段大家看不懂沒關系，先了解一下，看一下就行
//變數型別 變數名字 = new Demo12();
Demo12 demo12 = new Demo12();
System.out.println(demo12.age); //輸出結果為：0
System.out.println(demo12.name); //輸出結果為：null
}
public void add(){
}
}
注意：
? 實體變數如果沒初始化值，所有的數值型別的默認初始化值都是：0或0.0（0是整數型別;0.0是浮點數）；字符型別的話是 u0000，但是它也會輸出0；布林值默認是false；除了基本型別其他都為null，
類變數：
也是在方法外面，類里面；只不過他再呼叫的時候不需要像實體變數那么麻煩，
public class Demo12{
//類變數：static 后面講到jvm會給大家分析
static double salary = 2500;
public static void main(String[] args){
System.out.println(salary); //輸出結果為2500.0；是可以直接輸出的
}
public void add(){
}
}
后面我們在學習的程序中，遇到需要在類里面方法外面定義的變數，我們就使用類變數，這樣就不用去new了
有一些大家聽不懂的，不用去糾結，我們后面都會學到的；重點記一下關鍵字：static
常量
常量(Constant)：初始化后不能在改變值！不會變動的值，
常量可以理解為一種特殊的變數，它的值被設定后，在程式運行的程序中不允許被改變，
- 語法：final 常量名 = 值 或者 final 資料型別 常量名 = 值；
- 常量名一般使用大寫字符
public class Demo13{
//類變數的定義方法 +常量
static final double PI = 3.14;
//修飾符不存在先后順序，static和final誰在前面都一樣
public static void main(String[] args){
System.out.println(PI);
}
}
一般運用在：假如你要寫一個游戲，要設定寬和高(不需要變動的值)，我們把寬和高設定成賦值給常量即可；
變數的命名規范
所有變數、方法、類名：見名知意
類成員變數(類里面方法外面的變數)：首字母小寫和駝峰原則：monthSalary
區域變數：首字母小寫和駝峰原則
方法名：首字母小寫和駝峰原則：run()，runRun()
常量：大寫字母(如果多個單詞就以下劃線分開)：MAX_VALUE
類名：首字母大寫和駝峰原則：Man，GoodMan
運算子
Java語言支持如下運算子
算數運算子：+，-，*，/，%，++，--（加、減、乘、除、取余、后面兩個等一下講）
賦值運算子：=（java中=是賦值才是等于）
關系運算子：>，<，>=，<=，，!=，instanceof（大于、小于、大于等于、小于等于、等于、不等于、最后這個學到面向物件講）
邏輯運算子：&&，||，!（與、或、非）
位運算子：&，|，^，~，>>，<<，>>>（了解即可）
條件運算子：?，:
擴展賦值運算子：+=，-=，*=，/=
- 前面字體加粗的4種運算子是一定要掌握的，位運算子了解一下就行，后面這兩個是用來偷懶用的，會就行
算數運算子
演示 加減乘除：
public class Demo14{
public static void main(String[] args){
//+ - * / 二元運算子：就是需要兩個運算元的
int a = 10;
int b = 20;
int c = 30;
int d = 40;
System.out.println(a+b); //結果：30
System.out.println(a-b); //結果：-10
System.out.println(a*b); //結果：200
System.out.println(a/b); //結果：0
}
}
為什么這個a/b等于0呢？
? 因為a是int型的b也是int型的，他們兩個除完還是int型的，他們的值應該等于0.5，但是被整數形型別限制住了，只能舍去小數，所以等于0；所以我們不能這樣寫，我們要隨便對一個進行強制型別轉換，System.out.println(a/(double)b);
演示 4種整數型別相加的情況
public class Demo15{
public static void main(String[] args){
long a = 123123123123123L;
int b = 123;
short c = 10;
byte d = 8;
System.out.println(a+b+c+d); //算出來還是long型別
System.out.println(b+c+d); //int型別
System.out.println(c+d); //int型別
}
}
得出結果：
- 多個運算元中，有一個數為long型別，那么這個結果型別也為long
- 如果多個運算元中，沒有一個數為long型別，那么結果的型別都為int
我們再來看一下其他基礎資料型別型別：
public class Demo16{
public static void main(String[] args){
double a = 0.3;
int b = 3;
char c = 'a';
System.out.println(a+b); //結果：3.3為浮點型
System.out.println(a+c); //結果：97.3為浮點型
System.out.println(b+c); //結果：100為整形
}
}
得出結果：
- 不同基本的相加最終得出的結果的型別，取決于運算元中在型別轉換中較高優先級的型別
- 我能大膽的告訴你-，*，/也是這樣的；但是也會遇下面這兩種種情況：
public class Demo17{
public static void main(String[] args){
int a = 3;
int b = 6;
char c = 'a';
System.out.println(a/c); //結果為0
System.out.println(b/c); //結果為0
}
}
那么這兩種情況與上面演示 加減乘除：這種情況是一樣的
關系運算子
關系運算子只有兩種回傳結果：正確和錯誤，就是通過布林值來表示的
public class Demo18{
public static void main(String[] args){
int a = 10;
int b = 20;
System.out.println(a>b); //false
System.out.println(a<b); //true
System.out.println(a==b); //false
System.out.println(a!=b); //true
}
}
后期會經常與if去使用！
取余、自增自減運算子、初識Math類
取余、模運算
public class Demo19{
public static void main(String[] args){
int a = 10;
int b = 21;
System.out.println(b%a);//結果為1
}
}
就像我們小學學的余數21/10=2......1；取余就是要這個余數；也叫模運算+
自增、自減(一定要理解起來)
這個比較難理解，但是我會講的通俗一點
public class Demo20{
public static void main(String[] args){
// ++ -- 自增、自減 一元運算子
int a = 3;
int b = a++;
int c = ++a;
System.out.pringln(a); //5
System.out.pringln(b); //3
System.out.pringln(c); //5
}
}
為什么會是這樣的結果呢？
原因就在++的位置：
? int b = a++;
? ++在后面：先給b進行賦值，再進行自增
? 就是說a初始值是3；int b = a++;這句是先把初始值3賦值給b之后，然后再進行a=a+1;
? int c = ++a;
? ++在前面：先進行自增，再進行賦值
? 就是說現在a的值是4，int c = ++a;這句是先進行a=a+1;之后a值為5，再把5賦值給c
自減也是這樣的！
初識Math
public class Demo21{
public static void main(String[] args){
//冪運算 2^3 2*2*2 = 8
//java中是像下面這樣寫的；我們會借助到數學類Math
double pow = Math.pow(2,3); //這樣是表示2的3次方
System.out.println(pow); //8.0
}
}
在java中，很多運算，我們會使用一些工具類來操作！
邏輯運算子、位運算子
邏輯運算子
public class Demo22{
public static void main(String[] args){
// 與（and） 或（or） 非（取反）
boolean a = true;
boolean b = false;
System.out.println("a && b："+(a&&b)); //a && b：false
//邏輯與運算：兩個變數都位true，結果才為true
System.out.println("a || b："+(a||b)); //a || b：true
//邏輯或運算：兩個變數有一個位true，結果才為true
System.out.println("! (a && b)："+!(a&&b));//! (a && b)：true
//邏輯非運算：對結果進行取反，如果結果為真則變為假，結果為假，則變為真
}
}
- 邏輯與運算：兩個變數都位true，結果才為true
- 邏輯或運算：兩個變數有一個位true，結果才為true
- 邏輯非運算：對結果進行取反，如果結果為true則變為false，結果為false，則變為true
短路運算
public class Demo23{
public static void main(String[] args){
//短路運算
//因為邏輯與運算需要兩個變數都為真結果才為真
//這樣的話是不是第一個為假第二個就不會執行了？下面我們來實驗一下
int a = 5;
boolean b = (a<4)&&(a++<4);
//c<4結果肯定為假，如果第一個變數為假，第二個變數沒有執行的話那么a還是等于5，實驗成功；如果第二個變數執行了的話那么a就等于6，實驗失敗；
System.out.println(b); //false
System.out.println(a); //5
}
}
短路法則：
變數1 && 變數2
變數1為“假”，則變數2不會再執行；
否則，變數1“真”，則變數2必須執行，
變數1 || 變數2
變數1為“真”，則變數2不會再執行；
否則，變數1“假”，則變數2必須執行，
位運算子
別輕易去用位運算，很容易出錯
$ | ^ ~位運算子里面的 位與、位或、位異或、位非(其中只有位非(~)是一元運算子，其他都為二元運算子)
public class Demo24{
public static void main(String[] args){
/*
布林值：false即是0，true即是1
比如我們現在有兩個值
A = 0011 1100
B = 0000 1101
A&B
位與運算子：A與B上面的和下面對其的都為1那么結果為1，否則為0；結果：0000 1100
也就是說兩者對其位都為true則結果為true，否則為false
A|B
位或運算子：A或B的對其位其中有一個為1那么結果為1，否則為0；結果0011 1101
也就是說兩者對其位只要有一個為true結果就為true，否則為false
A^B
位異或運算子：對其位不同即為1，相同則為0；結果：0011 0001
也就是對其位不相同為true，相同則為false
~B
位非運算子：就是取反，1取反為0,0取反為1；結果：1111 0010
也就是說如果為true就取反為false，為false取反為true
*/
}
}
<<、>>位運算子里面的 左移、右移 (涉及到一道面試題)
public class Deomo25{
public static void main(String[] args){
/*
常見的一道面試題
問：2*8怎么算最快
2*8大家都都可以直接知道等于16，但是計算機不知道
我們先來做一下這道題：
*/
System.out.println(2<<3); //2左移3位，結果為16
/*
給大家分析一下為什么2移一下為什么就變成16了
二進制 代表10進制的
0000 0000 0
0000 0001 1 *
0000 0010 2 *
0000 0011 3
0000 0100 4 *
0000 0101 5
0000 0110 6
0000 0111 7
0000 1000 8 *
0000 1001 9
0000 1010 10
0000 1011 11
0000 1100 12
0000 1101 13
0000 1110 14
0000 1111 15
0001 0000 16 *
上面這些就是2進制對應10進制的轉換結果
我標*號這些請仔細觀察一下你就會發現，十進制的1開始每次乘以2的結果，都對應著二進制的1往左移1位
*/
}
}
得出結果：
<<：左移相當于*2 所以2<<3相當于2x2x2x2
>>：右移相當于/2
- 把這個結果死死記載心里
- 我們現在雖然接觸不到演算法，但是很多底層的演算法它們會用位計算來做一些非常精巧的東西，因為位運算有一個好處：效率極高；因為它是直接跟底層打交道的，底層說的就是這個二進制
所以2*8在計算機中這么算最快：2<<3；
擴展賦值運算子、條件運算子
擴展賦值運算子
public class Demo26{
public static void main(String[] args){
int a = 10;
int b = 20;
a+=b; //這句話相當于a=a+b
System.out.println(a); //輸出30
}
}
我說過這個是用來偷懶的，但是我不建議大家偷懶
+=、-=、*=、/=都是像上面+=這個例子差不多
順便擴展一下字串連接符
public class Demo27{
public static void main(String[] args){
//涉及到一道常見面試題
int a = 10;
int b = 20;
//問下面兩種寫法有什么區別
System.out.println(""+a+b); //這個會輸出1020
System.out.println(a+b+""); //這個會輸出30
}
}
也就是說
? 如果這個字串在前面，那么后面的會拼接
? 如果這個字串在后面，那么前面的依舊進行運算
條件運算子
public class Demo28{
public static void main(String[] args){
//三元運算子
//x ? y : z
//如果x為true，則結果為y，否則結果為z
//演示個例子
int score = 50;
String type = score<60 ? "不及格" : "及格";
//上面這一句就是說，如果score小于60為真的(true)，那么就是不及格，為假的(false)，那么就及格
System.out.println(type);
}
}
這個也是用來偷懶的，因為后面我們會學if陳述句，我們一般使用條件分支陳述句if來判斷！
雖然是偷懶的，但是這個必須掌握，因為在我們開發中非常常見
優先級
? 就跟小學的先加減后乘除差不多
? 在java中一元運算子是最優先的然后加減乘除再來就是與或非等，但是這些東西在大家使用的時候會發現，這個東西不需要刻意去記住，運算式里有就優先使用括號()去組織，多打一些括號不影響代碼的理解，反而會更清晰
包機制、JavaDoc
包機制
為了更好地組織類，Java提供了包機制，用于區別類名的命名空間，
包陳述句的語法格式為：
package pkg1[.pkg2[.pkg3...]];
//放于檔案的最開頭
演示：這是我的一個package結構
package com.xiaodi.operator.base;
包的本質就是檔案夾
我們的包名不是憑空定義的，一般利用公司域名倒置作為包名比如：
? baidu.com com.baidu
為了能夠使用某一個包的成員，我們需要在java中明確匯入該包，使用inport陳述句即可完成此功能
import package1[.package2].(classname|*);
//放于 package下面
演示：匯入java自帶的Date類
package com.xiaodi.operator.base;
import java.util.Date;
public class Demo10 {
public static void main(String[] args){
//寫一個時間，直接像下面這樣寫是不行的，IDEA會報錯，會提示你按住Alt+回車，會幫你生成錯誤資訊和自動排錯,選擇第一個就行；你這個不用管我Date寫的是什么意思，你只要知道Date是來著java自帶的類就行
Date;
}
}
演示：匯入自己寫的類
package com.xiaodi.operator.base;
import com.xiaodi.operator.Demo01; //這樣是會報錯的，因為和我們下面這個類名一樣了，所以我們要避免包里面的檔案名重復
//下面這種名字不重復的就不會報錯
import com.xiaodi.operator.Demo02;
public class Demo01 {
public static void main(String[] args){
}
}
我們要避免檔案名重復，即使不同的包，檔案名也盡量不要重復，會干涉到import匯入報錯
有的人會問：我包里寫了100多個類，我不想一個一個去匯入；那么就可以使用通配符*；會把我們包里所有類都匯入進去；寫法如下
import com.xiaodi.operator.*;
這篇文章看完推薦大家去看個東西：百度搜索阿里巴巴開發手冊
認真看一遍
JavaDoc
JavaDoc檔案注釋：javadoc命令是用來生成自己的API檔案的；一種能將你的注釋資訊生成幫助檔案的技術；類似java的API幫助檔案一樣：可以去搜索jdk幫助檔案
引數資訊
- @author 作者名
- @version 程式版本號
- @since 指明需要用的jdk版本
- @param 引數名
- @return 回傳值情況
- @throws 例外拋出情況
加在類上面就是類的注釋，加在方法上面的就是我們方法的注釋
package com.xiaodi.operator.JavaDoc;
/**
* @author XiaoDi
* @version 1.0
* @since jdk8
*/
public class Doc {
String name;
/**
*
* @param name
* @return
* @throws Exception
*/
public String test(String name) throws Exception{
return name;
}
}
使用IDEA開發工具來寫的話，一般類的這個資訊是需要自己寫的，方法的只要你方法寫好了，在方法上面寫一行/**然后回車它就會自動生成
這個時候我們就可以使用javadoc命令來生成這個API檔案了，從檔案夾中打開Doc.java檔案；然后在地址欄輸入cmd；輸入下面這些代碼即可在當前檔案夾生成：
javadoc -encoding UTF-8 -charset UTF-8 Doc.java
我們的注釋中可能會有中文，所以需要加編碼引數-encoding UTF-8；表示使用UTF-8編碼，還需要加字符集引數-charset UTF-8
生成出來的檔案看index.html就行，其他不用管；
現在很少人用這種注釋方式(看一下就行)，這是用命令列生成的，也可以百度查一下怎么使用IDEA生成API檔案；
基礎知識，基本在后面的每一天都會用，所以非常重要重要重要！！！
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/436938.html
標籤：Java