一、對象的綜述

面向?qū)ο缶幊蹋∣OP）具有多方面的吸引力。對管理人員，它實現(xiàn)了更快和更廉價的開發(fā)與維護(hù)過程。對分析與設(shè)計人員，建模處理變得更加簡單，能生成清晰、易于維護(hù)的設(shè)計方案。對程序員，對象模型顯得如此高雅和淺顯。此外，面向?qū)ο蠊ぞ咭约皫斓木薮笸κ咕幊坛蔀橐豁椄谷擞鋹偟娜蝿?wù)。每個人都可從中獲益，至少表面如此。

所有編程語言的最終目的都是解決企業(yè)又或者人在現(xiàn)實生活中所遇到的問題，最初我們的程序可能長這樣“11111100001”，相信大家都不會陌生，只是大家沒這么子去敲過代碼。再后來出現(xiàn)了匯編語言，匯編語言便是對基礎(chǔ)機器語言（二進(jìn)制）的少量抽象，再到后來出現(xiàn)了許多“命令式”語言（如FORTRAN、BASIC和C），這些語言便是對匯編語言的一種抽象。這些語言都有了長足的進(jìn)步，但它們的抽象原理依然要求我們著重考慮計算機的結(jié)構(gòu)，而考慮的不是要解決的問題的本身結(jié)構(gòu)。在機器與實際要解決的問題之間，程序員必須建立起一種聯(lián)系，這個過程要求人們付出較大的精力，使得程序代碼很難編寫，寫出來的代碼又很難理解，要花較大的代價進(jìn)行維護(hù)。

面向?qū)ο蟮某绦虮愫芎玫慕鉀Q了這一問題，程序員可利用程序來表達(dá)實際問題中的元素，我們便將這些元素在程序中的表示稱為“對象”。我們可以根據(jù)現(xiàn)實中的問題來靈活配置對象，以便與特定的問題配合。與之前的語言相比，這無疑是一種更加靈活、更加強大的語言抽象。總之OOP允許我們根據(jù)問題來描述問題，而不是根據(jù)問題在機器中的方案。與現(xiàn)實世界中的“對象”或者“物體”相比，編程對象與它們也存在共通的地方：它們都有自己的特征和行為。

二、什么是對象

通過上面的文字或許大家已經(jīng)有些明白什么是對象了吧？而上面的文字也是對對象的一種比較深入的理解，而我們最常見的理解方式無非是：對象(object)是任何看得見、摸得著、感覺得到，可以獲得的東西，有自己的標(biāo)識的任何東西。對象是某一類的事物的具體個例。比如這輛汽車、這個人、這間房子、這張桌子、這株植物、這張支票、這件雨衣，概括來說就是：萬物皆對象。

在這里給大家摘錄一些句子，希望看過的人能夠花時間去思考一下：

①“對象一般以域的形式包含數(shù)據(jù),通常稱作屬性；以程序的形式包含代碼,通常稱作方法”。
②“對象在域中儲存自身狀態(tài)并通過方法暴露自身行為”。
③“每個對象就如一個小型電腦——它有狀態(tài),并且它提供操作,你可以調(diào)用執(zhí)行”。
④“一個類包含了存放數(shù)值的數(shù)據(jù)域和操作數(shù)值的的方法”。
⑤“一個對象就是儲存某些類型的值的內(nèi)存空間”。
⑥“一個對象包含一些私有內(nèi)存空間和一些操作”。

三、面向?qū)ο蟪绦蛟O(shè)計方法

(1)所有東西都是對象?？蓪ο笙胂蟪梢环N新型變量；它保存著數(shù)據(jù)，但可要求它對自身進(jìn)行操作。理論上講，可從要解決的問題身上提出所有概念性的組件，然后在程序中將其表達(dá)為一個對象。
(2)程序是一大堆對象的組合；通過消息傳遞，各對象知道自己該做些什么。為了向?qū)ο蟀l(fā)出請求，需向那個對象“發(fā)送一條消息”。更具體地講，可將消息想象為一個調(diào)用請求，它調(diào)用的是從屬于目標(biāo)對象的一個子例程或函數(shù)。
(3)每個對象都有自己的存儲空間，可容納其他對象?；蛘哒f，通過封裝現(xiàn)有對象，可制作出新型對象。所以，盡管對象的概念非常簡單，但在程序中卻可達(dá)到任意高的復(fù)雜程度。
(4)每個對象都有一種類型。根據(jù)語法，每個對象都是某個“類”的一個“實例”。其中，“類”（Class）是“類型”（Type）的同義詞。一個類最重要的特征就是“能將什么消息發(fā)給它？”。
(5)同一類所有對象都能接收相同的消息。這實際是別有含義的一種說法。由于類型為“圓”（Circle）的一個對象也屬于類型為“形狀”（Shape）的一個對象，所以一個圓完全能接收形狀消息。這意味著可讓程序代碼統(tǒng)一指揮“形狀”，令其自動控制所有符合“形狀”描述的對象，其中自然包括“圓”。這一特性稱為對象的“可替換性”，是OOP 最重要的概念之一。
(6)一些語言設(shè)計者認(rèn)為面向?qū)ο蟮某绦蛟O(shè)計本身并不足以方便解決所有形式的程序問題，提倡將不同的方法組合成“多形程序設(shè)計語言”。

四、對象的使用

下面讓我們以電燈泡為例：

在這個例子中，類型／類的名稱是 Light，可向 Light 對象發(fā)出的請求包括包括打開（ on）、關(guān)閉（ off）、變得更明亮（ brighten ）或者變得更暗淡（ dim）。通過簡單地聲明一個名字（ lt），我們?yōu)?Light 對象創(chuàng)建了一個“句柄”。然后用 new 關(guān)鍵字新建類型為 Light 的一個對象。再用等號將其賦給句柄。為了向?qū)ο蟀l(fā)送一條消息，我們列出句柄名（ lt），再用一個句點符號（ .）把它同消息名稱（ on）連接起來。從中可以看出，使用一些預(yù)先定義好的類時，我們在程序里采用的代碼是非常簡單和直觀的。

五、封裝

封裝，即隱藏對象的屬性和實現(xiàn)細(xì)節(jié)，僅對外公開接口，控制在程序中屬性的讀和修改的訪問級別；將抽象得到的數(shù)據(jù)和行為（或功能）相結(jié)合，形成一個有機的整體，也就是將數(shù)據(jù)與操作數(shù)據(jù)的源代碼進(jìn)行有機的結(jié)合，形成“類”，其中數(shù)據(jù)和函數(shù)都是類的成員。封裝的目的是增強安全性和簡化編程，使用者不必了解具體的實現(xiàn)細(xì)節(jié)，而只是要通過外部接口，以特定的訪問權(quán)限來使用類的成員。隱藏之后，外部程序就不能接觸和改變那些細(xì)節(jié)，所以不用擔(dān)心自己的類會受到非法修改，可確保它們不會對其他程序造成影響。

封裝的原則：

1. 將不需要對外提供的內(nèi)容都隱藏起來；

2. 把屬性都隱藏，提供公共方法對其訪問。

簡單示例代碼：

package com.alanlee;

public class Student {

 //屬性私有化，避免屬性被直接使用和修改
 private Integer age;

 //對外提供公有的方法用來獲取對象的屬性值
 public Integer getAge() {
  return age;
 }

 //對外提供公有的方法，可以對對象的屬性進(jìn)行控制，避免不合法的操作
 public void setAge(Integer age) {
  if(age > 0 && age < 100){
   this.age =age;
  }else{
   System.out.println("輸入的年齡不合法！");
  }
 }

 public static void main(String[] args) {
  Student stu = new Student();
  //賦值
  stu.setAge(10);
  //取值并打印
  System.out.println(stu.getAge());
 }
}

六、繼承

我們費盡心思做出一種數(shù)據(jù)類型后，假如不得不又新建一種類型，令其實現(xiàn)大致相同的功能，那會是一件非常令人灰心的事情。但若能利用現(xiàn)成的數(shù)據(jù)類型，對其進(jìn)行“克隆”，再根據(jù)情況進(jìn)行添加和修改，情況就顯得理想多了。“繼承”正是針對這個目標(biāo)而設(shè)計的。但繼承并不完全等價于克隆。在繼承過程中，若原始類（正式名稱叫作基礎(chǔ)類、超類或父類）發(fā)生了變化，修改過的“克隆”類（正式名稱叫作繼承類或者子類）也會反映出這種變化。在 Java 語言中，繼承是通過 extends 關(guān)鍵字實現(xiàn)的。

使用繼承時，相當(dāng)于創(chuàng)建了一個新類。這個新類不僅包含了現(xiàn)有類型的所有成員（盡管private 成員被隱藏起來，且不能訪問），但更重要的是，它復(fù)制了基礎(chǔ)類的接口。也就是說，可向基礎(chǔ)類的對象發(fā)送的所有消息亦可原樣發(fā)給衍生類的對象。根據(jù)可以發(fā)送的消息，我們能知道類的類型。這意味著衍生類具有與基礎(chǔ)類相同的類型！為真正理解面向?qū)ο蟪绦蛟O(shè)計的含義，首先必須認(rèn)識到這種類型的等價關(guān)系。

由于基礎(chǔ)類和衍生類具有相同的接口，所以那個接口必須進(jìn)行特殊的設(shè)計。也就是說，對象接收到一條特定的消息后，必須有一個“方法”能夠執(zhí)行。若只是簡單地繼承一個類，并不做其他任何事情，來自基礎(chǔ)類接口的方法就會直接照搬到衍生類。這意味著衍生類的對象不僅有相同的類型，也有同樣的行為，這一后果通常是我們不愿見到的。

有兩種做法可將新得的衍生類與原來的基礎(chǔ)類區(qū)分開。第一種做法十分簡單：為衍生類添加新函數(shù)（功能）。這些新函數(shù)并非基礎(chǔ)類接口的一部分。進(jìn)行這種處理時，一般都是意識到基礎(chǔ)類不能滿足我們的要求，所以需要添加更多的函數(shù)。這是一種最簡單、最基本的繼承用法，大多數(shù)時候都可完美地解決我們的問題(添加特定的方法，特殊的方法)。第二種做法是改變基礎(chǔ)類一個現(xiàn)有函數(shù)的行為（重寫父類的方法）。

簡單示例代碼：

public class Animal {
 private String name;
 private int id;
 public Animal(String myName, int myid) {
  name = myName;
  id = myid;
 }
 public void eat(){
  System.out.println(name+"正在吃");
 }
 public void sleep(){
  System.out.println(name+"正在睡");
 }
 public void introduction() {
  System.out.println("大家好！我是"   + id + "號" + name + ".");
 }
}

public class Penguin extends Animal { 
  public Penguin(String myName, int myid) { 
   super(myName, myid); 
  } 
 }

 public class Mouse extends Animal { 
  public Mouse(String myName, int myid) { 
   super(myName, myid); 
  } 
 }

Java是單繼承的，一個類只能繼承一個父類。

七、多態(tài)

多態(tài)是同一個行為具有多個不同表現(xiàn)形式或形態(tài)的能力，多態(tài)就是同一個接口，使用不同的實例而執(zhí)行不同操作，多態(tài)性是對象多種表現(xiàn)形式的體現(xiàn)。

多態(tài)的優(yōu)點：

• 1. 消除類型之間的耦合關(guān)系
• 2. 可替換性
• 3. 可擴(kuò)充性
• 4. 接口性
• 5. 靈活性
• 6. 簡化性

多態(tài)存在的三個必要條件：

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

當(dāng)使用多態(tài)方式調(diào)用方法時，首先檢查父類中是否有該方法，如果沒有，則編譯錯誤；如果有，再去調(diào)用子類的同名方法。

簡單示例代碼：

public class Test {
 public static void main(String[] args) {
  show(new Cat()); // 以 Cat 對象調(diào)用 show 方法
  show(new Dog()); // 以 Dog 對象調(diào)用 show 方法

  Animal a = new Cat(); // 向上轉(zhuǎn)型
  a.eat();    // 調(diào)用的是 Cat 的 eat
  Cat c = (Cat)a;  // 向下轉(zhuǎn)型
  c.work();  // 調(diào)用的是 Cat 的 catchMouse
 }

 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("看家");
 }
}

八、抽象類

設(shè)計程序時，我們經(jīng)常都希望基礎(chǔ)類只為自己的衍生類提供一個接口。也就是說，我們不想其他任何人實際創(chuàng)建基礎(chǔ)類的一個對象，只對上溯造型成它，以便使用它們的接口。為達(dá)到這個目的，需要把那個類變成“抽象”的—— 使用 abstract 關(guān)鍵字。若有人試圖創(chuàng)建抽象類的一個對象，編譯器就會阻止他們。這種工具可有效強制實行一種特殊的設(shè)計。

亦可用 abstract 關(guān)鍵字描述一個尚未實現(xiàn)的方法—— 作為一個“根”使用，指出：“這是適用于從這個類繼承的所有類型的一個接口函數(shù)，但目前尚沒有對它進(jìn)行任何形式的實現(xiàn)?！背橄蠓椒ㄒ苍S只能在一個抽象類里創(chuàng)建。繼承了一個類后，那個方法就必須實現(xiàn)，否則繼承的類也會變成“抽象”類。通過創(chuàng)建一個抽象方法，我們可以將一個方法置入接口中，不必再為那個方法提供可能毫無意義的主體代碼。

interface（接口）關(guān)鍵字將抽象類的概念更延伸了一步，它完全禁止了所有的函數(shù)定義。“接口”是一種相當(dāng)有效和常用的工具。另外如果自己愿意，亦可將多個接口都合并到一起（不能從多個普通 class 或abstract class 中繼承）。比如上面的示例代碼就將父類以及父類的方法進(jìn)行了抽象，因為父類并不需要做任何實際的事情。

九、對象在哪里

對象保存在內(nèi)存堆。一種常規(guī)用途的內(nèi)存池（也在 RAM 區(qū)域），其中保存了 Java 對象。和堆棧不同，“內(nèi)存堆”或“堆”（ Heap）最吸引人的地方在于編譯器不必知道要從堆里分配多少存儲空間，也不必知道存儲的數(shù)據(jù)要在堆里停留多長的時間。因此，用堆保存數(shù)據(jù)時會得到更大的靈活性。要求創(chuàng)建一個對象時，只需用new 命令編制相關(guān)的代碼即可。執(zhí)行這些代碼時，會在堆里自動進(jìn)行數(shù)據(jù)的保存。當(dāng)然，為達(dá)到這種靈活性，必然會付出一定的代價：在堆里分配存儲空間時會花掉更長的時間。

到此這篇關(guān)于淺談Java實現(xiàn)面向?qū)ο缶幊蘪ava oop的文章就介紹到這了,更多相關(guān)Java實現(xiàn)面向?qū)ο缶幊虄?nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評論