什么是面向對象思想？已經(jīng)學完了java確不知道如何跟別人解釋面向對象是什么意思這很常見。讓我們一起來回顧下這個奇思妙想~

一、面向對象與面向過程

現(xiàn)在越來越多的高級語言流行起來了，如大家耳熟能詳?shù)腸++，python，java等，這些都是基于面向對象的語言
而最最基礎的，學校必學的語言----c語言它是屬于面向過程的語言。
好了，現(xiàn)在讓我們來討論下這兩類語言的區(qū)別

1、什么是面向過程？

面向過程：
就是分析出解決問題所需要的步驟，然后用函數(shù)把這些步驟一步一步實現(xiàn)，使用的時候一個一個依次調用就可以了。

舉例來說，大象裝進冰箱需要幾步？

按照面向過程思想：
第一步：工作人員去打開冰箱門
第二步：把大象塞進冰箱
第三步：工作人員把冰箱門關上
誒，這里我們就看出來了，面向過程就是把一件事按步驟一步一步來實現(xiàn)
用代碼表示

    public void openDoor(){}  //開門
    public void putIn(){}       //裝冰箱
    public void closeDoor(){}   //關門

依次調用這些方法就完成了

2、什么是面向對象？

對象，就是對問題中的事物的抽象
面向對象：
就是把現(xiàn)實中的事物都抽象為“對象”。每個對象是唯一的，且都可以擁有它的屬性與行為。我們就可以通過調用這些對象的方法、屬性去解決問題。

用面向對象思想解決大象裝進冰箱

大致的了解到了對象這個概念，可以說是對現(xiàn)實事物的一種抽象映射。

例如在這個事件中：
冰箱作為一個對象；
大象作為一個對象。
冰箱有這些功能：開門、裝物體、關門

class fridge{
    public void open(大象){}   //開門
    public void putIn(大象){}  //放進冰箱
    public void close(大象){}  //關門
}
class elephant{
	public void eat(){}   //吃
}

看出來了什么？每個對象是獨立的，有屬于它自己的功能，只需要專心實現(xiàn)自己的功能就好。所以在建立對象模型階段，僅僅關注對象有什么的功能，但不考慮如何實現(xiàn)這些功能。

面向對象的好處，就包括有很好的延展性，比如我給大象賦予了一個吃的功能，它通過調用就可以在冰箱里去吃東西。面向對象就是把現(xiàn)實問題抽象為對象，通過調用每個對象的屬性或功能去解決問題。

如果我要修改我的需求，把大象換成兔子，我用面向過程是不是得把每個步驟中的大象改為兔子。而用面向對象解決，我甚至可以重新創(chuàng)一個兔子對象，僅僅在調用的時候選擇兔子就行了。

二、類與對象的關系

很多人都會創(chuàng)建對象，不就是new嘛，調用對象方法不就是new.方法嘛。結果，有部分人在new類的時候，就下意識的把類當成了對象，那么類到底是不是對象呢？

肯定不是，先給出他們的基本概念

1、基本概念

對象
對象是由數(shù)據(jù)（描述事物的屬性）和作用于數(shù)據(jù)的操作（體現(xiàn)事物的行為）組成的封裝體，描述客觀事物的一個實體，是構成系統(tǒng)的基本單元。

類
類是對一組有相同數(shù)據(jù)和相同操作的對象的定義，是對象的模板，其包含的方法和數(shù)據(jù)描述一組對象的共同行為和屬性。類是在對象之上的抽象，對象則是類的具體化，是類的實例。類可有其子類，也可有其他類，形成類層次結構。

2、類與對象的區(qū)別

1）類是對象的抽象，而對象是類的具體實例。類是抽象的，不占用內存，而對象是具體的，占用存儲空間。

2）類是一組具有相同屬性和行為的對象的抽象。我們可以將類看做是創(chuàng)建對象藍圖，對象根據(jù)這個藍圖去具體實現(xiàn)某個東西。

比如來說，給一張“傘”的藍圖，我們設計出了晴雨傘，劍傘等等，你會發(fā)現(xiàn)，這些傘都有相同的行為呀----遮雨。

所以，類的實例化結果就是對象，而對一類對象的抽象就是類，類描述了一組有相同屬性和相同方法的對象。

三、基本特征：封裝、繼承、多態(tài)

1、封裝

（一）基本概念
封裝(encapsulation)即信息隱蔽。它是指在確定系統(tǒng)的某一部分內容時，應考慮到其它部分的信息及聯(lián)系都在這一部分的內部進行，外部各部分之間的信息聯(lián)系應盡可能的少。

（二）四種訪問控制級別

• public：對外公開，訪問級別最高
• protected：只對同一個包中的類或者子類公開
• 默認：只對同一個包中的類公開
• private：不對外公開，只能在對象內部訪問，訪問級別最低
  

（三）封裝使用
1、把盡可能多的東西藏起來，對外提高簡潔的接口
比如有半自動洗衣機和一個全自動洗衣機

半自動洗衣機接口有以下方法
①開機
②關機
③放水
④定時
⑤洗滌
⑥排水
⑦脫水

全自動洗衣機有以下方法
①開機
②關機
③設置洗衣機模式
④開始洗衣服，洗完自動關

對比來看，我們就會發(fā)現(xiàn)，自動洗衣機把放水、定時、洗滌、排水、脫水等細節(jié)，封裝到了③設置洗衣機模式里，這樣為使用者提供了更加簡單易用的接口，所以自動洗衣機會更加方便。

2、把所有屬性藏起來
加入某種屬性允許外界訪問，那么提供訪問該屬性的公開方法。假如狗類有一個名字、年齡屬性，不允許外界直接訪問屬性，但允許提供get和set方法來訪問

class Dogs{
    private String name;  //名字
    private String age;   //年齡
    
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }
}

那么我們把屬性設為private私有，把對外界提供設置屬性的方法設置為public。

有些人會問，既然是對外公開的，為什么不直接把name，age屬性設置為public呢，反而還要通過方法來設置，會不會多此一舉？

不會，有以下四個原因:

（一）符合現(xiàn)實外因通過內因起作用的客觀規(guī)律
假設原來狗就有一個叫“旺財”的名字，是對象本身原主人取的，調用了setName()方法【內因】。好了，領養(yǎng)狗的主人打算給狗換個名字“大黃”，他是使用者，也是調用setName()方法【外因】。

（二）靈活控制屬性的讀和修改的訪問級別
比如我只能讓使用者知道這狗狗的名字，但卻不允許修改他。那就吧setName()設為private私有，getName()設為public公有。

（三）防止使用者錯誤修改屬性
直接調用類的屬性，萬一改錯了怎么辦。所以我們可以在公有方法setName()里面添加限制條件，防止使用者錯誤修改屬性。例如，狗狗的年齡的范圍要在0~20期間。

public void setAge(int age) {
    if (age >20 || age < 0){
        throw new IllegalArgumentException("口令不合法");
    }
    else {
        this.age = age;
    }
}

（四）有助于對象封裝實現(xiàn)細節(jié)
如果上述判斷年齡合法的過程我們不想對使用者公開，就把這個過程用private封裝成一個“透明”的方法。這個判斷年齡合法的過程對使用者是透明的。

與封裝具有相同含義的一個概念就是透明。對象封裝實現(xiàn)細節(jié)，也就意味著對象的實現(xiàn)細節(jié)對使用者是透明的。透明在這里理解為“看不見”

public void setAge(int age) {
        isLegal();   //判斷是否合法
        this.age = age;
    }

private void isLegal(){
    if (age >20 || age < 0){
        throw new IllegalArgumentException("口令不合法");
    }
    else return;
}

2、繼承

繼承：讓某個類型的對象獲得另一個類型的對象的屬性和方法。繼承就是子類繼承父類的特征和行為，使得子類對象（實例）具有父類的實例域和方法，或子類從父類繼承方法，使得子類具有父類相同的行為。

（一）語法

class A extends B{}

一共繼承了哪些東西呢？這要分兩種情況

• 當A和B在同一包下，A繼承了B中public、protected和默認訪問級別的成員變量和成員方法
• 當A和B不在同一包下，A繼承了B中public、protected成員變量和成員方法

（二）繼承父類成員變量/方法
hanqishi繼承了父類Dog

class Dog{
    public String name="小白";
    public void say(){
        System.out.println("汪汪汪");
    }
}
//哈奇士
class haqishi extends Dog {
    public void test(){
        System.out.println(name);
        say();
    }
}

調用haqishi的test()方法，測試如下

小白
汪汪汪

測試結果：子類haqishi繼承了父類的成員變量和成員方法

（三）重寫父類方法
子類haqishi重寫父類Dog的say方法

class Dog{
    public String name="小白";
    public void say(){
        System.out.println("汪汪汪");
    }
}
//哈奇士
class haqishi extends Dog {
    @Override
    public void say() {
        //super.say();    繼承父類原有方法
        System.out.println("哈哈哈");
    }
}

調用子類say方法，測試如下：

哈哈哈

（四）重載父類方法
重載方法必須滿足以下條件：
1、方法名相同
2、方法的參數(shù)類型、個數(shù)、順序至少有一項不同
3、方法的返回類型可以不同
4、方法的修飾符可以不相同

class Dog{
    public String name="小白";
    public void say(){
        System.out.println("汪汪汪");
    }
}
//哈奇士
class haqishi extends Dog {
   //重載 改變參數(shù)
    public void say(String name) {
        System.out.println(name+"汪汪汪");
    }
	//重載 改變參數(shù)+返回值
    public int say(int age) {
        System.out.println("汪汪汪"+age);
        return age;
    }
}

分別調用
haqishi h = new haqishi();
h.say();
h.say(“哈奇士”);
h.say(6);
結果如下：

汪汪汪
哈奇士汪汪汪
汪汪汪6

3、多態(tài)

多態(tài)：對于同一個行為，不同的子類對象具有不同的表現(xiàn)形式。多態(tài)存在的3個條件：
1）繼承 2）重寫 3）父類引用指向子類對象。

public class extend {
    public static void main(String[] args) {
        Animal a = new Dog();
        Animal b = new Cat();
        a.say();
        b.say();
    }
}

abstract class Animal {
    abstract void say();
}
//貓
class Cat extends Animal{
    public String name="小黑";
    public void say(){
        System.out.println("喵喵喵");
    }
}
//狗
class Dog extends Animal{
    public String name="小白";
    public void say(){
        System.out.println("汪汪汪");
    }
}

運行結果

汪汪汪
喵喵喵

理解多態(tài)
在這個運行環(huán)境中，引用變量所指向的具體類型和通過該引用變量發(fā)出的方法調用在編程時并不確定，而是在程序運行期間才確定。Java虛擬機會根據(jù)引用變量指向的對象來調用該對象的指定方法，這種運行機制被稱為動態(tài)綁定

參考文獻：《Java面向對象編程（第2版）》- 孫衛(wèi)琴文章來源地址http://www.zghlxwxcb.cn/news/detail-785220.html

到了這里，關于什么是面向對象，它的三個基本特征：封裝、繼承、多態(tài)的文章就介紹完了。如果您還想了解更多內容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關文章，希望大家以后多多支持TOY模板網(wǎng)！