java是一種面向物件的語言，在java語言的描述下，萬事萬物皆物件。

理解面向物件（OOP）：
1，面向物件是相對面向過程而言。

2，面向過程強調的是功能行為，例如c語言是一個面向過程的語言。

3，面向物件將功能封裝進物件，強調具備功能的物件。

4，面向物件是基於面向過程的。

理解類和物件：
類是廣泛的概念，表示一個具有相同屬性和方法的多個物件的集合，是一個有共同性質的群體，而物件，所謂"萬物皆物件"，指的是一個
實實在在的東西。

成員變數和區域性變數的作用範圍：成員變數作用於整個類中，儲存於堆記憶體中，而區域性變數作用在函式中或語句中，儲存在棧記憶體中。

建構函式的書寫規範：
1，函式名必須和類名一樣。

2，不用定義返回值。

3，不可以寫return語句。

作用： 當分析事物時，該事物具備一些特性或者行為，那麼將這些內容定義在建構函式中，給物件進行初始化。

注意:
1，一個類中沒有定義建構函式時，系統會預設給該類加一個空引數的建構函式。

2，當在類中自定義了建構函式後，預設的建構函式就沒有了。

3，自定義的多個建構函式是以過載的方式存在的。

4，一個物件的建立，建構函式只執行一次，而一般方法可以被物件呼叫多次。

構造程式碼塊的作用：給物件進行初始化。物件一建立就執行，優先於建構函式執行。

與建構函式的區別：構造程式碼塊是給所有物件統一初始化，而建構函式是給對應的物件初始化。

this關鍵字代表本類物件。
super代表的是父類物件的引用。

static關鍵字：用於修飾成員（成員函式和成員變數）
被修飾後的成員具備以下特點：
1，隨著類的載入而載入，並隨著類的消失而消失，生命週期最長。

2，優先於物件存在

3，被所有物件所共享

4，可知直接被類名呼叫。

5，儲存與方法區中，成員變數隨著物件的建立存在於堆記憶體中。

6, 成員變數隨著物件的消失而消失。

靜態程式碼塊：
1，隨著類的載入而執行。

2，作用是用於給類進行初始化，也就是類一進記憶體還沒有建立物件時就需要對類做一些初始化動作。

static使用注意：
1，靜態方法只能訪問靜態成員

2，靜態方法中不可以寫this，super關鍵字

3，main函式必須是靜態方法。

繼承（extends）:
繼承是java不可或缺的一部分，在java中任何類都繼承了java的標準根源類Object。
繼承的優勢：
1,提高了程式碼複用性。

2，讓類與類之間產生了關係，有了這個關係，才有了多型的特性

注意：千萬不要為了獲取其他類的功能和簡化程式碼使用繼承，必須是類與類之間有所屬關係才可以繼承。所屬關係為is a。

java語言中，java只繼承單繼承，不支援多繼承因為多繼承會帶來安全隱患，當一個類繼承多個父類是，如果父類中有相同的函式，子類在呼叫函式時不知道該呼叫哪一個。

但是java支援多層繼承，也就是一個繼承體系。

想要使用體系，先查閱體系父類的描述，因為體系父類描述的是體系的共性功能。通過了解共性功能，就可知道該體系的基本功能。

在具體呼叫時，要建立子類物件。原因：
1，父類可能不可以建立物件。

2，建立子類物件可以獲得更多的功能，包括共有的和特有的。

當子類繼承父類時，沿襲了父類的功能到子類中。而且子類可以重新定義父類的功能，即進行功能的覆蓋。

功能覆蓋規則：
1，子類覆蓋父類時，必須保證子類許可權大於等於父類許可權才可以覆蓋。

2，靜態只能覆蓋靜態。

子父類中的建構函式：在對子類物件進行初始化時，父類的建構函式也會執行，那是因為子類的建構函式第一行有一條隱式的super()語句。

子類必須訪問父類中的建構函式的原因：
以為父類中的資料子類可以直接獲取，所以子類物件在建立的時候，需要先檢視父類是如何對這些資料進行初始化的，
故子類在進行物件初始化的時候，要先訪問一下父類中的建構函式

如果要訪問父類中制定的建構函式，可以在子類手動定義super語句的方式來訪問。

注意： super語句一定要定義在子類建構函式的第一行

final關鍵字：
1，final可以修飾類，方法，變數。

2，final修飾的類不可以被繼承 。（為了避免繼承後被子類複寫功能）

3，final修飾的方法不可以被覆蓋。

4，final修飾的變數只是一個常量，只能被賦值一次，既可以修飾成員變數，又可以修飾區域性變數。

注意：內部類只能訪問被final修飾的佈局變數。

抽象類（abstract）：
當多個類中出現相同功能，但是功能的主體不同這時可以進行向上抽取，值抽取功能定義，而不抽取功能主體。

定義抽象類的語法:
1，抽象方法一定在抽象類中

2，抽象方法和抽象類都必須被abstract關鍵字修飾

3，抽象類不可以用new建立物件，因為呼叫抽象方法沒意義

4，抽象類中的方法要被使用，必須由子類複寫所有的功能，建立子類物件對用，如果子類只複寫了部分功能，那這個子類仍是抽象類。

抽象類和一般類沒有太大的不同。該如何描述事物，就如何描述事物，只不過，該事物出現了一些看不懂的東西,通過抽象方法來表示，並交給子類來實現。抽象類比一般類多了一個子類。

注意： 抽象類不可以被例項化。抽象類可以不定義抽象方法，這樣做僅僅是不讓該類建立物件。

用抽象類來獲得一段程式執行的時間的例子：

<span style="font-family:KaiTi_GB2312;font-size:18px;">class GetTime
{
 public void getTime()
 {
  long start = System..currentTimeMillis();
  runCode();
  long end = System.currentTimeMills();
  System.out.println("spend time is : "+(end -start));
 }
 
 //在這裡我們不知道成具體是什麼，故將其抽象，叫給繼承GetTime的子類區實現。
 public abstract void runCode();
}

class SubTime extends GetTime
{
    public void runCode()
 {
  for(int i=0; i<100; i++)
  {
   System.out.println(i);
  }
 }
}

public class Test
{
 public static void main(String[] args) 
 {
  SubTime  sub = new SubTime();
                sub.getTime();
 }
}
</span>

上面例子實際用到了模板設計模式。
模板方法設計模式：
在定義功能時，功能一部分是確定的，而另一部分是不確定的，而確定的部分在使用不確定
的部分，那麼這是就將不確定的部分暴露出去，有該類的子類區完成

介面（interface）：
初期理解，可以認為是一個特殊的抽象類。當抽象類中的方法都是抽象的，那麼該類可以通過介面的形式來表示。class用來定義類，interface用來定義介面。

介面的特點：
1，介面是對外暴露的規則

2，介面是程式的功能擴充套件

3，介面可以用來多實現

4，類與介面之間是實現關係，而且類可以繼承一個類的同時實現多個介面

5，介面與介面之間可以有繼承關係

格式特點
1，介面中常見的定義： 常量，抽象方法
2，常量： 用 public static final 修飾
   方法： 用 public abstract 修飾

注意: 介面的成員都是public的，介面是不可以建立物件的，因為有抽象方法。子類對介面中的方法全部覆蓋後，子類才可以被例項化，否則子類是一個抽象類。

介面可以被類多實現，這也是對多繼承不支援的轉換形式。

舉例：

<span style="font-family:KaiTi_GB2312;font-size:18px;">abstract class  Student
{
 public abstract void study();
 
 public void sleep()
 {
  System.out.println("sleep");
 }

}

interface Smoking
{
 public void smoke();
}

class ZhangSan extends Student implements Smoking
{
 public void study() 
 {
  System.err.println("zhangsan study at university");
 }

 @Override
 public void smoke() 
 {
  System.out.println("zhangsan smoke");
 }
}

class Lisi extends Student 
{
 public void study() 
 {
  System.err.println("lisi study at university");
 }

}

public class test
{
 public static void main(String[] args)
 {
  ZhangSan a = new ZhangSan();
  Lisi l = new Lisi();
  a.study();
  a.smoke();
  l.study();
 }
}
</span>

因為不是每個學生都有smoke的功能，故在Student類中只抽取所有學生都具備的功能：學習和睡覺。
讓會抽菸的學生去實現Smoking介面，不會抽菸的學生則不實現Smoking介面。

多型（polymorphic）：
可以理解為事物存在的多種體現形態。

1，多型的體現：父類的引用也指向了自己子類物件。父類的引用也可以接受自己的子類物件

2，多型的前提：必須是類與類之間有關係，要麼繼承，要麼實現。通常還有一個前提： 存在覆蓋

3，多型的好處：多型的好處大大的提高了程式的擴充套件性

4，多型的弊端：提高了擴充套件性，但是隻能使用父類的引用訪問父類的成員。

例子：

<span style="font-family:KaiTi_GB2312;font-size:18px;">class Animal
{
 public void eat() 
 {
  System.out.println("eat food");
 }
}

class Cat extends Animal
{
 public void eat()
 {
  System.out.println("eat fish");
 }
 
 public void catchMouse()
 {
  System.out.println("Catch Mouse");
 }
}

class Dog extends Animal
{
 public void eat()
 {
  System.out.println("eat bone");
 }
 
 public void bark()
 {
  System.out.println("bark.....");
 }
}

public class test
{
 public static void main(String[] args)
 {
  Animal cat = new Cat();
  Animal dog = new Dog(); 
  cat.eat(); 
  dog.eat();
                ((Cat)cat).catchMouse();
 }
}
</span>

結果輸出:
eat fish
eat bone
Catch Mouse

上面的例子中，因為cat是Animal的引用型別，所以cat只能呼叫eat這個方法，而不能呼叫catchMouse方法。
要想呼叫catchMouse函式，必須強制將cat轉換為Cat型別。注意：絕對不能將（new Animal()）強制轉換成
Cat或者Dog型別的物件，原因其實很好理解，貓一定是一個動物，但動物不一定是貓！！

多型中成員函式的特點：
1，在編譯時期，參閱引用型變數所屬的類中是否有呼叫的方法，如果有，編譯通過。

2，在執行時期，參閱物件所屬的類中是否有呼叫的方法。

內部類（inner-class）：
內部類訪問特點：
1，內部類可以直接訪問外部類中的成員，包括私有成員，之所以可以直接訪問外部類中的成員，是因為內部類持有格式：外部類.this.成員

2，而外部類要訪問內部類的成員必須要建立內部類的物件了一個外部類引用。

訪問格式：
當內部類定義在外部類的成員位置上，而且非私有，可以在外部其他類中直接建立內部類物件

注意： 當內部類中的定義了靜態成員，該內部類必須是靜態的。當外部類中的靜態方法訪問內部類時，內部類也必須是靜態的。

當描述事物時。事物內部還有事物，該事物用內部類來描述。因為內部事物在使用外部事物的內容。

從內部類中訪問區域性變數，需要將區域性變數宣告為最終型別

匿名內部類：
1，匿名內部類其實就是內部類的簡寫格式

2，定義匿名內部類的前提：內部類必須是繼承一個類或者實現一個介面

3，匿名內部內的格式：new父類或者介面(){內容}；

異常（Exception）：
在java中可以使用兩種方法來處理異常：
1，在發生異常的地方直接處理。

2，將異常丟擲，讓呼叫者來處理異常。

java提供了豐富的異常類，他們都是java.lang.Throwable的子孫類。

異常體系：
 Throwable
  |--Error
  |--Exception
         |--RuntimeException

異常體系的特點：異常體系中的所有類以及建立的物件都具備可拋性。

java將異常劃分為三種：
1，檢查型異常（Exception）： 描述了正確程式中所發生的問題，這些問題一般情況下是因為外在環境的條件不滿足而引起的，如使用者錯誤及IO異常

2，執行期異常（RuntimeException）：通常意味著程式存在bug，一般需要通過更改程式來避免。

3，錯誤（Error）：錯誤可能來源於一個程式bug，但一般情況下更可能來源於環境的問題，如記憶體耗盡問題。

其中執行期異常類是檢查型異常類的子類。

異常的處理：
java提供了特有的語句進行處理，
try
{
 需要別檢測的程式碼。
}
catch ()
{
 處理異常的程式碼（處理方式）
}
finally
{
 一定會執行的語句。
}

異常宣告throws：在功能上通過throws關鍵字宣告該功能有可能會出現的問題。
如果函式聲明瞭異常，呼叫者需要進行處理，處理方式可以throws也可以trycatch。

當函式內容有thorw丟擲異常物件，並未進行try處理，必須要在函式上宣告，否則編譯失敗
注意：RuntimeException除外。也就是時候如果函式內容有丟擲RuntimeException異常物件，函式上可以不用宣告。

舉例：

<span style="font-family:KaiTi_GB2312;font-size:18px;">class Demo
{
 public double div(int a, int b)
 {
  if(b<=0) 
   throw new RuntimeException("除數小於等於零！！！");
  return a/b;
 } 
}

public class test
{
 public static void main(String[] args)
 {
  Demo demo = new Demo1();
  demo.div(1, 0);
 }
}
</span>

div函式和main函式都沒有宣告異常，main函式中也沒有用try處理異常，但編譯能通過，這就是執行時異常的特點，程式會在丟擲執行時異常的地方停止執行。

throws和throw的區別：
1,throws使用在函式上。

2，throw使用在函式內。

3，throws後面可以跟多個異常類，throw丟擲的是異常類的物件。

處理異常的注意事項：
1，宣告異常時，建議宣告更為具體的異常。

2，對方宣告幾個異常，就對應有幾個catch塊，不要定義多餘的catch塊，如果多個catch塊中的異常出現繼承關係，父類異常catch塊放在最下面。

注意：建立catch處理時，catch中一定要定義具體處理方式，不要簡單定義一句： e.printStackTrace()。也不要簡單的就寫一條輸出語句。

自定義異常：因為專案中會出現特有的問題，而這些問題並未被java所描述並封裝成物件，此時要自定義異常封裝。
自定義異常類繼承Exception或者RuntimeException的原因：
1，為了讓該自定義類具備可拋性

2，讓該類具備操作異常的共性方法。

異常處理語句格式：
第一種：
try
{
 
}
catch ()
{

}

第二種：
try
{
 
}
catch ()
{

}
finally
{

}

第三種：
try
{
 throw 異常物件
}
finally
{
 出現錯也必須要執行的程式碼，入關閉資源
}

記住： catch是用於處理異常，如果沒有catch就代表異常沒有被處理過。

異常-覆蓋時的異常特點：
1,子類在覆蓋父類時，如果父類的方法丟擲異常，那麼子類的覆蓋方法，只能丟擲父類的異常或者改異常的子類。

2，如果父類方法丟擲多個異常，那麼子類在覆蓋該方法時，只能丟擲父類異常的子集。

3，如果父類後者介面的方法中沒有異常丟擲，那麼子類在覆蓋方法時，也不可以丟擲異常。如果子類方法發生了異常，必須進行try處理，絕對不能丟擲異常。

finally塊只有在一種情況下不會執行，即當執行到System.exit(0)的時候。

java異常處理機制的好處在於將問題進行封裝，使正常流程程式碼和問題處理程式碼想分離，方便於閱讀。

---------------------- ASP.Net+Unity開發、.Net培訓、期待與您交流！ ----------------------詳細請檢視：www.itheima.com