# **注釋**
  平時我們編寫代碼,在代碼量比較少的時候,我們還可以看懂自己寫的,但是當項目結構一旦復雜起 ????來,我們就需要用到一個注釋了,注釋就類似于我們上學時候寫的筆記,我們看著筆記就知道自己寫的 ?什么東西了!在程序中也是如此。我們來看一下Java中的注釋怎么寫,看以下代碼:
```
/*
*@Description HelloWorld類
*@Author zhangsan
**/
public class HelloWorld {
/*
這是我們Java程序的主入口
main方法也是程序的主線程。
*/
public static void main(String\[\] args) {
// 輸 出 HelloWorld!
System.out.println("Hello,World!");
}
}
```
  注釋并不會被執行,是給我們寫代碼的人看的,書寫注釋是一個非常好的習慣,在很多大公司都是強制 ?要求各位去進行編寫注釋!比如,我們的BAT三大巨頭等等。。。
Java中的注釋有三種:
單行注釋:只能注釋當前行,以//開始,直到行結束
```
//輸出HelloWorld!
```
多行注釋:注釋一段文字,以/開始, /結束!
```
/*
這是我們Java程序的主入口
main方法也是程序的主線程。
*/
```
文檔注釋:用于生產API文檔,配合JavaDoc。
>[info]【注】文檔注釋我們現在只作為了解,在學習JavaDoc時候我們會詳細給大家說,目前知道有這樣的注釋就好。
```
/*
* @Description HelloWorld類
* @Author zhangsan
**/
```
>[success]【建議】平時寫代碼一定要注意注釋的規范性,一個好的程序員,一定是有非常良好的編碼習慣 ?的,我希望大家能夠從小事開始鍛煉自己的行為習慣!
# **標識符**
  每個人從出生開始就有一個名字,咋們生活中的所有事物也都有名字,這名字是誰規定呢?回答是:造物主,誰生產出來的誰規定名字,在我們的程序中也不例外。
  我們作為造物主,需要給所有的東西給上一個名字,比如我們的HelloWorld程序:
  HelloWorld是類名,也是我們的文件名。它前面的 public class是關鍵字,不過是搞Java那群人已經定義好的有特殊作用的,下面的每一個代碼都有自己的意思和名字對吧,就是用來作區分!和我們的名字一樣,拿來被叫或者稱呼的,程序一切都源自于生活,一定要把學程序和生活中的一切聯系起來,你會 ?發現這一切都是息息相關的。

  我們來看看有哪些是Java自己定義好的**關鍵字**呢?

  這些看起來非常的多,但是隨著我們以后的學習我們都會用到,所以完全不用擔心自己 看不懂,這些被
  Java已經規定的關鍵字,我們自己就不能拿它當做名字了!
  Java 所有的組成部分都需要名字。類名、變量名以及方法名都被稱為標識符。我們自己起名字有哪些要求呢?
  表示類名的標識符用大寫字母開始。
>[info]如:Man,Teacher,Student,GoodMan,Book
  表示方法和變量的標識符用小寫字母開始,后面的描述性詞以大寫開始。
>[info]如:eat( ),eatFood( ), getName( ),setName( ) //駝峰命名法
#### **關于** **Java** **標識符,有以下幾點需要注意:**
* 所有的標識符都應該以字母(A-Z 或者 a-z),美元符($)、或者下劃線(_)開始
* 首字符之后可以是字母(A-Z 或者 a-z),美元符($)、下劃線(\_)或數字的任何字符組合不能使用關鍵字作為變量名或方法名。
* 標識符是大小寫敏感的
* 合法標識符舉例:age、$salary、\_value、1\_value
* 非法標識符舉例:123abc、\-salary、#abc
【 ??JAVA不采用通常語言使用的ASCII字符集,而是采用unicode這樣的標準的國際字符集。因此,這里的字母的含義:可以表示英文、漢字等等。】
【可以使用中文命名,但是一般不建議這樣去使用,也不建議使用拼音,很Low】
```
public static void main(String[ ] args) {
String 王者榮耀 = "最強王者";
System.out.println(王者榮耀);
}
```
**課外擴展**:[各種字符集和編碼詳解](http://cms.yiniuedu.com/javastudy/2423775)
**演示**:合法標識符以及不合法標識符
# **數據類型**
Java是一種**強類型語言**,每個變量都必須聲明其類型。
## **1** **、強弱類型語言**
  說到強類型語言,那什么是強類型語言呢?
  **強類型語言**也稱為強類型定義語言。要求變量的使用要嚴格符合規定,所有變量都必須先定義后才能使 ?用。
  Java、.NET、C++等都是強制類型定義的。也就是說,一旦一個變量被指定了某個數據類型,如果 ??不經過轉換,那么它就永遠是這個數據類型了。
  安全性高,運行效率相對較慢,魚和熊掌不可兼得!強類型定義語言在速度上可能略遜色于弱類型定義 ?語言,但是強類型定義語言帶來的嚴謹性能夠有效的避免許多錯誤。
  與其相對應的是弱類型語言。
  **弱類型語言**也稱為弱類型定義語言。與強類型定義相反。像vb,php等就屬于弱類型語言·
  在VBScript中,可以將字符串‘12’和整數3進行連接得到字符串‘123’,也可以把它看成整數123,而不需 ??要顯示轉換。是不是十分的隨便,我們Java就不是這樣的。
  但其實它們的類型沒有改變,VB只是在判斷出一個表達式含有不同類型的變量之后,自動在這些變量前加了一個clong()或(int)()這樣的轉換函數而已。能做到這一點其實是歸功于VB的編譯器的智能化而已,這并非是VB語言本身的長處或短處。
  好了,到這里,我們應該對強弱類型語言有了一定的了解!我們繼續回到數據類型這個話題.
## **2** **、數據類型**
  Java的數據類型分為兩大類:基本類型(primitive type)和引用類型 (reference type)

【注:引用數據類型的大小統一為4個字節,記錄的是其引用對象的地址!】

如果你看到這一堆頭疼的話,沒關系,不用記,JDK中類型對應的包裝類都幫忙寫好了,我們需要時候可以直接看到!可以把以下代碼拷貝進行查看結果:
```
public static void main(String[ ] args) {
// byte
System.out.println("基本類型:byte 二進制位數:" + Byte.SIZE);
System.out.println("包裝類:java.lang.Byte");
System.out.println("最小值:Byte.MIN_VALUE=" + Byte.MIN_VALUE);
System.out.println("最大值:Byte.MAX_VALUE=" + Byte.MAX_VALUE);
System.out.println();
// short
System.out.println("基本類型:short 二進制位數:" + Short.SIZE);
System.out.println("包裝類:java.lang.Short");
System.out.println("最小值:Short.MIN_VALUE=" + Short.MIN_VALUE);
System.out.println("最大值:Short.MAX_VALUE=" + Short.MAX_VALUE);
System.out.println();
// int
System.out.println("基本類型:int 二進制位數:" + Integer.SIZE);
System.out.println("包裝類:java.lang.Integer");
System.out.println("最小值:Integer.MIN_VALUE=" + Integer.MIN_VALUE);
System.out.println("最大值:Integer.MAX_VALUE=" + Integer.MAX_VALUE);
System.out.println();
// long
System.out.println("基本類型:long 二進制位數:" + Long.SIZE);
System.out.println("包裝類:java.lang.Long");
System.out.println("最小值:Long.MIN\_VALUE=" + Long.MIN_VALUE);
System.out.println("最大值:Long.MAX\_VALUE=" + Long.MAX_VALUE);
System.out.println();
// float
System.out.println("基本類型:float 二進制位數:" + Float.SIZE);
System.out.println("包裝類:java.lang.Float");
System.out.println("最小值:Float.MIN_VALUE=" + Float.MIN_VALUE);
System.out.println("最大值:Float.MAX_VALUE=" + Float.MAX_VALUE);
System.out.println();
// double
System.out.println("基本類型:double 二進制位數:" + Double.SIZE);
System.out.println("包裝類:java.lang.Double");
System.out.println("最小值:Double.MIN_VALUE=" + Double.MIN_VALUE);
System.out.println("最大值:Double.MAX_VALUE=" + Double.MAX_VALUE);
System.out.println();
// char
System.out.println("基本類型:char 二進制位數:" + Character.SIZE);
System.out.println("包裝類:java.lang.Character");
// 以數值形式而不是字符形式將Character.MIN_VALUE輸出到控制臺
System.out.println("最小值:Character.MIN_VALUE="
+ (int) Character.MIN_VALUE);
// 以數值形式而不是字符形式將Character.MAX_VALUE輸出到控制臺
System.out.println("最大值:Character.MAX_VALUE="
+ (int) Character.MAX_VALUE);
}
```
如果你是熱愛學習的人,你現在應該非常想知道這字節到底是什么東西,所以我給大家科普一下相關知識:
```
/*
位(bit):是計算機 內部數據 儲存的最小單位,11001100是一個八位二進制數。
字節(byte):是計算機中 數據處理 的基本單位,習慣上用大寫 B 來表示,
1B(byte,字節)= 8bit(位)
字符:是指計算機中使用的字母、數字、字和符號
ASCIIS碼:
1個英文字母(不分大小寫)= 1個字節的空間
1個中文漢字 = 2個字節的空間
1個ASCII碼 = 一個字節
UTF-8編碼:
1個英文字符 = 1個字節
英文標點 = 1個字節
1個中文(含繁體) = 3個字節
中文標點 = 3個字節
Unicode編碼:
1個英文字符 = 2個字節
英文標點 = 2個字節
1個中文(含繁體) = 2個字節
中文標點 = 2個字節
1bit表示1位,
1Byte表示一個字節 1B=8b。
1024B=1KB
1024KB=1M
1024M=1G.
```
那有人會問:電腦的32位和64位的區別是什么呢?
```
/*
32位操作系統只可以使用32位的cpu
而64位的CPU既可以安裝32位操作系統也可以安裝64位操作系統。
尋址能力簡單點說就是支持的內存大小能力
64位系統最多可以支達128 GB的內存
而32位系統最多只可以支持4G內存。
32位操作系統只可以安裝使用32位架構設計的軟件
而64位的CPU既可以安裝使用32位軟件也可以安裝使用64位軟件。
現在的電腦都是64位了!
*/
```
【好了,回到正題,我們了解了這些知識后,我們自己定義一些**變量**來看!】
```
public static void main(String[] args) {
//整型
int i1=100;
//長整型
long i2 =998877665544332211L;
//短整型
short i3 =235;
//浮點型
double d1 =3.5; //雙精度
double d2 =3;
float f1 = (float)3.5; //單精度
float f2 =3.5f; //單精度
//布爾類型 boolean true真/false假
boolean isPass =true;
boolean isOk =false;
boolean isBig = 5 > 8;
if(isPass){
System.out.println("通過了");
}else{
System.out.println("未通過");
}
//單字符
char f ='女';
char m ='男';
}
```
【Java語言的整型常數默認為int型,浮點數默認是Double】
## **3** **、整型拓展**
在我們計算機中存在很多進制問題,十進制,八進制,十六進制等等的問題,他們怎么表示呢?
1. 十進制整數,如:99,-500, 0。
2. 八進制整數,要求以 0開頭,如:015。
3. 十六進制數,要求 0x或 0X 開頭,如:0x15。
演示:
```
//整型
int i =10;
int i2 =010;
int i3 =0x10;
System.out.println(i); //10
System.out.println(i2); //8
System.out.println(i3); //16
```
## **4** **、浮點型拓展**
【金融面試問:銀行金融業務用什么類型表示?】
浮點類型?oat, double的數據不適合在不容許舍入誤差的金融計算領域。如果需要進行不產生舍入誤差的精確數字計算,需要使用**BigDecimal**類。
```
public static void main(String[ ] args) {
float f = 0.1f;
double d = 1.0/10;
System.out.println(f==d); //false
float d1 = 2131231231f;
float d2 = d1+1;
if(d1==d2){
System.out.println("d1==d2");
}else{
System.out.println("d1!=d2");
}
}
```
主要理由:
由于字長有限,浮點數能夠精確表示的數是有限的,因而也是離散的。浮點數一般都存在舍入誤差,很 多數字無法精確表示,其結果只能是接近,但不等于;二進制浮點數不能精確的表示0.1,0.01,0.001這樣10的負次冪。并不是所有的小數都能可以精確的用二進制浮點數表示。
#### **最好完全避免使用浮點數比較** **!**
**大數**值:Java.math下面的兩個有用的類:BigInteger和BigDecimal,這兩個類可以處理任意長度的數值。BigInteger實現了任意精度的整數運算。BigDecimal實現了任意精度的浮點運算。
#### **浮點數使用總結:**
1.默認是double
2.浮點數存在舍入誤差,很多數字不能精確表示。
如果需要進行不產生舍入誤差的精確數字計算,需要使用BigDecimal類。
3.避免比較中使用浮點數
## **5** **、字符型拓展**
單引號用來表示字符常量。例如‘A’是一個字符,它與“A”是不同的,“A”表示一個字符串。
char 類型用來表示在Unicode編碼表中的字符。.
Unicode編碼被設計用來處理各種語言的所有文字,它占2個字節,可允許有65536個字符;
【科普:2字節=16位 2的16次方=65536,我們用的Excel原來就只有這么多行,并不是無限的】
【代碼演示:字符轉int看結果】
```
public static void main(String[] args) {
char c1 = 'a';
char c2 = '中';
System.out.println(c1);
System.out.println((int) c1);//976
System.out.println(c2);
System.out.println((int) c2);//20013
}
```
Unicode具有從0到65535之間的編碼,他們通常用從’u0000’到’uFFFF’之間的十六進制值來表示(前綴為 ?u表示Unicode)
```
char c3 = '\u0061';
System.out.println(c3);//a
```
Java 語言中還允許使用轉義字符 ‘’ 來將其后的字符轉變為其它的含義,有如下常用轉義字符:

【以后我們學的String類,其實是字符序列(char sequence)。在這里給大家一個思考題】
```
//代碼1
String sa=new String("Hello world");
String sb=new String("Hello world");
System.out.println(sa==sb); //false
//代碼2
String sc="Hello world";
String sd="Hello world";
System.out.println(sc==sd); //true
```
大家可以先思考下為什么,之后我們學到對象的時候,會給大家進行內存級別的分析,那時候你會恍然 ?大悟!
## **6** **、布爾型拓展**
boolean類型(一位,不是一個字節),就是0|1
boolean類型有兩個值,true和false,不可以 0 或非 0 的整數替代 true 和 false ,這點和C語言不同。
boolean 類型用來判斷邏輯條件,一般用于程序流程控制。
```
boolean flag = false;
if(flag){
// true分支
}else{
// false分支
}
```
【編碼規范:很多新手程序員喜歡這樣寫】
```
if(is == true && un == false){...}
```
只有新手才那么寫。對于一個熟練的人來說,應該用如下方式來表示:
```
if( i s&& !un){....}
```
這點都不難理解吧。所以要習慣去掉所有的\==fasle 和 \==true。Less is More!! 代碼要精簡易讀!
# **類型轉換**
由于Java是強類型語言,所以要進行有些運算的時候的,需要用到類型轉換。整型、實型(常量)、字符型數據可以混合運算。
運算中,不同類型的數據先轉化為同一類型,然后進行運算。轉換從低級到高級(根據容量來看)。
低 ---------------------------------------->高
byte,short,char-> int->long->float->double
數據類型轉換必須滿足如下規則:
* 不能對boolean類型進行類型轉換。
* 不能把對象類型轉換成不相關類的對象。
* 在把容量大的類型轉換為容量小的類型時必須使用強制類型轉換。
* 轉換過程中可能導致溢出或損失精度,例如:
```
int i =128;
byte b = (byte)i;
```
因為 byte類型是 8位,最大值為127,所以當 int強制轉換為 byte類型時,值 128時候就會導致溢出。
* 浮點數到整數的轉換是通過舍棄小數得到,而不是四舍五入,例如:
```
(int)23.7 ==23;
(int)-45.89f== -45;
```
## **1** ~~~~**、自動類型轉換**
自動類型轉換:容量小的數據類型可以自動轉換為容量大的數據類型。
例如: short數據類型的位數為16位,就可以自動轉換位數為32的int類型,同樣?oat數據類型的位數為32,可以自動轉換為64位的double類型。
【演示】
```
public class ZiDongLeiZhuan{
public static void main(String[ ] args){
char c1 ='a';//定義一個char類型
int i1 = c1;//char自動類型轉換為int
System.out.println("char自動類型轉換為int后的值等于"+i1);
char c2 = 'A';//定義一個char類型
int i2 = c2+1;//char 類型和 int 類型計算
System.out.println("char類型和int計算后的值等于"+i2);
}
}
```
【 **解析:** c1 的值為字符 **a** ,查 ASCII 碼表可知對應的 int 類型值為 97, A 對應值為 65,所以**i2=65+1=66**。】
## **2** **、強制類型轉換**
強制類型轉換,又被稱為造型,用于顯式的轉換一個數值的類型.
在有可能丟失信息的情況下進行的轉換是通過造型來完成的,但可能造成精度降低或溢出。
強制類型轉換的語法格式: ,運算符“()”中的type表示將值var想要轉換成的目標數據類型。 條件是轉換的數據類型必須是兼容的。
【演示】
```
public static void main(String[] args) {
double x = 3.14;
int nx = (int)x; //值為3
char c = 'a';
int d = c+1;
System.out.println(d); //98
System.out.println((char)d); //b
}
```
當將一種類型強制轉換成另一種類型,而又超出了目標類型的表示范圍,就會被截斷成為一個完全不同的值,溢出。
```
public static void main(String[ ] args) {
int x = 300;
byte bx = (byte)x; //值為44
System.out.println(bx);
}
```
## **3** **、常見錯誤和問題**
1.操作比較大的數時,要留意是否溢出,尤其是整數操作時;
2.L和l的問題:
* 不要命名名字為l的變量
* long類型使用大寫L不要用小寫。
```
1public static void main(String[] args) {
int l = 2;
long a = 23451l;
;System.out.println(l+1); //3
System.out.println(a); //23451
}
```
## **4** **、****JDK7****擴展**
#### **JDK7** **新特性** **:** **二進制整數**
由于我們在開發中也經常使用二進制整數,因此JDK7為我們直接提供了二進制整數的類型。我們只要以:0b開頭即可。
```
inta=0b0101:
```
#### **JDK7** **新特性:下劃線分隔符**
在實際開發和學習中,如果遇到特別長的數字,讀懂它令人頭疼!JDK7為我們提供了下劃線分隔符,可以按照自己的習慣進行分割。
```
intb=1_2234_5678;
```
我們很容易就知道這是1億2234萬5678啦! 非常符合國人的習慣!
```
public static void main(String[] args) {
int a = 0b0101;
int b = 1_2345_7893;
System.out.println(a); //5
System.out.println(b); //123457893
}
```
# **變量,常量**
## **1** **、變量(****variable****)**
變量是什么:就是可以變化的量!
我們通過變量來操縱存儲空間中的數據,變量就是指代這個存儲空間!空間位置是確定的,但是里面放 ?置什么值不確定! 打個比方:
這就好像我們家里有一個大衣柜,里面有十分多的小格子,我們給格子上貼上標簽,放衣服,放鞋子, ?放手表等等,此時我們知道了哪里該放什么,但是,我們并不知道里面到底放的是什么牌子的鞋子,是 ?衣服還是褲子。那個標簽就相當于我們的變量,我們給他起了個名字,但是里面要放什么需要我們自己 ?去放。
Java是一種強類型語言,每個變量都必須聲明其類型。
Java變量是程序中最基本的存儲單元,其要素包括變量名,變量類型和作用域。
變量在使用前必須對其聲明, 只有在變量聲明以后,才能為其分配相應長度的存儲單元,聲明格式為:
```
type varName [=value] [{,varName[=value]}] ;
//數據類型 變量名 = 值;可以使用逗號隔開來聲明多個同類型變量。
```
注意事項:
* 每個變量都有類型,類型可以是基本類型,也可以是引用類型。
* 變量名必須是合法的標識符。
* 變量聲明是一條完整的語句,因此每一個聲明都必須以分號結束
【演示】
```
int a, b, c; //聲明三個int型整數:a、 b、c
int d = 3, e = 4, f = 5; // 聲明三個整數并賦予初值
byte z = 22; // 聲明并初始化 z
String s = "yiniuedu"; // 聲明并初始化字符串 s
double pi = 3.14159; // 聲明了雙精度浮點型變量 pi
char x= 'x'; //聲明變量 x的值是字符 'x'。
```
【編碼規范】
雖然可以在一行聲明多個變量,但是不提倡這個風格,逐一聲明每一個變量可以提高程序可讀性。
## **2** **、變量作用域**
變量根據作用域可劃分為三種:
1. 類變量(靜態變量: static variable):獨立于方法之外的變量,用 static 修飾。
2. 實例變量(成員變量:member variable):獨立于方法之外的變量,不過沒有 static ?修飾。
3. 局部變量(lacal variable):類的方法中的變量。
```
public class Variable{
static int allClicks=0; //類變量
String str="hello world"; // 實例變量
public void method(){
int =0; //局部變量
}
}
```
### **局部變量**
方法或語句塊內部定義的變量。生命周期是從聲明位置開始到”}”為止。在使用前必須先聲明和初始化(賦初值)。
局部變量沒有默認值,所以局部變量被聲明后,必須經過初始化,才可以使用。
```
public static void main(String[ ] args) {
int i;
int j = i+5 ; // 編譯出錯,變量i還未被初始化
System.out.println(j);
}
```
修改為:
```
public static void main(String[ ] args) {
int i = 10;
int j = i+5 ; // 編譯出錯,變量i還未被初始化
System.out.println(j);
}
```
### **實例變量**
方法外部、類的內部定義的變量。
從屬于對象,生命周期伴隨對象始終。
如果不自行初始化,他會自動初始化成該類型的默認初始值
(數值型變量初始化成0或0.0,字符型變量的初始化值是16位的0,布爾型默認是false)
```
public class Test {
// 這個實例變量對子類可見
public String name;
// 私有變量,僅在該類可見
private double salary;
...
}
```
### **靜態變量**
使用static定義。
從屬于類,生命周期伴隨類始終,從類加載到卸載。
(注:講完內存分析后我們再深入!先放一放這個概念!)
如果不自行初始化,他會自動初始化成該類型的默認初始值
(數值型變量初始化成0或0.0,字符型變量的初始化值是16位的0,布爾型默認是false)
```
public class Employee {
//salary是靜態的私有變量
private static double salary;
// DEPARTMENT是一個常量
public static final String DEPARTMENT = "開發人員";
public static void main(String[ ] args){
salary = 10000;
System.out.println(DEPARTMENT+"平均工資:"+salary);
}
}
```
## **3** **、常量**
常量(Constant):初始化(initialize)后不能再改變值!不會變動的值。
所謂常量可以理解成一種特殊的變量,它的值被設定后,在程序運行過程中不允許被改變。
```
final常量名=值;
final double PI=3.14;
final String LOVE = "hello";
```
常量名一般使用大寫字符。
程序中使用常量可以提高代碼的可維護性。例如,在項目開發時,我們需要指定用戶的性別,此時可以 ?定義一個常量 SEX,賦值為 "男",在需要指定用戶性別的地方直接調用此常量即可,避免了由于用戶的不規范賦值導致程序出錯的情況。
## **4** **、變量的命名規范**
1.所有變量、方法、類名:見名知意
2.類成員變量:首字母小寫和駝峰原則 : monthSalary
3.局部變量:首字母小寫和駝峰原則
4.常量:大寫字母和下劃線:MAX\_VALUE
5.類名:首字母大寫和駝峰原則: Man,GoodMan
6.方法名:首字母小寫和駝峰原則: run(),runRun()
# **運算符**
#### **運算符** **operator**
**Java** **語言支持如下運算符:**
* 算術運算符: +,-,*,/,%,++,--
* 賦值運算符 =
* 關系運算符: >,=,<=,==,!= instanceof
* 邏輯運算符:&&,||,!
* 位運算符:&,|,^,~,>>,>>>(了解!!!)
* 條件運算符 ?:
* 擴展賦值運算符:+=,-=,*=,/=
**1** **、二元運算符**
兩個操作數,來看看我們小時候的數學運算;
```
public static void main(String[] args){
int a = 10;
int b = 20;
int c = 25;
int d = 25;
;System.out.println("a+b=" +(a+b));
System.out.println("a-b=" +(a-b));
System.out.println("a*b=" +(a*b));
System.out.println("b/a=" +(b/a));
}
```
#### **整數運算**
如果兩個操作數有一個為Long, 則結果也為long
沒有long時,結果為int。即使操作數全為shot,byte,結果也是int.
```
public static void main(String[] args) {
long a = 1231321311231231L;
int b = 1213;
short c = 10;5
byte d = 8;
System.out.println((a+b+c+d)); //Long類型
System.out.println((b + c + d));//Int類型
System.out.println((c + d));//Int類型
}
```
#### **浮點運算**
如果兩個操作數有一個為double, 則結果為double. 只有兩個操作數都是?oat, 則結果才為?oat.
```
public static void main(String[] args) {
float a = 3.14565F;
double b = 3.194546464;
float c = 1.3123123F;
System.out.println(a+b); //double類型
System.out.println(b+c); //double類型
System.out.println(a+c); //float類型
}
```
#### **關系運算符**
返回布爾值!

## **2** **、取模運算**
就是我們小學的取余;5%3 余 2
其操作數可以為浮點數,一般使用整數。如:5.9%3.9=2.000000004
**要點**:
負數%負數=負數; 負數%正數=負數; 正數%負數=正數;
```
public static void main(String[] args) {
System.out.println(9 % 4); //1
System.out.println(-9 % -4); //-1
System.out.println(-10 % 4); //-2
System.out.println(9 % -4); //1
}
```
【注:一般都是正整數運算,進行結果的判斷!】
## **3** **、一元運算符**
**自增(****++****)自減(****\--****)運算符**是一種特殊的算術運算符,在算術運算符中需要兩個操作數來進行運算, ?而自增自減運算符是一個操作數,分為前綴和后綴兩種。
```
public static voidmain(String[] args) {
int a = 3;
int b = a++;//執行完后,b=3。先給b賦值,再自增。
int c = ++a;//執行完后,c=5。先自增,再給b賦值
}
```
#### **注意:** **java** **中的乘冪處理**
```
public static void main(String[] args) {
int a = 3^2; //java中不能這么處理, ^是異或符號。
double b = Math.pow(3, 2);
}
```
Math類提供了很多科學和工程計算需要的方法和常數。特殊的運算都需要運用到方法!
## **4** **、邏輯運算符**
邏輯與:&&和&,邏輯或:||和|,邏輯非:!。

【演示】
```
public static void main(String[] args) {
boolean a = true;
boolean b = false;
System.out.println("a && b = " + (a&&b));
System.out.println("a || b = " + (a||b) );
System.out.println("!(a && b) = " + !(a && b));
}
```
邏輯與和邏輯或采用**短路的方式**。從左到右計算,如果確定值則不會再計算下去。在兩個操作數都為 ?true時,結果才為true,但是當得到第一個操作為false時,其結果就必定是false,這時候就不會再判斷 ??????第二個操作了。
邏輯與只要有一個為false, 則直接返回false. 邏輯或只要有一個為true, 則直接返回true;
【演示】
```
public static void main(String[] args){
int a = 5;//定義一個變量;
boolean b = ( a<4)&&(a++<10);
System.out.println("使用短路邏輯運算符的結果為"+b);
System.out.println("a的結果為"+a);
}
```
**解析:** 該程序使用到了短路邏輯運算符*(&&)*,首先判斷 *a<4* 的結果為 *false*,則 *b* 的結果必定是 *false*, 所以不再執行第二個操作 *a++<10* 的判斷,所以 *a* 的值為 *5*。
## **5** **、位運算符**
Java定義了位運算符,應用于整數類型(int),長整型(long),短整型(short),字符型(char),和字節型(byte)等類型。位運算符作用在所有的位上,并且按位運算。
```
A =0011 1100
B =0000 1101
A & B = 0000 1100
A | B = 0011 1101
A ^ B = 0011 0001
~A =1100 0011
```

右移一位相當于除2取商。
左移一位相當于乘2。
【常見面試題:int a=2\*8怎樣運算效率最快?】
#### **解析:**
```
public static void main(String[] args) {
System.out.println(2 << 3);
}
```
用移位運算 int a=2<<3;
a就是2乘以8 最后結果是16 這是最省內存 最有效率的方法
這個方法確實高效率的。我來解釋一下:
2的二進制是10 在32位存儲器里面是0000 0000 0000 0010
左移三位后變成 0000 0000 0001 0000 也就是16
解釋一下,在系統中運算是以二進制的形式進行的。相比來說倆個二進制數相乘運算比移位運算慢一 ?些。
位操作是程序設計中對位模式按位或二進制數的一元和二元操作。 在許多古老的微處理器上, 位運算比加減運算略快, 通常位運算比乘除法運算要快很多。 在現代架構中, 情況并非如此:位運算的運算速度通常與加法運算相同(仍然快于乘法運算). **詳細的需要了解計算機的組成原理!**
## **6** **、擴展運算符**

```
public static void main(String[] args) {
int a=10;
int b=20;
a+=b; // a = a + b
System.out.println(a+":"+b);
}
```
**7** **、字符串連接符**
“+” 運算符兩側的操作數中**只要有一個是字符串**(String)類型,系統會自動將另一個操作數轉換為字符串然后再進行連接。
```
//字符串
String s1="Hello 中文!";
String s2=1+""; //轉換成String
//int
int c = 12;
System.out.println("c=" + c);
```
## **8****、三目條件運算符**
三目條件運算符,語法格式:x ? y : z
其中x為boolean類型表達式,先計算x的值,若為true,則整個三目運算的結果為表達式y的值,否則整個運算結果為表達式z的值。
【演示】
```
public static void main(String[] args) {
int score = 80;
String type = score < 60 ? "不及格" : "及格";
System.out.println("type= " + type);
}
```
三元運算符在真實開發中十分的常見,大家可以多練習使用,之后我們會講解分支語句,可以利用三元 ?運算符做到更加精簡代碼!便于理解!
## **9** **、運算符優先級**
我們小學都學過:先加減,后乘除,所以優先級我們并不陌生。
當多個運算符出現在一個表達式中,誰先誰后呢?這就涉及到運算符的優先級別的問題。在一個多運算 ?符的表達式中,運算符優先級不同會導致最后得出的結果差別甚大。
下表中具有最高優先級的運算符在的表的最上面,最低優先級的在表的底部。

大家不需要去刻意的記住,表達式里面優先使用小括號來組織!!方便理解和使用,不建議寫非常冗余 的代碼運算!
```
public static void main(String[] args) {
boolean flag = 1<4*5&&122>3||'q'+3<5;
System.out.println(flag);
}
```
# **包機制**
## **1** **、問題發現**
存在這樣一個問題:當定義了多個類的時候,可能會發生類名的重復問題。解決方式:在java中采用包機制處理開發者定義的類名沖突問題。
就好比我們平時的用電腦,一個文件夾下不能存在同名的文件,我們要是有這樣的需求,但是又不想換 ?名字,我們就可以考慮使用新建一個文件夾來存放!在我們的Java中也是這樣的。
【演示:重名文件】
還有一個問題:我們平時在IDE中可以跑的文件,用命令行就會報錯;
【演示:HelloWorld!IDE和命令行】
這是為什么呢?
罪魁禍首正是代碼第一行:package com.yiniuedu.demo01;
這就是Java中的包機制,使用package com.yiniuedu.demo01;
就要求此份.java文件必須保存在這樣一個目錄下,這樣Java解釋器才能找到它。 ???在IDEA中能正確運行, 你可以去Windows下的工程中查看,HelloWorld這個文件必是在這樣的目錄結構下的。
## **2** **、包的作用**
為了更好地組織類,Java 提供了包機制,用于區別類名的命名空間。
#### **包的作用:**
1、把功能相似或相關的類或接口組織在同一個包中,方便類的查找和使用。
2、如同文件夾一樣,包也采用了樹形目錄的存儲方式。同一個包中的類名字是不同的,不同的包中的類 ?的名字是可以相同的,當同時調用兩個不同包中相同類名的類時,應該加上包名加以區別。因此,包可 ??以避免名字沖突。
3、包也限定了訪問權限,擁有包訪問權限的類才能訪問某個包中的類。
Java ?使用包(package)這種機制是為了防止命名沖突,訪問控制,提供搜索和定位類(class)、接口、枚舉(enumerations)和注釋(annotation)等。
包語句的語法格式為:
```
package pkg1[. pkg2[. pkg3...]];
```
例如,一個Something.java 文件它的內容:
```
package net.java.util;
public class Somethings{
...
}
```
那么它的路徑應該是 **net/java/util/Something.java** 這樣保存的。 package(包) 的作用是把不同的
java 程序分類保存,更方便的被其他 java 程序調用。
一個包(package)可以定義為一組相互聯系的類型(類、接口、枚舉和注釋),為這些類型提供訪問保護和命名空間管理的功能。
以下是一些 Java 中的包:
* **java.lang**\-打包基礎的類
* **java.io**\-包含輸入輸出功能的函數
開發者可以自己把一組類和接口等打包,并定義自己的包。而且在實際開發中這樣做是值得提倡的,當 ?你自己完成類的實現之后,將相關的類分組,可以讓其他的編程者更容易地確定哪些類、接口、枚舉和 ?注釋等是相關的。
由于包創建了新的命名空間(namespace),所以不會跟其他包中的任何名字產生命名沖突。使用包這種機制,更容易實現訪問控制,并且讓定位相關類更加簡單。
## **3** **、創建包**
創建包的時候,你需要為這個包取一個合適的名字。之后,如果其他的一個源文件包含了這個包提供的 ?類、接口、枚舉或者注釋類型的時候,都必須將這個包的聲明放在這個源文件的開頭。
包聲明應該在源文件的第一行,每個源文件只能有一個包聲明,這個文件中的每個類型都應用于它。 ?如果一個源文件中沒有使用包聲明,那么其中的類,函數,枚舉,注釋等將被放在一個無名的包
(unnamed package)中。
一般利用公司域名倒置作為報名; 例子:
[www.baidu.com](http://www.baidu.com/)包名:com.baidu.www
bbs.baidu.com 包名:com.baidu.bbs
blog.baidu.com 包名:com.baidu.blog
我們平時也可以按照自己的公司域名去寫,比如:com.yiniuedu.utils
## **4** **、** **import** **關鍵字**
為了能夠使用某一個包的成員,我們需要在 Java 程序中明確導入該包。使用 "import" 語句可完成此功能。
在 java 源文件中 import 語句應位于 package 語句之后,所有類的定義之前,可以沒有,也可以有多條,其語法格式為:
```
import package1\[.package2…\].(classname|\*);
```
如果在一個包中,一個類想要使用本包中的另一個類,那么該包名可以省略。要是要用到其他包下的類,就必須要先導包!
如果兩個類重名,需要導入對應的包,否則就需要寫出完整地址:
```
com.yiniedu.dao.Hello hello = new com.yiniuedu.dao.Hello();
```
用 **import** 關鍵字引入,使用通配符 "\*" , 導入io包下的所有類!
```
import java.io.*;
```
【不建議這樣使用,因為會全局掃描,影響速度!】使用 **import** 關鍵字引入指定類:
【注意】類文件中可以包含任意數量的 import 聲明。import 聲明必須在包聲明之后,類聲明之前。
【編碼規范:推薦參考阿里巴巴開發手冊編程規范】下載地址:阿里巴巴開發手冊
#
**JavaDoc**
## **1** **、簡介**
JavaDoc是一種將注釋生成HTML文檔的技術,生成的HTML文檔類似于Java的API,易讀且清晰明了。在簡略介紹JavaDoc寫法之后,再看一下在Intellij Idea 中如何將代碼中的注釋生成HTML文檔。
javadoc是Sun公司提供的一個技術,它從程序源代碼中抽取類、方法、成員等注釋形成一個和源代碼配套的API幫助文檔。也就是說,只要在編寫程序時以一套特定的標簽作注釋,在程序編寫完成后,通過Javadoc就可以同時形成程序的開發文檔了。javadoc命令是用來生成自己API文檔的,使用方式:使用 ????命令行在目標文件所在目錄輸入javadoc?+文件名.java。
#### **先看一段樣例代碼:**
```
/** 這是一個Javadoc測試程序
* @author yiniuedu
* @version 1.0
* @since 1.5
* */
public class HelloWorld {
public String name;
/** @param name 姓名
* @return 返回name姓名
* @throws Exception無異常拋出
* */
public String function(String name) throws Exception{
return name;
}
}
```
稍微解釋一下:
以 /*\** 開始,以 / 結束。
@author 作者名
@version 版本號
@since 指明需要最早使用的jdk版本
@param 參數名
@return 返回值情況
@throws 異常拋出情況
##
**2** **、命令行生成** **Doc**

```
-encoding UTF-8 -charset UTF-8
//解決GBK亂碼問題,在中間添加編碼設置
```
【演示:生成并查看文檔】
# **回顧及總結**
這一章,我們學習了Java的基礎
* 安裝使用了IDEA
* 使用注釋
* 了解了Java的關鍵字
* 數據類型
* 怎么定義一個變量
* 怎么操作這些變量
* 如何生成一篇完整的文檔
* 。。。
以后這些東西在我們的生活中會天天遇到!
不積跬步,無以至千里;不積小流,無以成江海! 一生二,二生三,三生萬物!
一切一切都說明了基礎的重要性!
所以,簡單的東西,不要忽略,高手之間的區分,就在于這些細節方面的東西!
- Java基礎企業實踐篇
- 一、Java開發環境搭建
- 1.Java的前世今生
- 2.JVM、JRE和JDK的概念及關系
- 3.Java的跨平臺特性
- 4.Java運行機制
- 5.環境搭建
- 二、程序設計基礎
- 1.掌握代碼基本結構
- 2.熟練寫注釋
- 3.掌握標識符的使用
- 4.掌握關鍵字的使用
- 5.掌握常量的使用
- 6.認識變量
- 7.掌握數據類型的使用
- 8.掌握類型轉換
- 9.掌握作用域
- 10.掌握運算符的使用
- 11.掌握順序結構的使用
- 13.掌握循環結構的使用
- 14.掌握方法的使用
- 15.掌握數組的使用
- 16.掌握修飾符的使用
- 三、面向對象語言基礎
- 1.對象的概念
- 2.類的概念
- 3.類和對象的關系
- 4.面向過程和面向對象的區別
- 5.實訓項目:五子棋游戲設計與實現
- 6.案例練習
- 案例一:地址類
- 案例二:員工類
- 案例三:動物狗類
- 案例四:銀行賬戶類
- 案例五:圖書類
- 四、面向對象概念的理解,類和對象
- 1.類的構成
- 2.屬性
- 3.方法和構造方法
- 4.重載和重寫
- 5.變量的作用域
- 6.成員變量和局部變量
- 7.靜態塊的作用和加載機制
- 8.類生成對象的過程
- 9.對象參數傳遞過程
- 五、封裝,繼承,多態
- 1.理解封裝、繼承、多態的概念和目的
- 2.理解封裝、繼承、多態的實現方法和步驟
- 3.掌握Java訪問修飾符
- 4.理解什么是內部類
- 5.理解this、static、final關鍵字
- 6.實訓項目:租車系統設計與實現
- 六、抽象類和接口
- 1.理解抽象類的概念,為什么要有抽象類
- 2.掌握抽象類的聲明格式
- 3.理解什么是接口,為什么要有接口
- 4.掌握接口的定義與實現
- 5.理解接口和抽象類的區別
- 6.實訓案例
- 案例一:電腦模型(OO實現)
- 案例二:銀行轉賬(OO實現)
- 七、Object類和常用API
- 1.理解什么是API
- 2.掌握Java?API文檔的使用
- 3.理解Java類庫的概念
- 4.掌握Object類并掌握該類中的方法
- 5.掌握String類的應用
- 6.掌握StringBuffer、StringBuilder類的應用
- 7.掌握基本數據類型及其包裝類
- 8.掌握Java日期類
- 八、泛型、集合
- 1.理解泛型的概念和實現語法
- 2.理解Java集合框架三大接口:List、Set、Map
- 3.掌握List接口的實現類ArrayList、LinkedList的使用
- 4.掌握HashSet的使用
- 5.掌握HashMap的使用
- 6.掌握Collections類中提供的靜態方法
- 九、異常和IO技術
- 1.理解異常的概念
- 2.掌握異常的分類和Java常見的異常
- 3.理解掌握Java的異常處理機制
- 4.掌握自定義異常
- 5.理解文件系統和File類
- 6.理解I/O概念和分類
- 7.掌握常見的I/O流對象
- 8.掌握文件流與緩沖流
- 十、泛型的延伸
- 1.理解并掌握泛型的基本原理與具體運作過程
- 2.掌握泛型類的定義
- 3.掌握泛型方法的定義
- 十一、流的延伸
- 1.理解數據流的作用
- 2.掌握對象流的作用
- 3.理解對象序列化的概念
- 5.理解線程死鎖
- 4.理解對象反序列化的概念
- 十二、反射技術
- 1.理解反射的概念
- 2.理解反射的工作原理
- 3.理解Reflection API中相關類的作用
- 十三、多線程技術
- 1.理解多線程的概念
- 2.理解線程的狀態與生命周期
- 3.理解多線程通信
- 4.理解線程同步
- 十四、網絡編程技術
- 1.理解網絡編程常用協議TCP/UDP/HTTP/FTP等基礎知識
- 2.掌握TCP網絡編程連接建立的3次握手和4次揮手的具體過程
- 3.掌握UDP網絡通信工作原理
- 4.掌握Socket通信模型的工作原理
- 十五、圖形化界面
- 5.理解線程死鎖
- 十六、JDBC技術
- 1.熟練掌握JDBCAPI中常用接口的基本概念
- 2.理解JDBC連接數據庫的思路和實現方法
- 3.熟練掌握JDBC連接數據庫的基本步驟
- 4.理解并掌握數據庫連接公共類的設計思路和方法
- 5.熟練掌握JDBC使用公共類連接數據庫的基本步驟
- 6.熟練掌握JDBC操作數據庫的基本步驟
- 7.熟練掌握JDBC操作數據庫的SQL語句
- 8.熟練掌握JDBC操作單表的方法及SQL語句
- 9.熟練掌握JDBC操作多表的方法及SQL語句
- 10.理解事務的基本概念
- 11.熟練掌握JDBC在綜合項目的使用方法(包含:基本數據、業務處理等)
- 十七、課外補充
- 附錄1.各種字符集和編碼詳解
- 項目實訓
- 項目2:汽車銷售系統