一、對象的綜述

面向對象編程（OOP）具有多方面的吸引力。對管理人員，它實現了更快和更廉價的開發(fā)與維護過程。對分析與設計人員，建模處理變得更加簡單，能生成清晰、易于維護的設計方案。對程序員，對象模型顯得如此高雅和淺顯。此外，面向對象工具以及庫的巨大威力使編程成為一項更使人愉悅的任務。每個人都可從中獲益，至少表面如此。

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

面向對象的程序便很好的解決了這一問題，程序員可利用程序來表達實際問題中的元素，我們便將這些元素在程序中的表示稱為“對象”。我們可以根據現實中的問題來靈活配置對象，以便與特定的問題配合。與之前的語言相比，這無疑是一種更加靈活、更加強大的語言抽象?？傊甇OP允許我們根據問題來描述問題，而不是根據問題在機器中的方案。與現實世界中的“對象”或者“物體”相比，編程對象與它們也存在共通的地方：它們都有自己的特征和行為。

二、什么是對象

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

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

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

三、面向對象程序設計方法

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

四、對象的使用

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

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

五、封裝

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

封裝的原則：

1. 將不需要對外提供的內容都隱藏起來；

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

簡單示例代碼：

package com.alanlee;

public class Student {

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

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

 //對外提供公有的方法，可以對對象的屬性進行控制，避免不合法的操作
 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());
 }
}

六、繼承

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

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

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

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

簡單示例代碼：

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

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

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

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

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

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

簡單示例代碼：

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

八、抽象類

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

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

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

九、對象在哪里

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

到此這篇關于淺談Java實現面向對象編程java oop的文章就介紹到這了,更多相關Java實現面向對象編程內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

最新評論