首先原諒小編的過錯，昨天第二篇文章标題是：
程式員：為什麼選擇Java？
1:關鍵字(掌握)
(1)被Java語言賦予特定含義的單詞
(2)特點：
全部小寫。
(3)注意事項：
A:goto和const作為保留字存在。
B:類似于Notepad++這樣的進階記事本會對關鍵字有特殊顔色标記
/*
關鍵字：被java語言賦予特定含義的單詞。
特點：組成關鍵字單詞的字母全部小寫。
注意：
A:goto和const是保留字
B:類似于Notepad++這樣的進階記事本，針對關鍵字都有特殊的顔色标記。
*/
class KeyWordDemo {
public static void main(String[] args) {
System.out.println("HelloWorld");
}
}
2:辨別符(掌握)
(1)就是給類，接口，方法，變量等起名字的字元序列
(2)組成規則：
A:英文大小寫字母
B:數字
C:$和_
(3)注意事項：
A:不能以數字開頭
B:不能是java中的關鍵字
C:區分大小寫
(4)常見的命名規則(見名知意)
A:包 全部小寫
單級包：小寫
舉例：liuyi,com
多級包：小寫，并用.隔開
舉例：cn.itcast,com.baidu
B:類或者接口
一個單詞：首字母大寫
舉例：Student,Demo
多個單詞：每個單詞首字母大寫
舉例：HelloWorld,StudentName
C:方法或者變量
一個單詞：首字母小寫
舉例：name,main
多個單詞：從第二個單詞開始，每個單詞首字母大寫
舉例：studentAge,showAllNames()
D:常量
全部大寫
一個單詞：大寫
舉例：PI
多個單詞：大寫，并用_隔開
舉例：STUDENT_MAX_AGE
/*
辨別符：就是給類，接口，方法，變量等起名字。
組成規則：
A:英文字母大小寫
B:數字字元
C:$和_
注意事項：
A:不能以數字開頭
B:不能是Java中的關鍵字
C:Java語言嚴格區分大小寫
常見的命名規則：見名知意
舉例：我要定義一個學生類
class Student {}
class S{}
包：其實就是檔案夾，用于把相同的類名進行區分
全部小寫
單級：liuyi
多級：cn.itcast
cn
itcast
類或者接口：
一個單詞：單詞的首字母必須大寫
舉例：Student,Dog
多個單詞：每個單詞的首字母必須大寫
舉例：HelloWorld,StudentName
方法或者變量：
一個單詞：單詞的首字母小寫
舉例：main,age
多個單詞：從第二個單詞開始，每個單詞的首字母大寫
舉例：studentAge,showAllNames()
常量：
一個單詞：全部大寫
舉例：PI
多個單詞：每個字母都大寫，用_隔開
舉例：STUDENT_MAX_AGE
*/
class MakeNameDemo {
public static void main(String[] args) {
//正确做法
int x = 100;
//不能以數字開頭
//int 1y = 100;
int y1 = 100;
//不能是Java中的關鍵字
//int public = 100;
int Public = 100;
}
}
3:注釋(掌握)
(1)就是對程式進行解釋說明的文字
(2)分類：
A:單行注釋 //
B:多行注釋 /**/
C:文檔注釋(後面講) /** */
/*
注釋：用于解釋說明程式的文字
Java中注釋的分類及格式
單行注釋：//
多行注釋：/星 星/
注意：多行不可以嵌套使用，而單行是可以的
文檔注釋：被javadoc工具解析生成一個說明書，面向對象部分講解。
*/
//這是我的注釋案例
class ZhuShiDemo {
//main方法是主方法
//是程式的入口
//被jvm調用
public static void main(String[] args) {
System.out.println("好好學習,天天向上");
}
}
(3)把HelloWorld案例寫了一個帶注釋的版本。
後面我們要寫一個程式的過程。
需求：
分析：
實作：
代碼展現：
/*
需求：我準備寫一個java程式，把"HelloWorld"這句話輸出在控制台
分析：
A:要寫一個Java程式，必須定義類
B:把資料能夠輸出，說明我們的程式是可以獨立運作的，而程式要獨立運作，必須定義main方法
C:把資料輸出在控制台，必須使用輸出語句
實作：
A:java語言提供了一個關鍵字：class用來定義類，後面跟的是類名
B:main方法的格式是固定的：
public static void main(String[] args) {
}
C:輸出語句的格式是固定的：
System.out.println("HelloWorld");
"HelloWorld"這個内容是可以改變的
*/
//這是我的HelloWorld案例
class HelloWorld {
/*
為了程式能夠獨立運作，定義main方法
main方法是程式的入口
被jvm自動調用
*/
public static void main(String[] args) {
//為了把資料顯示在控制台，我們就使用了輸出語句
System.out.println("HelloWorld");
}
}
(4)注釋的作用
A:解釋說明程式，提高了代碼的閱讀性。
B:可以幫助我們調試程式。
後面我們會講解一個更高端的一個調試工具
/*
注釋的作用：
A:解釋說明程式，提高程式的閱讀性
B:可以幫助我們調試程式。
後面我們會講解更進階的調試。
*/
class ZhuShiDemo2 {
public static void main(String[] args) {
System.out.println("林青霞");
System.out.println("王祖賢");
System.out.println("劉亦菲");
System.out.println("範冰冰");
}
}
4:常量(掌握)
(1)在程式執行的過程中，其值不發生改變的量
(2)分類：
A:字面值常量
B:自定義常量(後面講)
(3)字面值常量
A:字元串常量 "hello"
B:整數常量 12,23
C:小數常量 12.345
D:字元常量 'a','A','0'
E:布爾常量 true,false
F:空常量 null(後面講)
(4)在Java中針對整數常量提供了四種表現形式
A:二進制 由0，1組成。以0b開頭。
B:八進制 由0，1，...7組成。以0開頭。
C:十進制 由0，1，...9組成。整數預設是十進制。
D:十六進制 由0，1，...9,a,b,c,d,e,f(大小寫均可)組成。以0x開頭。
/*
常量：
在程式執行過程中，其值不發生改變的量。
分類：
A:字面值常量
B:自定義常量(後面講)
字面值常量
A:字元串常量 用雙引号括起來的内容。
舉例："hello","world","HelloWorld"
B:整數常量 所有的整數
舉例：100,200
C:小數常量 所有的小數
舉例：10.23,110.11
D:字元常量 用單引号括起來的内容
舉例：'a','A','0'
錯誤的：'ab'
E:布爾常量 比較特殊
舉例：true,false
F:空常量 後面講
舉例：null
*/
class ConstantDemo {
public static void main(String[] args) {
//字元串常量的輸出
System.out.println("hello");
//整數常量的輸出
System.out.println(100);
//小數常量的輸出
System.out.println(100.10);
//字元常量的輸出
System.out.println('a');
System.out.println('A');
System.out.println('0');
//這個是有問題的
//System.out.println('ab');
//布爾常量的輸出
System.out.println(true);
System.out.println(false);
}
}
5:進制轉換(了解)
(1)其他進制到十進制
系數：就是每一個位上的數值
基數：x進制的基數就是x
權：對每一個位上的資料，從右，并且從0開始編号，對應的編号就是該資料的權。
結果：系數*基數^權次幂之和。
(2)十進制到其他進制
除基取餘，直到商為0，餘數反轉。
(3)進制轉換的快速轉換法
A:十進制和二進制間的轉換
8421碼。
B:二進制到八進制，十六進制的轉換
/*
不同進制的資料表現：
二進制：由0，1組成。以0b開頭。
八進制：由0,1,...7組成。以0開頭。
十進制：由0,1,...9組成。預設整數是十進制。
十六進制：由0,1,...9,a,b,c,d,e,f(大小寫均可)組成。以0x開頭。
*/
class JinZhiDemo {
public static void main(String[] args) {
System.out.println(100); //十進制
System.out.println(0b100); //二進制
System.out.println(0100); //八進制
System.out.println(0x100); //十六進制
}
}
1：得到下面資料的十進制值：
0b10101
=1*2^4 + 1*2^2 + 1*2^0
=16 + 4 + 1
=21
0123
=1*8^2 + 2*8^1 + 3*8^0
=64 + 16 + 3
=83
0x3c
=3*16^1 + c*16^0
=48 + 12
=60
2：得到下面資料的二進制，十進制，十六進制
52分别得到二進制，十進制，十六進制
得到二進制：
52 / 2 = 26 0
26 / 2 = 13 0
13 / 2 = 6 1
6 / 2 = 3 0
3 / 2 = 1 1
1 / 2 = 0 1
0b110100
得到八進制：
52 / 8 = 6 4
6 / 8 = 0 6
064
得到十六進制：
52 / 16 = 3 4
3 / 16 = 0 3
0x34
3:有符号資料表示法的練習
A:已知某數X的原碼為10110100B，試求X的補碼和反碼。
符号位 數值位
原碼: 1 0110100
反碼： 1 1001011
補碼： 1 1001100
B:已知某數X的補碼11101110B，試求其原碼。
符号位 數值位
補碼： 1 1101110
反碼： 1 1101101
原碼： 1 0010010
6:變量(掌握)
(1)在程式的執行過程中，其值在某個範圍内可以發生改變的量
(2)變量的定義格式：
A:資料類型 變量名 = 初始化值;
B:資料類型 變量名;
變量名 = 初始化值;
/*
使用變量的時候要注意的問題：
A:作用域
變量定義在哪個大括号内，它就在這個大括号内有效。
并且，在同一個大括号内不能同時定義同名的變量。
B:初始化值
沒有初始化值的變量不能直接使用。
你隻要在使用前給值就行，不一定非要在定義的時候立即給值。
推薦在定義的時候給值。
定義變量的格式：
a:資料類型 變量名 = 初始化值;
b:資料類型 變量名;
變量名 = 初始化值;
C:在一行上建議隻定義一個變量
可以定義多個，但是不建議
*/
class DataTypeDemo2 {
public static void main(String[] args) {
//定義變量
int x = 100;
//錯誤，不能有同名的
//int x = 200;
//定義變量必須給值
//int y;
//System.out.println(y);
int z;
z = 100;
System.out.println(z);
//在一行上定義多個變量
//int a = 10; int b = 20; int c = 30;
//上面的寫法可以，但是不建議。
int a = 10;
int b = 20;
int c = 30;
//int d, e;
//d = 40;
//e = 50;
//int f,int g; //錯誤
//int h; int i; //正确
}
}
7:資料類型(掌握)
(1)Java是一種強類型語言，針對每種資料都提供了對應的資料類型。
(2)分類：
A:基本資料類型：4類8種
B:引用資料類型：類，接口，數組。
(3)基本資料類型
A:整數 占用位元組數
byte 1
short 2
int 4
long 8
B:浮點數
float 4
double 8
C:字元
char 2
D:布爾
boolean 1
注意：
整數預設是int類型，浮點數預設是double。
長整數要加L或者l。
單精度的浮點數要加F或者f。
/*
資料類型：Java是一種強類型的語言，針對每一種資料都定義了明确的資料類型。
資料類型分類：
A:基本資料類型
B:引用資料類型(類,接口,數值)
基本資料類型:4類8種
A:整數 占用位元組數
byte 1
short 2
int 4
long 8
B:浮點數
float 4
double 8
C:字元
char 2
D:布爾
boolean 1
注意：
整數預設是int類型
浮點數預設是double類型。
長整型字尾用L或者l标記。建議使用L。
單精度浮點數用F或者f标記。建議使用F。
*/
class DataTypeDemo {
public static void main(String[] args) {
//定義變量的格式：
//資料類型 變量名 = 初始化值;
//定義一個位元組變量
byte b = 10;
System.out.println(10);
System.out.println(b);
//定義一個短整型變量
short s = 100;
System.out.println(s);
//定義一個整型變量
int i = 1000;
System.out.println(i);
//超過了int的範圍
//int j = 1000000000000;
long j = 1000000000000L;
//long j = 100L;
System.out.println(j);
//定義浮點資料變量
float f = 12.345F;
System.out.println(f);
double d = 12.345;
System.out.println(d);
//定義字元變量
char ch = 'a';
System.out.println(ch);
//定義布爾變量
boolean flag = true;
System.out.println(flag);
}
}
8:資料類型轉換(掌握)
(1)boolean類型不參與轉換
(2)預設轉換
A:從小到大
B:byte,short,char -- int -- long -- float -- double
C:byte,short,char之間不互相轉換，直接轉成int類型參與運算。
/*
+是一個運算符(我們等會講解)。做加法運算的。
一般來說，我們在運算的時候，要求參與運算的資料類型必須一緻。
注意：
boolean類型不能轉換為其他的資料類型
預設轉換(從小到大的轉換)
A:byte,short,char—int—long—float—double
B:byte,short,char互相之間不轉換，他們參與運算首先轉換為int類型
*/
class DataTypeDemo3 {
public static void main(String[] args) {
//直接輸出的方式做加法
//System.out.println(3 + 4);
//兩個int類型做加法
int x = 3;
int y = 4;
int z = x + y;
System.out.println(z);
//定義一個byte類型，一個int類型，做加法
byte a = 3;
int b = 4;
System.out.println(a + b);
//可能損失精度
//byte c = a + b;
int c = a + b;
System.out.println(c);
}
}
(3)強制轉換
A:從大到小
B:可能會有精度的損失，一般不建議這樣使用。
C:格式：
目标資料類型 變量名 = (目标資料類型) (被轉換的資料);
/*
強制轉換：
從大的資料類型到小的資料類型。
格式：
目标資料類型 變量 = (目标資料類型) (被轉換的資料);
注意：
不要随意的去使用強制轉換，因為它隐含了精度損失問題。
*/
class DataTypeDemo4 {
public static void main(String[] args) {
byte a = 3;
int b = 4;
//這個肯定沒有問題
//int c = a + b;
//byte c = 7;
//這個是有問題的
//byte c = a + b;
//用強制類型轉換改進
byte c = (byte) (a + b);
System.out.println(c);
}
}
(4)思考題和面試題：
A:下面兩種方式有差別嗎?
float f1 = 12.345f;
float f2 = (float)12.345;
/*
思考題1：請問下面這個有沒有問題
double d = 12.345;
float f = d;
思考題2：看看下面兩個定義有沒有差別呢?
float f1 = (float)12.345;
float f2 = 12.345f;
f1其實是通過一個double類型轉換過來的。
而f2本身就是一個float類型。
*/
class DataTypeDemo5 {
public static void main(String[] args) {
//把double指派給float，加了強制類型轉換
double d = 12.345;
float f = (float)d;
//看看下面兩個定義有沒有差別呢?
float f1 = (float)12.345;
float f2 = 12.345F;
}
}
B:下面的程式有問題嗎，如果有，在哪裡呢?
byte b1 = 3;
byte b2 = 4;
byte b3 = b1 + b2;
byte b4 = 3 + 4;
/*
面試題：
byte b1=3,b2=4,b;
b=b1+b2;
b=3+4;
哪句是編譯失敗的呢？為什麼呢？
b = b1 + b2;是有問題的。
因為變量相加，會首先看類型問題，最終把結果指派的也會考慮類型問題。
常量相加，首先做加法，然後看結果是否在指派的資料類型範圍内，如果不是，才報錯。
*/
class DataTypeDemo6 {
public static void main(String[] args) {
//定義了三個byte類型的變量，b1，b2，b3
//b1的值是3，b2的值是4，b沒有值
byte b1 = 3,b2 = 4,b;
//b = b1 + b2; //這個是類型提升，所有有問題
b = 3 + 4; //常量，先把結果計算出來，然後看是否在byte的範圍内，如果在就不報錯。
}
}
C:下面的操作結果是什麼呢?
byte b = (byte)130;
/*
byte b = 130;有沒有問題?如果我想讓指派正确，可以怎麼做?結果是多少呢?
練習：byte b = (byte)300;
*/
class DataTypeDemo7 {
public static void main(String[] args) {
//因為byte的範圍是：-128到127。
//而130不在此範圍内，是以報錯。
//byte b = 130;
//我們可以使用強制類型轉換
byte b = (byte) 130;
//結果是多少呢?
System.out.println(b);
}
}
/*
分析過程：
我們要想知道結果是什麼，就應該知道是如何進行計算的。
而我們又知道計算機中資料的運算都是補碼進行的。
而要得到補碼，首先要計算出資料的二進制。
A:擷取130這個資料的二進制。
00000000 00000000 00000000 10000010
這是130的原碼，也是反碼，還是補碼。
B:做截取操作，截成byte類型的了。
10000010
這個結果是補碼。
C:已知補碼求原碼。
符号位 數值位
補碼： 1 0000010
反碼： 1 0000001
原碼： 1 1111110
*/
D:字元參與運算
是查找ASCII裡面的值
'a' 97
'A' 65
'0' 48
System.out.println('a');
System.out.println('a' + 1);
/*
看程式寫結果
通過字元和一個整數相加，我們給出一張表：ASCII碼表。
通過看完這張表以後，我們要記住三個值：
'a' 97
'A' 65
'0' 48
*/
class DataTypeDemo8 {
public static void main(String[] args) {
//直接輸出一個字元
System.out.println('a'); //a
//輸出一個字元和一個整數做加法
System.out.println('a'+1); //98
}
}
E:字元串參與運算
這裡其實是字元串的連接配接
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");
/*
看程式寫結果
字元串資料和其他資料做+，結果是字元串類型。
這裡的+不是加法運算，而是字元串連接配接符。
*/
class DataTypeDemo9 {
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
}
}
(1):在定義Long或者Float類型變量的時候，要加L或者f。
整數預設是int類型，浮點數預設是double。
byte，short在定義的時候，他們接收的其實是一個int類型的值。
這個是自己做了一個資料檢測的，如果不再它們的範圍内，就報錯。
(2):byte值的問題
byte b1 = 127;
byte b2 = (byte)128; //-128
byte b3 = (byte)129; //-127
byte b4 = (byte)130; //-126
byte的範圍：-128 ~ 127
128：10000000
-128：10000000 (這裡的1即是符号位，也是數值位)
(3):資料類型轉換之預設轉換
byte,short,char -- int -- long -- float -- double
long: 8個位元組
float：4個位元組
A:它們底層的存儲結構不同。
B:float表示的資料範圍比long的範圍要大
long：2^63-1
float：3.4*10^38 > 2*10^38 > 2*8^38 = 2*2^3^38 = 2*2^114 > 2^63-1
( 4):Java語言中的字元char可以存儲一個中文漢字嗎?為什麼呢?
可以。因為java語言中的字元占用兩個位元組。
Java語言采用的是Unicode編碼。
懂得分享才能學好Java，
Java開源有你的一份力量
你有好的資源可以分享給我；
記得寫上你的名字，發表時會署名
