1.Java基礎-面向對象編程思想（封裝繼承多態接口）

封裝：

1.定義：隱藏對象的屬性和實現細節，僅對外公開接口,控制在程序中屬性的讀和修改的訪問級別。

2.封裝的目的是：加強安全性和簡化編程，使用者沒必要了解具體的實現細節，而只是要經過外部接口，一特定的訪問權限來使用類的成員。

3.封裝的基本要求是:把全部的屬性私有化，對每一個屬性提供getter和setter方法，若是有一個帶參的構造函數的話，那必定要寫一個不帶參的構造函數。在開發的時候常常要對已經編寫的類進行測試，因此在有的時候還有重寫toString方法，但這不是必須的。

 

繼承：

1.目的：實現代碼的複用。

2.介紹：當兩個類具備相同的特徵（屬性）和行爲（方法）時，能夠將相同的部分抽取出來放到一個類中做爲父類，其它兩個類繼承這個父類。繼承後子類自動擁有了父類的屬性和方法，但特別注意的是，父類的私有屬性和構造方法並不能被繼承。另外子類能夠寫本身特有的屬性和方法，目的是實現功能的擴展，子類也能夠複寫父類的方法即方法的重寫。子類不能繼承父類中訪問權限爲private的成員變量和方法。子類能夠重寫父類的方法，及命名與父類同名的成員變量。有時候咱們須要這樣的需求：咱們須要將某些事物儘量地對這個世界隱藏，可是仍然容許子類的成員來訪問它們。這個時候就須要使用到protected。

 

 

 

 

 

多態：

1.概念：相同的事物，調用其相同的方法，參數也相同時，但表現的行爲卻不一樣。

 

2. Java實現多態有三個必要條件：繼承、重寫、向上轉型。

         繼承：在多態中必須存在有繼承關係的子類和父類。

         重寫：子類對父類中某些方法進行從新定義，在調用這些方法時就會調用子類的方法。

         向上轉型：在多態中須要將子類的引用賦給父類對象，只有這樣該引用纔可以具有技能調用父類的方法和子類的方法。

      只有知足了上述三個條件，咱們纔可以在同一個繼承結構中使用統一的邏輯實現代碼處理不一樣的對象，從而達到執行不一樣的行爲。

 

3.多態的實現方式：

 

 

（1）基於繼承實現的多態

      基於繼承的實現機制主要表如今父類和繼承該父類的一個或多個子類對某些方法的重寫，多個子類對同一方法的重寫能夠表現出不一樣的行爲。

 

 

（2）基於接口實現的多態

      繼承是經過重寫父類的同一方法的幾個不一樣子類來體現的，那麼就可就是經過實現接口並覆蓋接口中同一方法的幾不一樣的類體現的。

      在接口的多態中，指向接口的引用必須是指定這實現了該接口的一個類的實例程序，在運行時，根據對象引用的實際類型來執行對應的方法。

      繼承都是單繼承，只能爲一組相關的類提供一致的服務接口。可是接口能夠是多繼承多實現，它可以利用一組相關或者不相關的接口進行組合與擴充，可以對外提供一致的服務接口。因此它相對於繼承來講有更好的靈活性。

 

4.多態性主要表如今以下兩個方面:

 

 

(1)方法重載.一般指在同一個類中,相同的方法名對應着不一樣的方法實現,可是方法的參數不一樣.

 

(2)成員覆蓋.一般指在不一樣類(父類和子類)中,容許有相同的變量名,可是數據類型不一樣;也容許有相同的方法名，可是對應的方法實現不一樣.

 

5.多態的好處：程序的可擴展性及可維護性加強。

 

 

抽象：

1.介紹：在面向對象的概念中，咱們知道全部的對象都是經過類來描繪的，可是並非全部的類都是用來描繪對象的，若是一個類中沒有包含足夠的信息來描繪一個具體的對象，這樣的類就是抽象類。抽象類每每用來表徵咱們在對問題領域進行分析、 設計中得出的抽象概念，是對一系列看上去不一樣，可是本質上相同的具體概念的抽象，咱們不能把它們實例化（拿不出一個具體的東西）因此稱之爲抽象。

 

　　好比：咱們要描述「水果」，它就是一個抽象，它有質量、體積等一些共性（水果有質量），但又缺少特性（蘋果、橘子都是水果，它們有本身的特性），咱們拿不出惟一一種能表明水果的東西（由於蘋果、橘子都不能表明水果），可用抽象類來描述它，因此抽象類是不可以實例化的。當咱們用某個類來具體描述「蘋果」時，這個類就能夠繼承描述「水果」的抽象類，咱們都知道「蘋果」是一種「水果」。

 

2.抽象方法：被abstract修飾的方法是抽象方法，抽象方法沒有方法體。修飾符 abstract 返回值類型 函數名();抽象方法的修飾符只能用public或者protected或者沒有修飾，不能被final，static，private修飾。

（1）、類即便不包含抽象方法，也能夠定義成抽象類。
（2）、類中含有抽象方法的類必定要定義成抽象類。
（3）、抽象類中字段的定義和子類的訪問與通常類沒有變化。
（4）、擴展抽象類有兩種方法，第一種是在子類中定義部分抽象方法或者抽象方法不定義，這樣子類也必須定義成抽象類，第二種是定義所有的抽象方法，這樣子類就能夠不定義成抽象的了。
（5）、抽象類不能被實例化，可是能夠定義一個抽象類的對象變量，這個變量能夠引用非抽象子類的對象。
（6）、抽象類中包含有構造方法，也能夠顯式書寫構造方法，構造方法在實例化子類的對象中調用。


接口與抽象類的區別:

不一樣點：
一、接口能夠多實現，而抽象類只能單繼承
二、抽象類能夠有非抽象的方法和構造方法、變量，可是接口只能有抽象方法，靜態常量。
三、抽象類和子類具備父子關係，子類能擁有父類中一些屬性。接口雖然某個類實現一個接口，可是因爲接口中的變量都爲靜態常量，不存在繼承關係。

相同點：
一、不管接口仍是抽象類，都沒法直接實例化，其自身實例化須要靠實現類或子類來實現。
二、接口和抽象類都必須實現其中的全部方法。

 

抽象類（abstract class）的定義方式以下： 

public abstract class AbstractClass             //裏面至少有一個抽象方法
{
 　　public int t;  //普通數據成員
　　 public abstract void method1();   //抽象方法，抽象類的子類在類中必須實現抽象類中的抽象方法
 　　public abstract void method2(); 
 　　public void method3();   //非抽象方法
 　　public int method4();
 　　publi int method4 (){
      　　…… //抽象類中能夠賦予非抽象方法方法的默認行爲，即方法的具體實現
 　　}

       public void method3(){
      　　…… //抽象類中能夠賦予非抽象方法方法的默認行爲，即方法的具體實現
 　　} 

}

 

接口（interface）的定義方式以下： 

public interface Interface
{ 
 　　static final int i;  //接口中不能有普通數據成員，只可以有靜態的不能被修改的數據成員,static表示全局，final表示不可修改，能夠不用static final 修飾，會隱式的聲明爲static和final
 　　

　　 public void method1();  //接口中的方法必定是抽象方法，因此不用abstract修飾
 　　

 　　public void method2();  //接口中不能賦予方法的默認行爲，即不能有方法的具體實現
}

一、一個接口能夠被多個類實現，一個類也能夠實現多個接口。
二、接口中全部的定義的字段默認都是public static final 的屬性，寫和不寫沒有區別。
三、接口中的方法都是抽象的方法，而且抽象的方法默認都是public abstract修飾的，不能用其餘的修飾符修飾，能夠不寫。
四、接口中沒有構造方法
五、接口不是類，尤爲不能使用new運算符實例化一個接口。可是能夠聲明接口的變量，這個變量能夠指向實現了此接口的子類。

簡言之抽象類是一種功能不全的類，接口只是一個抽象方法聲明和靜態不能被修改的數據的集合，二者都不能被實例化。

　　從某種意義上說，接口是一種特殊形式的抽象類，在ｊａｖａ語言中抽象類表示的是一種繼承關係，一個類只能繼承繼承一個抽象類，而一個類卻能夠實現多個接口。在許多狀況下，接口確實能夠代替抽象類，若是你不須要刻意表達屬性上的繼承的話。

 super的用法：

1.     子類的構造函數若是要引用super的話，必須把super放在函數的首位.

class Base {

    Base() {

       System.out.println("Base");

    }

}

 

public class Checket extends Base {

    Checket() {

       super();//調用父類的構造方法，必定要放在方法的首個語句

       System.out.println("Checket");

    }

 

    public static void main(String argv[]) {

       Checket c = new Checket();

    }

}

          若是想用super繼承父類構造的方法，可是沒有放在第一行的話，那麼在super以前的語句，確定是爲了知足本身想要完成某些行爲的語句，可是又用了super繼承父類的構造方法。那麼之前所作的修改就都回到之前了，就是說又成了父類的構造方法了。

 

2．       在java中，有時還會遇到子類中的成員變量或方法與超類（有時也稱父類）中的成員變量或方法同名。由於子類中的成員變量或方法名優先級高，因此子類中的同名成員變量或方法就隱藏了超類的成員變量或方法，可是咱們若是想要使用超類中的這個成員變量或方法，就須要用到super.

 class Country {

    String name;

 

    void value() {

       name = "China";

    }

}

 

class City extends Country {

    String name;

 

    void value() {

    name = "Hefei";

    super.value();//不調用此方法時，super.name返回的是父類的成員變量的值null

       System.out.println(name);

       System.out.println(super.name);

    }

 

    public static void main(String[] args) {

       City c=new City();

       c.value();

       }

}

         爲了在子類中引用父類中的成員變量name和方法value()，在代碼中使用了super、super.name和super.value(),若不調用super.value()時，super.name返回父類成員變量默認值null,調用此方法時，super.value()方法把成員變量name賦值爲China,再利用super.name調用父類的成員變量的值。

     另外，要注意的是super.name調用的是成員變量的值，

class Country {

    String name="xianfan";

 

    String value(String name) {

       name = "China";

       return name;

    }

}

 

class City extends Country {

    String name;

 

    String value(String name) {

    name = "Hefei";

super.value("失敗");//不調用此方法時，super.name返回的是父類的成員變量的值null

       System.out.println(name);

       System.out.println(super.name);

       return name;

    }

 

    public static void main(String[] args) {

       City c=new City();

       c.value("成功");

    }

}

    結果爲：Hefei

xianfan

     此時，super.name返回的值是父類成員變量的值xianfan,而此時的super.value()方法是不起做用的。

 

3．用super直接傳遞參數：

  class Person {

    public static void prt(String s) {

       System.out.println(s);

    }

 

    Person() {

       prt("A Person.");

    }

 

    Person(String name) {

       prt("A person name is:" + name);

    }

}

 

public class Chinese extends Person {

    Chinese() {

       super(); // 調用父類構造函數（1）

       prt("A chinese.");// (4)

    }

 

    Chinese(String name) {

       super(name);// 調用父類具備相同形參的構造函數（2）

       prt("his name is:" + name);

    }

 

    Chinese(String name, int age) {

       this(name);// 調用當前具備相同形參的構造函數（3）

       prt("his age is:" + age);

    }

 

    public static void main(String[] args) {

       Chinese cn = new Chinese();

       cn = new Chinese("kevin");

       cn = new Chinese("kevin", 22);

    }

}

      結果爲：A Person.

A chinese.

A person name is:kevin

his name is:kevin

A person name is:kevin

his name is:kevin

his age is:22

          在這段程序中，this和super再也不是像之前那樣用「.」鏈接一個方法或成員，而是直接在其後跟上適當的參數，所以它的意義也就有了變化。super後加參數的是用來調用父類中具備相同形式的構造函數，如1和2處。this後加參數則調用的是當前具備相同參數的構造函數，如3處。固然，在Chinese的各個重載構造函數中，this和super在通常方法中的各類用法也仍可以使用，好比4處，你能夠將它替換爲「this.prt」(由於它繼承了父類中的那個方法）或者是「super.prt」（由於它是父類中的方法且可被子類訪問），它照樣能夠正確運行。但這樣彷佛就有點多此一舉的味道了。

 

 this的用法：「this是指向對象自己的一個指針」

 

說明在什麼狀況下須要用到this：

        第1、經過this調用另外一個構造方法，用發是this(參數列表)，這個僅僅在類的構造方法中，別的地方不能這麼用。

        第2、函數參數或者函數中的局部變量和成員變量同名的狀況下，成員變量被屏蔽，此時要訪問成員變量則須要用「this.成員變量名」的方式來引用成員變量。固然，在沒有同名的狀況下，能夠直接用成員變量的名字，而不用this。

 

        第3、在函數中，須要引用該函所屬類的當前對象時候，直接用this。

 

super和this的異同：

       1)super（參數）：調用基類中的某一個構造函數（應該爲構造函數中的第一條語句） 

       2)this（參數）：調用本類中另外一種造成的構造函數（應該爲構造函數中的第一條語句）
       3)super:　它引用當前對象的直接父類中的成員（用來訪問直接父類中被隱藏的父類中成員數據或函數，基類與派生類中有相同成員定義時如：super.變量名    super.成員函數據名（實參）

      4)this：它表明當前對象名（在程序中易產生二義性之處，應使用this來指明當前對象；若是函數的形參與類中的成員數據同名，這時需用this來指明成員變量名）

 

      5）調用super()必須寫在子類構造方法的第一行，不然編譯不經過。每一個子類構造方法的第一條語句，都是隱含地調用super()，若是父類沒有這種形式的構造函數，那麼在編譯的時候就會報錯。

      6）super()和this()相似,區別是，super()從子類中調用父類的構造方法，this()在同一類內調用其它方法。

　  7）super()和this()均需放在構造方法內第一行。

　  8）儘管能夠用this調用一個構造器，但卻不能調用兩個。

　  9）this和super不能同時出如今一個構造函數裏面，由於this必然會調用其它的構造函數，其它的構造函數必然也會有super語句的存在，因此在同一個構造函數裏面有相同的語句，就失去了語句的意義，編譯器也不會經過。

　10）this()和super()都指的是對象，因此，均不能夠在static環境中使用。包括：static變量,static方法，static語句塊。

　11）從本質上講，this是一個指向本對象的指針, 然而super是一個Java關鍵字。

 

如下是關於子類父類的構造方法的注意事項：

       

   轉載自http://blog.csdn.net/qq_22118507/article/details/51422591