萬物皆物件,在面向物件思想裡,封裝,繼承,多型我們可能不會特別總視它。什麼是面向物件？什麼是封裝，什麼是繼承？什麼是多型？什麼介面？什麼是抽象？介面與抽象之間的關係？在面試過程中，我回答的支支吾吾，深刻發現到自己對面向物件沒有一個系統的，深刻的理解，一切只停留在課本上，只有一個淺顯的認識。在面試官的交談中，面試官給我講解了那些我理解不夠深刻的知識，算是我目前為止，遇到的面試官，人很好，就想個老大哥一樣，交談很舒適和放鬆。現在讓我重新認識一下面向物件把！

　　java面向物件的三大特徵：封裝，繼承，多型

1、封裝：java中的封裝是指一個類把自己內部的實現細節進行隱藏，，只暴露對外的介面（getter和setter）方法，封裝又分為屬性的封裝和方法的封裝。封裝又分為屬性的封裝和方法的封裝，把屬性定義為私有地，他們通過setter和getter方法來對屬性的值進行設定和獲取。

 1 public class Person{
 2 
 3 private int id;
 4 private String name;
 5 private persion;
 6 
 7 
 8 public int getId(){
 9 return id;}
10 
11 public String getName(){
12 return name;}
13 
14 public String getPerson(){
15 return person;
16 }
17 
18 public void setId(int id){
19 this.id=id; 
20 
21 }
 
22 public void setName(String name){
23 this.name= name;
24 }
25 public void setPerson(Person person){
26 this.person= person;
27 }
28 
29 }

在Person類中，定義類三個成員變數，分別為id,name,perosn，他們的訪問修飾都是private私有的，通過setter和getter方法對這些變數進行設值以及取值。封裝的意義就是增強類的資訊隱藏與模組化。封裝的主要作用是對外部隱藏具體的實現細節，增加程式的安全性。

2、繼承

java中的繼承是指在一個現有類（父類）的基礎上在構建一個新類（子類）,子類可以整合父類的成員以及成員方法（但是不一定能訪問或呼叫，例如private的私有地成員變數以及方法不能訪問和呼叫）。繼承的作用是能提高程式碼的複用性。子類擁有父類中的一切（擁有不一定能使用），它可以訪問和使用父類中的非私有成員變數，以及重寫父類中的非私有成員方法。

父類：

public class Person{
  private int a= 1;父類的私有屬性
  private int id;
  private String name;
  private int age;
  public int getID(){
            return id; 
}
  public void setId(){
            this.id=id;  
}
  public String getName(){
             return name;
}
   public String setName(String name){
              this.name=name;
}
   public int Age(){
               return age();
}
   public void setAge(int age){
                this.age=age;  
}
    @Override
public String toString(){
return "Person [id="+id+",name="+name+",age="+age+"]";}

}
public void say(){
          System.out.println("person say");
}
public void run(){
           System.out.println("person run..");
}
//父類的私有方法
private void show(){
System.out.println(“persion show...”);
}
}

子類：

public class Student extends Person{

@Override

public void say（）{

super.say();

}

@Override

public void run(){

super.run();

}

public static void main(String[] args){

Student st = new Student();

//st.show();//子類物件呼叫父類的私有方法，報錯！！！

st.say();

st.run();

           }

}

繼承的好處是實現程式碼的服用以及擴充套件，子類通過對父類程式碼的複用，可以不用再定義父類中已經定義好多的成員變數，方法上直接對父類的方法進行重寫實現了擴充套件。

3、多型：

多型就是指多種狀態，就是說當一個操作在不同的物件時，有產生不同的結果。

在Java中，實現多型的方式有兩種，一種是編譯時的多型，另一種是執行時多型，編譯時的多型是通過方法的過載實現的，而執行時多型是通過方法的重寫實現的。

方法的過載是指在同一個類中，有多個方法名相同的方法，但是這些方法有著不同的引數列表，在編譯期我們就可以確定到底呼叫了那個方法。

方法的重寫，子類重寫父類中的方法（包括介面的實現），父類的引用不僅可以指向父類的物件，而且還可以指向子類的物件。當父類的引用指向子類的引用時，只有在執行時才能確定呼叫那個方法。

在執行時的多型需要滿足三個條件：1、繼承（包括介面的實現）；2、方法的重寫；3、父類的引用指向子類；

執行時的多型：

介面：

public inteface  Animal{

      void shout();   
  

實現類：

public class Dog implements Animal{

@Override
public void shout(){

System.out.println("wangwang");
}
}

實現類：

public class Cat implement Animal{

@Override
public void shout(){
System.out.println("喵喵")；
}

}

　　測試：

public class AnimalTest{
     public static void main(String[] args){

//父類的引用指向子類物件
Animal d = new Dog();
animalShot(d);

//父類的引用指向子類物件
Animal c = new Cat();
animalShout(c);
}

public static void animalShout(Animal animal){
animal.shout();
}

}

面向物件的核心雖然是這短短的六個字，但想把這六個字用活，用好，需要我們不斷地學習和認識它。

（在面試的時候，遇到一個優秀面試官，能讓菜雞不斷地成長。。。） ，下一節在寫寫介面啊，抽象啊，再重新認識下。總之，面向物件的開發，是以物件為中心的，額額，我好像還沒有物件，自己建立一個把