1，常見的進制
學習程度：
知道什麼是二進制？什麼是十進制？什麼是八進制？什麼是十六進制就可以了。
十進制：
現實生活中是十進制。每一位由0123456789組成，逢十進一。
二進制：
計算機中是二進制。每一位由0和1組成，逢二進一。
八進制：（了解）
每一位由01234567組成。逢八進一。
十六進制：（了解）
每一位由0123456789abcdef組成。逢十六進一。
2，在Java中如何表示二進制，十進制，八進制，十六進制
學習程度：
我給你一個數字，你能判斷出來他是幾進制的，而且能說出是否報錯即可。
二進制：
是以0b開頭的。b可以大寫也可以小寫。
System.out.println(0b10);//0b相當于就是一個标記。
//标記着後面的數字是二進制下的。
十進制：
預設前面什麼都沒有
八進制：
是以0開頭的。
System.out.println(010);//前面的0相當于就是一個标記。
//标記着後面的數字是八進制下的。
十六進制：
是以0x開頭的。x可以大寫也可以小寫。
System.out.println(0x10);//前面的0x相當于就是一個标記。
//标記着後面的數字是十六進制下的。
案例1：
System.out.println(0b123);//報錯。
//因為0b表示着後面的數字是二進制。而二進制由0和1組成。沒有其他數字
//在本案例當中出現了2和3，就是錯誤的。
案例2：
System.out.println(090);//報錯
//因為以0開頭的，表示後面的數字是八進制的。而八進制由01234567組成。
//在本案例中出現了9，是以錯誤。
案例3：
System.out.println(0x123);//正确沒有問題，十六進制
//因為以0x開頭，表示是十六進制，十六進制由0123456789abcdef組成。
//本案例中所有的數字沒有超出範圍。
3，進制之間的轉換
手動計算不需要掌握。
咱們隻需要掌握使用電腦來求出進制就可以了。
4，計算機的存儲機關
一個數字如何存儲到硬碟當中？
先把這個數字轉成二進制，然後把二進制存到硬碟當中。
舉例：99 ----> 0110 0011 —> 在把二進制存儲到硬碟當中
知道計算機中最小的存儲單元是什麼？
是byte.
bit：在二進制中的一個0或者一個1。(比特位)
但是一個bit表示的内容太少了。是以我們會把8個bit分為一組。這一組就叫做byte。（位元組）
而這個位元組（byte）才是計算機中最小的存儲機關。
知道bit，位元組，KB,MB,GB,TB之間的轉換關系？
8個bit = 1個位元組
1024位元組 = 1KB
1024KB = 1MB
1024MB = 1GB
1024GB = 1TB
5，變量
什麼是變量？
就是在代碼中，臨時存儲資料一個容器，也可以把他了解為一個箱子。但是這個容器當中隻能存一個值。
變量的定義格式？
資料類型 變量名 = 資料值;
資料類型：表示這個變量以後隻能存什麼類型的資料。
變量名：就是這個容器的名字。以後想使用容器裡面的内容時，直接使用變量名就可以了。
= ：就是把右邊的數值指派給左邊的變量。
簡單了解就是把這個資料放到容器當中進行存儲。
資料值：真實的存到容器中的資料。
分号：表示語句的結束，就跟寫作文時候用到的句号是一模一樣的。
變量的命名規範
- 所有變量 、 方法 類名：**見名知意 **
- 類成員變量：首字母小寫和駝峰原則 monthSalary
- 局部變量：首字母小寫和駝峰原則
- 常量：大寫字母和下劃線：MAX_VALUE
- 類名：首字母大寫和駝峰原則：Man,GoodMan
- 方法名:首字母小寫和駝峰原則：run()，runRun()
舉例1：
//定義一個整數類型的變量
//資料類型 變量名 = 資料值;
整數類型 a = 10;
//此時在代碼當中，就會出現了一個容器。這個容器名字叫做a。這個容器隻能存整數，現在這個容器裡面已經有值了。值為10.
舉例2：
//定義一個小數類型的變量
//資料類型 變量名 = 資料值;
小數類型 b = 10.2；
//此時在代碼中，就會出現了一個容器，這個容器名字叫做b。這個容器隻能存小數，現在這個容器裡面已經有值了。值為10.2
6，Java中的資料類型
四類八種：
public class Demo01 {
public static void main(String[] args) {
//java分基本類型和引用類型
//八大基本資料類型
//整數4中資料類型
int num1= 10;
byte num2=20;
short num3=30;
long num4=30L;//Long類型後面要加L
//小數； 浮點數
float num5= 50.1F;//float類型後加F
double num6=3.66666566666666;
//字元
char name ='A';//字元隻能一個
//字元串,String不是關鍵字，類
//String namea="yuweikang"
//布爾值;是/非
boolean flag=true;
//boolean flag=false;
}
}
整數類型： byte short int long
浮點類型：（小數） float double
字元類型： char
布爾類型： boolean
定義變量的案例：
//定義一個整數類型的變量
byte a = 10;
short b = 20;
int c = 30;
long d = 40L;//如果要定義long類型的變量，在數字的後面需要加L字尾。
//定義一個小數類型的變量
float e = 10.1F;//如果要定義float類型的變量，在數字的後面需要加F字尾。
double f = 20.2;
//定義一個字元類型的變量
char g = '我';
//定義一個布爾類型的變量
boolean h = true;
字元串的詳細知識我們在就業班會學習。
目前，我們暫時隻要知道如何定義字元串類型的變量即可。
public class Demo3 {
public static void main(String[] args) {
//整數拓展： 進制 二進制0b 十進制 八進制0 十六進制0x
int i=10;
int i2=010;//八進制0
int i3=0x10;//十六進制0x 0~9 A~F
System.out.println(i);
System.out.println(i2);
System.out.println(i3);
System.out.println("------------------------------------");
//------------------------------------
//浮點數拓展? 銀行業務怎麼表示？ 錢
// BigDecimal 數學工具類
//------------------------------------
//float 有限 離散 有誤差 大約 接近但不等于
//double
//最好完全避免使用浮點數進行比較
//最好完全避免使用浮點數進行比較
//最好完全避免使用浮點數進行比較
float f = 0.1f; //0.1
double d = 1.0/10;//0.1
System.out.println(f==d);//false 不一樣
System.out.println(f);
System.out.println(d);
float d1 = 232323232323f;
float d2 = d1+1;
System.out.println(d1==d2);//trule 等于說明浮點數有問題
System.out.println("------------------------------------");
//------------------------------------
//字元拓展？
//------------------------------------
char c1 = 'a';
char c2 = '中';
System.out.println(c1);
System.out.println((int)c1);//強制轉換
System.out.println(c2);
System.out.println((int)c2);//強制轉換\
//所有字元本質還是數字
//編碼 Unicode 表：(97=a 65= A) 2個位元組 0~65536 Excel 2的16次方=65536
//U0000 uFFFF
char c3 ='\u0061';
// \u0000 轉譯
System.out.println(c3); //a
//轉譯字元
// \t 空格
// \n 換行
//...
System.out.println("你\t好");
//布爾值擴充
boolean flag = true;
if (flag==true){}//新手
if (flag){}//老手
//代碼要精簡易讀
}
}
7，不同類型的範圍
知道byte的取值範圍：
-128 ~ 127
知道一下int的大概範圍：
負21億多 ~ 21億多
預設使用的資料類型：
整數：int
小數：double
字元：char
布爾：boolean
字元串：String
取值範圍由大到小的關系：
double > float > long > int > short > byte （包含了整數和小數）
四類八種在記憶體中所占用的位元組個數：
byte ： 1
short ： 2
int ： 4
long ： 8
float ： 4
double ： 8
char： 2
boolean： 1 //因為隻有兩個值，true，false。是以一般不會考慮布爾類型在記憶體中占用位元組個數。
關于變量的練習1：
public class Test{
public static void main(String [] args){
//大家好，我叫播仔，是傳智播客與黑馬程式員的吉祥物
//今年2歲了，身高1.5米
//愛好比較廣泛（唱、跳、Rap、Java）
//另外，咱是一隻公猴~
//播仔 2 1.5 唱、跳、Rap、Java 公
//定義一個字元串類型的變量去記錄姓名
String a = "播仔";
//定義一個整數類型的變量去記錄年齡
int b = 2;
//定義一個小數類型的變量去記錄身高
double c = 1.5;
//定義一個字元串類型的變量去記錄愛好
String d = "唱、跳、Rap、Java";
//定義一個字元類型的變量去記錄性别
char e = '公';
System.out.println(a);
System.out.println(b);
System.out.println(c);
System.out.println(d);
System.out.println(e);
}
}
關于變量的練習2：
int a = 10；
System.out.println(a);//輸出的是變量a裡面的值10.
a = 30;//此時不是定義。
//而是把30指派給變量a。
//變量a是已經存在的。是以把變量a裡面原來的值覆寫了。因為變量裡面同時隻能存一個值。
System.out.println(a);//再次輸出，就是修改之後值30.
關于變量的練習3：
public class Test {
public static void main(String[] args) {
int a;//定義一個變量叫做a，但是此時變量a裡面沒有值。
System.out.println(a);//變量裡面沒有值，就無法輸出。是以這裡報錯。
{//單獨出現的大括号，表示代碼塊。
//限制了變量的作用範圍。
//變量在定義之後，隻能在所屬的大括号中使用。
int c = 20;
System.out.println(c);
}
c = 30;
System.out.println(c);
}
}
關于變量作用範圍的練習：
public class Test {
public static void main(String[] args) {
int a;//定義在main後面的這個大括号中的。
//是以在main的整個大括号中都有效。
System.out.println(a);
}
}
public class Test {
public static void main(String[] args) {
{//代碼塊。
int c = 20;//變量c此時是定義在裡面的單獨的大括号中的。
//隻能在這個大括号中才能使用。
//超出這個大括号就沒有用了
System.out.println(c);//可以使用c
}
System.out.println(c);//此處已經超出了變量c定義的大括号，是以，此時就無法使用變量c了
//變量c其實在記憶體中就已經消失了。
}
}
public class Test {
public static void main(String[] args) {
{
int c = 20;//定義在裡面的大括号中的。
System.out.println(c);//20
}//到了這一行代碼的時候第一個c，就已經從記憶體中消失了。
//既然記憶體中都沒有c了，那麼我再定義一個行不行？肯定是可以的。
int c = 10;
System.out.println(c);//10
}
}
8，變量的總結注意點：
public class Demo08 {
//類變量 static
static int salary = 3000;
//屬性：變量
//執行個體變量；從屬于對象；如果不自動初始化，這個類型的預設值 0 0.0
//布爾值預設false
//除了基本類型其餘都是null
String name="yuweikang";
int age =20;
//mian方法
public static void main(String[] args) {
//局部變量；必須聲明和初始化值
int i= 10;
System.out.println(i);
//變量類型 變量名字 = new Demo08();
Demo08 demo08 = new Demo08();
System.out.println(demo08.age);
System.out.println(demo08.name);
//類變量 static
System.out.println(salary);
}
//其他方法
public void add(){
}
}
-
變量的作用範圍
隻能在所屬的大括号中有效。代碼運作到目前右大括号時，這個變量就會從記憶體中消失。
- 變量名不允許重複定義
public class Test {
public static void main(String[] args) {
int a = 10;//因為第一個a是定義在main後面的大括号中的，在整個main當中都有效。
int a = 20;//既然第一個a還沒有消失，那麼就不能再定義第二個變量a
}
}
- 變量在使用之前，必須要指派。
- 定義float和long類型的變量時，需要在後面加字尾。
float a = 10.1F;
long b = 100L;
字尾可以大寫也可以小寫，但是個人推薦大寫。
9，辨別符
在代碼中，我們自己起的名字。
類名，變量名，方法名（後面學）。
10，辨別符的硬性規定
我們必須得這麼做，不這麼做，Java就報錯。
- 由數字，字母，下劃線，美元$組成.
- 不能以數字開頭
- 不能是關鍵字
- 區分大小寫的
11，辨別符的軟性建議
如果不這麼幹，程式不會報錯。但是代碼會顯得不專業。
小駝峰命名法:
變量名，方法名：
一個單詞：全部小寫。 比如：name、age、gender
多個單詞：從第二個單詞開始，首字母大寫。 比如：maxAge
大駝峰命名法:
類名：
一個單詞：首字母大寫。 比如：Test
多個單詞：每個單詞首字母都要大寫。 比如：HelloWorld
綜上所述：不管定義什麼東西，都要見名知意。
建議寫英文單詞，如果英文單詞不記得了，那麼可以寫拼音（不建議）或者是查閱有道詞典（建議）。
12，隐式轉換
判斷技巧：
把取值範圍小的，指派給取值範圍大的。
在代碼中的觸發時機：
-
直接指派：
取值範圍小的指派給取值範圍大的。不需要寫代碼額外實作，Java底層幫我們自動搞好。
比如：
第一個:
double d = 10;//此時10預設是int類型，交給取值範圍大的double就ok的。底層自動操作。
第二個：
int i = 10;
double d = i;//i現在為int類型，交給取值範圍大的double是ok的，底層自動操作。
-
不同資料類型參與計算：
小的資料類型會提升為大的，然後再進行計算。這個過程也是底層自動操作的。不需要我們額外寫代碼。
int i = 10;
long b = 100L;
float f = 20.0F;
double d = 100.0;
??? result = i + b + f + d;
//result變量應該是什麼類型？double
//因為在上面的案例中，i,b,f,d當中最大的取值範圍是double。是以最終就會提升為double。
byte，short，int類型的變量，在參與運算的時候，先提升為int，再進行計算。
byte b = 10;
short s = 20;
??? result = b + s;
//result變量應該是什麼類型？int
//取值範圍比int小的，在計算的時候，先提升為int，然後再進行計算。
byte b1 = 10;
byte b2 = 20;
??? result = b1 + b2;
//result變量應該是什麼類型？int
//取值範圍比int小的，在計算的時候，先提升為int，然後再進行計算。
byte b = 10;
short s = 20;
double d = 20.0;
??? result = b + s+ d;
//result變量應該是什麼類型？double
//計算的過程中，發生了什麼事情？
//因為b和s分别為byte和short類型，是以計算的時候先提升為int
//那麼此時就是 int + int + double
//double的取值範圍比int大，是以int需要再次往上提升為double
//最終 double + double + double 結果就是doouble類型。
byte b = 10;
float f = 10.1F;
??? result = b + f;
//result變量應該是什麼類型？float double
float：因為變量b是byte類型的，是以在計算的時候先自動提升為int
然後 int去加上float。又因為float> int。是以，最終是float類
double：等号的右邊最終計算之後，是float類型的，把一個小的給一個大的，是沒有問題的。
核心技巧：
把取值範圍小的，指派給取值範圍大的。是完全木有問題的。
double > float > long > int > short > byte //小數的取值範圍要大于所有的整數。
13，強制轉換
判斷核心技巧 :
把一個取值範圍大的，指派給取值範圍小的。（硬塞）
注意點：有可能會導緻精度的丢失。（數字有可能跟原來的數字不一樣）
在代碼中的觸發時機：
-
直接指派
把一個取值範圍大的變量或者值，指派給一個取值範圍小的變量。
int a = 50;
byte b = a;//此時代碼會報錯，因為把一個大的給一個小的。
//如果一定要這麼幹，請硬塞。
//byte b = (byte)a;//想轉成什麼類型，就在小括号中寫什麼類型就可以了。
int a = 300;
byte b = (byte)a;//大的指派給小的，硬塞。
//有沒有可能會出現什麼問題？
//會出現。因為byte的取值範圍是-128~127.而300已經超出了這個範圍。
//是以此時，代碼編譯和運作的時候不會報錯，但是數字會精度丢失。
//具體結果是什麼，不需要關心，隻要知道精度會丢失即可。
- 在運算的時候。把最終的結果進行指派。
跟上面也是類似的，隻不過是把最終的結果指派給一個變量
byte b1 = 10;
byte b2 = 10;
byte b3 = b1 + b2;//如果操作讓這行代碼不報錯？
//出錯的原因：b1和b2都是byte類型的，在運算的時候會自動提升為int。
//把int指派給byte，肯定報錯了。
//修改方式1：
int b3 = b1 + b2;
//修改方式2：
byte b3 = (byte)(b1 + b2);//把b1和b2的結果進行了強制轉換，變成了byte再進行指派。
//注意點：b1和b2一定要加小括号
byte b3 = (byte)b1 + b2;
//如果不加小括号，那麼就是先把b1強轉成byte，然後再跟b2進行相加。
核心技巧：
把取值範圍大的，指派給取值範圍小的。想要轉成誰，那麼就在小括号中寫誰就可以了。
隻不過強制之後，有可能導緻精度丢失。
14，整數的常量優化機制
byte b = 10; //為什麼沒有報錯。
觸發時機：
等号的右邊都是整數常量的時候。
比如: byte b = 3 +4;
比如:byte b = 100;
判斷技巧：
會看等号右邊最終的結果，是不是在左邊的範圍當中。
如果在，正常指派，不會報錯。
如果不在，就會報錯。
//案例一：
byte b = 100;
因為等号的右邊是整數100，觸發了整數的常量優化機制。
此時會檢查，100是否在byte的取值範圍當中。
發現，在，那麼直接指派不會報錯。
//案例二：
byte b1 = 10;
byte b2 = 20;
byte b3 = b1 + b2;
//此時會不會觸發整數的常量優化機制？不會
//因為此時等号的右邊存在變量。
//隻有等号的右邊都是整數常量的時候才會觸發。
//案例三：
byte b = 3 + 4;
//等号的右邊都是整數常量，是以也會觸發整數的常量優化機制。
//在編譯的時候，已經是最終的結果7了。
//檢查7是否在左邊的範圍當中。
//此時在，那麼就正常，不會報錯。
byte b = 100 + 200;
//報錯的。
//因為最終的結果，300，超出了byte的取值範圍。
15，小結
隐式轉換，整數的常量優化機制，強制轉換的小結：
1）看等号的右邊，如果等号的右邊都是整數常量。那麼就觸發整數的常量優化機制。
2）等号的右邊有小數或者存在變量，那麼就看是什麼資料類型，來決定如何進行提升。（隐式轉換）
如果比int小，先轉成int，然後再算。
如果比int大，就會轉成取值範圍最大的那個。
3）如果我們強制要把大的塞給小的，請使用強制轉換的格式。
16，字元的運算
char c = 'a';
System.out.println(c);//列印字元a
技巧：
字元在什麼時候會去查ASCII碼表。
- 字元參與計算
- 字元指派給整數類型的變量或者指派給小數類型的變量
int i = 1;
char c = 'a';
System.out.println(i + c);//此時字元參與了運算。就需要去查詢在碼表中a字元對應的數字是多少。
int i = 'a';//就會去查閱碼表字元a對應的數字是多少。發現是97，就會把97指派給變量i
System.out.println(i);//97
在ASCII碼表中：
所有的都不需要記。
分享一個技巧：
如果我們要查一個字元對應的數字是多少。不需要記，寫個代碼列印一下就ok了。
![Java小案例——随機數猜測随機數猜測[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)