面向對象高級

static,可以修飾屬性、方法、代碼塊。

每個對象稱為類的實例，對象之間的存儲區互不干涉。

static int data;是類變量（共享），為類開辟一個空間。共享存儲區域。

訪問類變量，通過類名訪問。一個對象引用也可以使用靜態成員，與它的編譯時類型的類訪問，一致。

MyClass m = new MyClass();
m.data 《= 》MyClass.data;

靜態方法-〉沒有當前對象概念-〉也就不允許訪問的類中的非靜態成員（實例變量）

主方法之所以是靜態的，它是程序入口，JVM最初沒有對象，必須通過使用類名調用方法，主方法必須為靜態的。

靜態方法不能被覆蓋。

靜態代碼塊只執行一次。

static 用于單例模式Singleton模式

final 修飾  類、屬性、方法

修飾類，無子類，保證用戶使用的一致性。典型范例String類。

修飾屬性或者變量一旦賦值，不得更改。

對于對象變量來說，是不能再指向其他對象，而現有的對象內部屬性可以改變。

會配合static一起使用，只分配一個存儲空間，只需要維護一個空間。

public static final，是一個常量。大寫。

class SuperClass{
      final int AGE;

      public SuperClass(){
         AGE=10;
      }
}

初始值0不算，需要顯示賦一次值。

初始設定在兩個地方，1定義時直接賦值，2構造器

靜態常量也在兩個地方設定，1初始設定，2靜態代碼塊




final方法不能覆蓋，由于多態，一個編譯時類型對應多個運行時類型，final保證某方法的穩定性。


private
               左邊的修飾符有其中一個，系統都默認添加了final修飾符。
static

所以之前的靜態方法不能覆蓋。

=====================
方法繼承是決定于在子類中是否可見。能見到就是繼承。

final不決定繼承。

實際上如果實例化一個子類對象，它的父類對象的所有屬性（包括private成員都創建了，就是訪問不了，所以不能成為繼承的一部分，也就是不能繼承咯）



=====================


abstract 修飾 類 方法

修飾類 -> 這個類必須被繼承使用->不能生成對象

用處，把子類最大的共性提取出來放入其中，面向對象一般原則。

雖然不能生成對象（不能作為運行時類型），但可以聲明為類型（可作為編譯時類型）。

抽象方法，沒有實現，留給子類覆蓋。

final永遠不可能和abstract在一起，那么private和static也不能和abstract聯合修飾。

final表示必須不能被繼承，不能覆蓋；abstract表示必須繼承，方法沒有實現，必須覆蓋使用。所以矛盾。

abstract class SuperClass{
      abstract void print(); //print(){},這是空實現，也是實現，所以不能帶大括號。
}

如果類中有抽象方法的話，那么類只能是抽象類。(一個半成品)

如果子類沒有實現父類的抽象方法，就會編譯出錯，因為子類繼承了抽象方法，需要聲明為抽象類。

SuperClass sc = new SubClass();

sc.print();動態類型判定，運行時類型不會改變，肯定是一個實現抽象方法的類對象。




接口:是同類，同一個層次的數據結構。

interface IA{
   void print();  
   int A = 1;
}

修飾符省略
一個Java文件，只能定義一個公開接口

一個接口等同于一個抽象類

一個特殊的抽象類：
   所有方法都是公開抽象的:public abstract
   所有屬性都是公開靜態常量:public static final

interface IA{
   void print();  
   int A = 1;
}

等價于

abstract class IA{
   public static final int A=1;
   public abstract void print();
}

這時可要注意，類實現接口時，覆蓋方法的訪問控制符一定要寫上public，接口是省略為public，類不寫可是default，根據Overriding規則，覆蓋方法的訪問控制等于或者大于父類方法的訪問控制。

class IAImpl extends java.util.ArrayList implements IA{}

1一個類除了繼承類，還可以實現接口（多個）。

2盡管一個類只能繼承一個類，一個類可以實現多個接口

3接口與接口之間可以繼承并可以多繼承，實現多重繼承，但復雜度不增加。

interface IC extends IA,IB{}

IC有著IA，IB所有方法的定義

IA，IB可以作為編譯時類型。

========================

接口，被用來定義可以***的東西。

                  存儲設備                              輸入設備
----|----------------|-----                     ----------|-----------
硬盤                  U盤                                 鼠標
----|----
移動硬盤

使用接口來剝離出一部分抽象。

移動硬盤、U盤、鼠標除了間接父類是統一的設備父類外。

他們都是USB設備，這部分抽象就需要用接口定義。

那么機器上的連接器是一個方法，connect(USB接口)，不管你什么具體設備，你都必須實現USB規范，才能往上插。

那么用接口來定義一個規范。


例子2，JDBC，使用Java來訪問數據庫。

首先，如果由Sun公司自己提供各種數據庫的驅動，那么各個DB廠商需要把數據庫核心代碼提供給Sun，這是不可能的，核心商業機密。

而由各個DB廠商自己寫的話，會出現方法名的不同，導致如果數據庫遷移，代碼需要改動。(例如Oracle提供的方法為ConnectOracle()而ms提供的方法為ConnectSQL)。那么無法真正實現Write Once，Run Anywhere，Sun不同意。

怎么辦？使用接口。

由Sun和DB聯合制定一些一系列接口。

interface Driver()
{
      void connect();
      ...
}

OracleDriver implements Driver
SQLDriver implements Driver

實現不同的connect()邏輯。

用戶Driver d = getDriver();
d.connect();

接口是實現Java一次編譯，到處運行的重要技術。

保證了Sun制定規范，數據庫廠商實現，用戶使用。保證架構穩定性（將三方分開）

對于用戶來說，接口最大化屏蔽差異。

1.實現不同層次，不同體系的對象的抽象。
2.保證架構穩定性。對用戶透明。


==============================

Object 類，所有類的父類（直接，間接父類）

finalize(),當一個對象被垃圾回收的時候，會調用一下。不適合放入釋放資源的方法。

toString(),對象的字符串表現形式。

System.out.println(obj);->obj.toString()

自定義類，覆蓋該方法，返回一些有意義的信息。

==  判斷字面值是否相等，

String a = new String("hello");
String b = new String("hello");
b==a false

String final類，并且它的值也是immutable的。

String a = "A"
a = a + "B"
這兩步操作一共產生了3個對象。

JVM內部有一個字符串池，一個獨立存儲區域，保存已創建的字符串，如果再有相同的，會將引用指向字符串池中的已有對象，不再創建新的，如果沒有再創建。

String a = "abc";
String b = "abc";

所以上面的例子是采用new String("abc")方式創建String對象，不會再去池中找，直接在堆中創建新對象。

String a = new String("hello");
String b = "hello";

a為堆地址，b為串池地址，a==b，false。

這種方式，是一種用時間換空間的做法，比如如果程序中有100個"hello"，難道程序要去維護100個對象嘛。

Object.equals   判斷對象值是否相等。

自定義類如果要進行對象值的比較，覆蓋Object的equals方法，自行判斷，如果不覆蓋，直接調用Object.equals是判斷地址。

equals方法覆蓋標準流程：