Java面向對象概述及三大特徵（封裝，繼承和多態）

1、面向對象思想

Java是面向對象的高級語言，對於Java語言來講，萬事萬物皆對象！

它的基本思想是使用類，對象，繼承，封裝，消息等基本概念進行程序設計。面向對象程序的最小單元是類，類表明了客觀世界中具備某一特徵的一類事物，封裝了這類事物所具備的屬性和行爲。

因此，類定義=成員變量（屬性）+方法（行爲）。

面向對象程序設計與人類的思惟習慣一致，好比但願完成「兔子吃草"這件事：

在面向過程的程序設計裏，一切以函數爲中心，則會用以下語句來表達：

吃（兔子，草）；

而在面向對象程序設計裏，一切以對象爲中心，則會用以下語句來表達：

兔子.吃（草）；

對比這兩條語句能夠看出，面向對象語句更接近天然語言語法，主謂賓一目瞭然。

2、類與對象的關係

　　類是對象的抽象，對象則是類的實例，一個類能夠生成多個對象。對一個類定義而言，包含三種最多見的成員：構造器、成員變量和方法，而構造器是一個類建立對象的根本途徑，若是一個類沒有構造器則沒法建立實例。所以，若是程序員沒有爲一個類建立構造器，則系統會爲該類提供一個默認無參的構造器。下面定義一個簡單的Person類：

public class Person{
    //定義兩個成員變量：姓名和年齡
    public String name;
    public int age;
    //定義一個say方法
    public void say(String content){
        System.out.println(content);
    }
}

　　定義類以後就能夠經過Person p = new Person()來建立對象了，Person對象賦給了p變量，它們在內存中的存儲示意圖以下：

　　

3、面向對象的三個基本特徵（封裝，繼承和多態）

一、封裝

 封裝是指將對象的實現細節隱藏起來，對外提供公共訪問方法，將對象的功能暴露出來。

封裝能夠被認爲是一個保護屏障，防止該類的代碼和數據被外部類定義的代碼隨機訪問。

適當的封裝可讓程式碼更容易理解與維護，也增強了程序代碼的安全性。最終目的是實現模塊設計的」高內聚低耦合「。

那麼，如何實現java的封裝呢？首先來看一下java的訪問控制級別：

Java提供了4個訪問控制級別，由小到大以下圖：

從上圖能夠得出，實現一個類封裝的步驟以下：

♦ 修改屬性的可見性（訪問級別）來限制對屬性的訪問（通常限制爲private），例如：

/**
這段代碼中，將 name 和 age 屬性設置爲私有的，只能本類才能訪問，其餘類都訪問不了，如此就對信息進行了隱藏。 
*/
public class Person {
    private String name;//姓名
    private int age;//年齡
}

 　　♦  對每一個值屬性提供對外的公共方法訪問，也就是建立一對賦值取值的方法，用於對私有屬性的訪問，例如：

public class Person{
    private String name;
    private int age;
​
    public int getAge(){
      return age;
    }
​
    public String getName(){
      return name;
    }
​
    public void setAge(int age){
      this.age = age;
    }
​
    public void setName(String name){
      this.name = name;
    }
}

　　採用 this 關鍵字是爲了解決實例變量（private String name）和局部變量（setName(String name)中的name變量）之間發生的同名的衝突，this指當前對象。

所以，一個類定義時，通常用private修飾成員變量，public修飾成員方法。獲取成員變量應該用對象.get變量名()而不是對象.成員變量名。

二、繼承

　　咱們生活中有不少繼承的例子：如兔子屬於動物的一種，兔子有通常動物的特徵及行爲，在java語言裏能夠說兔子繼承動物，兔子是子類，動物是父類；學生和老師都屬於人類，有人的通常特性，因此在java語言裏能夠說學生和老師繼承人類。因此繼承須要符合的關係是：is-a，父類更通用，子類更具體。

　　　

 繼承是指子類能夠複用父類的屬性和方法，Java的繼承是單繼承，每一個子類只有一個直接父類。Java的繼承經過extends關鍵字實現，實現繼承的類稱爲子類，被繼承的類稱爲父類（基類或超類）。Java繼承語法格式以下：

修飾符 class SubClass extends SuperClass{
  //類定義部分      
}

　　須要注意的是 Java 不支持多繼承，但支持多重繼承。

　　

　　子類包含與父類同名方法的現象稱爲方法重寫，也稱爲方法覆蓋。

　　方法的重寫要遵循「兩大兩小一大」規則，「兩同」即方法名相同、形參列表相同；「兩小」指子類方法返回值類型應該比父類方法返回值類型要小或相等，子類方法聲明拋出的異常應該比父類方法聲明拋出的異常類要小或相等；「一大」指子類方法的訪問權限應比父類方法的訪問權限更大或相等。

三、多態

　　多態是指子類對象能夠直接賦給父類變量（父類引用指向子類對象），但運行時依然表現出子類的行爲特徵，也就是說，同一類型的對象在執行同一個方法時，可能表現出多種行爲特徵。

　  多態存在的三個必要條件

• 繼承
• 重寫
• 父類引用指向子類對象

　　好比：Parent p = new Child();

　　當使用多態方式調用方法時，首先檢查父類中是否有該方法，若是沒有，則編譯錯誤；若是有，再去調用子類的同名方法。

　　多態的好處：可使程序有良好的擴展，並能夠對全部類的對象進行通用處理。

        在此我向你們推薦一個架構學習交流圈：830478757  幫助突破瓶頸 提高思惟能力

　　下面舉一個多態的例子：

public class Test {
    public static void main(String[] args) {
      show(new Cat());  // 以 Cat 對象調用 show 方法
      show(new Dog());  // 以 Dog 對象調用 show 方法
                
      Animal a = new Cat();  // 向上轉型  
      a.eat();               // 調用的是 Cat 的 eat
      Cat c = (Cat)a;        // 向下轉型  
      c.work();        // 調用的是 Cat 的 work
  }  
            
    public static void show(Animal a)  {
      a.eat();  
        // 類型判斷
        if (a instanceof Cat)  {  // 貓作的事情 
            Cat c = (Cat)a;  
            c.work();  
        } else if (a instanceof Dog) { // 狗作的事情 
            Dog c = (Dog)a;  
            c.work();  
        }  
    }  
}
 
abstract class Animal {  
    abstract void eat();  
}  
  
class Cat extends Animal {  
    public void eat() {  
        System.out.println("吃魚");  
    }  
    public void work() {  
        System.out.println("抓老鼠");  
    }  
}  
  
class Dog extends Animal {  
    public void eat() {  
        System.out.println("吃骨頭");  
    }  
    public void work() {  
        System.out.println("看家");  
    }  
}

 

 

執行以上程序，輸出結果爲：

吃魚
抓老鼠
吃骨頭
看家
吃魚
抓老鼠