畢業(yè)設計外文資料翻譯-Thinking in Java 4th Edition

1、畢業(yè)設計外文資料翻譯學 院： 專業(yè)班級： 學生姓名： 學 號： 指導教師： 外文出處： Thinking in Java 4th Edition 附 件：1.外文資料翻譯譯文； 2.外文原文 指導教師評語：該英文文獻是介紹Java對象基本概念的資料，與畢業(yè)設計所用的技術相關度高。從該生翻譯的內(nèi)容來看，術語翻譯準確度比較高，體現(xiàn)了較強的英語應用水平。翻譯工作認真細致，嚴格按照規(guī)定，翻譯材料能與原文能保持一致，能正確表達出原文意思。簽名： 年 月 日外文資料翻譯譯文Thinking in Java 4th Edition對象入門 “我們自然地減少并將它組織成概念,并賦予意義,很大程度上是因為在我們

2、的語言模式下各方達成一種協(xié)議除了通過訂閱的組織和分類數(shù)據(jù)協(xié)議的法令，否則我們不能交流?！北窘苊骼钗譅柗?1897 - 1941)計算機革命的起源是一臺機器。因此我們的編程語言的起源往往也是這樣的機器。但電腦并不全是機器思維放大工具(史蒂夫喬布斯喜歡說成“頭腦的自行車”)和不同的表達媒介。結果,工具開始看起來不那么像機器,更像我們的思想,也像 其他形式的表達,如寫作、繪畫、雕塑、動畫和電影制作。面向對象編程(OOP)是一部分用計算機作為表達媒介的活動。本章將介紹OOP的基本概念,包括開發(fā)方法的概述。這一章乃至這本書,假設你有編程經(jīng)驗,盡管不一定在C。如果你覺得你需要在開始閱讀這本書之前要在編程上

3、有更多的準備,你應該先看看在C多媒體研討會中思考,它能從www.MindV下載。這一章是背景和補充材料。許多人在不了解大局的情況下涉水面向對象編程不會覺得太容易。因此,這里有許多概念來給你介紹一個完備的OOP的概述。然而,其他人可能不會理解全局概念直到先給他們看的一些結構,這些人可能會變得停滯不前并且失去了一些代碼來讓他們上手。如果你是后者的一部分并渴望得到具體的語言,隨意跳過這章節(jié)-跳過它不會阻止你寫程序或學習語言。然而,你將最終要回到這里來填滿你的知識這樣就你就能理解為什么對象很重要并且如何來設計它們。1.1 抽象的進步 所有編程語言的最終目的都是提供一種“抽象”方法。一種較有爭議的說法是

4、：解決問題的復雜程度直接取 決于抽象的種類及質(zhì)量。這兒的“種類”是指準備對什么進行“抽象”？匯編語言是對基礎機器的少量抽 象。后來的許多“命令式”語言（如FORTRAN，BASIC 和 C）是對匯編語言的一種抽象。與匯編語言相比，這 些語言已有了長足的進步，但它們的抽象原理依然要求我們著重考慮計算機的結構，而非考慮問題本身的結 構。在機器模型（位于“方案空間”）與實際解決的問題模型（位于“問題空間”）之間，程序員必須建立起一種聯(lián)系。這個過程要求人們付出較大的精力，而且由于它脫離了編程語言本身的范圍，造成程序代碼很 難編寫，而且要花較大的代價進行維護。由此造成的副作用便是一門完善的“編程方法”學

5、科。 為機器建模的另一個方法是為要解決的問題制作模型。對一些早期語言來說，如 LISP 和 APL，它們的做法是 “從不同的角度觀察世界”“所有問題都歸納為列表”或“所有問題都歸納為算法”。PROLOG則將所有 問題都歸納為決策鏈。對于這些語言，我們認為它們一部分是面向基于“強制”的編程，另一部分則是專為 處理圖形符號設計的。每種方法都有自己特殊的用途，適合解決某一類的問題。但只要超出了它們力所能及的范圍，就會顯得非常笨拙。 面向對象的程序設計在此基礎上則跨出了一大步，程序員可利用一些工具表達問題空間內(nèi)的元素。由于這種表達非常普遍，所以不必受限于特定類型的問題。我們將問題空間中的元素以及它們在

6、方案空間的表示物稱 作“對象”（Object）。當然，還有一些在問題空間沒有對應體的其他對象。通過添加新的對象類型，程序可進行靈活的調(diào)整，以便與特定的問題配合。所以在閱讀方案的描述代碼時，會讀到對問題進行表達的話語。與我們以前見過的相比，這無疑是一種更加靈活、更加強大的語言抽象方法?？傊?，OOP允許我們根據(jù)問題來描述問題，而不是根據(jù)方案。然而，仍有一個聯(lián)系途徑回到計算機。每個對象都類似一臺小計算機； 它們有自己的狀態(tài)，而且可要求它們進行特定的操作。與現(xiàn)實世界的“對象”或者“物體”相比，編程“對象”與它們也存在共通的地方：它們都有自己的特征和行為。 Alan Kay 總結了 Smalltalk

7、的五大基本特征。這是第一種成功的面向對象程序設計語言，也是Java 的基礎 語言。通過這些特征，我們可理解“純粹”的面向對象程序設計方法是什么樣的： (1)所有東西都是對象?？蓪ο笙胂蟪梢环N新型變量；它保存著數(shù)據(jù)，但可要求它對自身進行操作。理論 上講，可從要解決的問題身上提出所有概念性的組件，然后在程序中將其表達為一個對象。 (2) 程序是一大堆對象的組合；通過消息傳遞，各對象知道自己該做些什么。為了向對象發(fā)出請求，需向那個對象“發(fā)送一條消息”。更具體地講，可將消息想象為一個調(diào)用請求，它調(diào)用的是從屬于目標對象的一個 子例程或函數(shù)。(3) 每個對象都有自己的存儲空間，可容納其他對象?；蛘哒f，通

8、過封裝現(xiàn)有對象，可制作出新型對象。所 以，盡管對象的概念非常簡單，但在程序中卻可達到任意高的復雜程度。 (4) 每個對象都有一種類型。根據(jù)語法，每個對象都是某個“類”的一個“實例”。其中，“類”（Class） 是“類型”（Type）的同義詞。一個類最重要的特征就是“能將什么消息發(fā)給它？”。 (5) 同一類所有對象都能接收相同的消息。這實際是別有含義的一種說法，大家不久便能理解。由于類型為 “圓”（Circle）的一個對象也屬于類型為“形狀”（Shape）的一個對象，所以一個圓完全能接收形狀消 息。這意味著可讓程序代碼統(tǒng)一指揮“形狀”，令其自動控制所有符合“形狀”描述的對象，其中自然包括 “圓”

9、。這一特性稱為對象的“可替換性”，是OOP最重要的概念之一。 一些語言設計者認為面向對象的程序設計本身并不足以方便解決所有形式的程序問題，提倡將不同的方法組 合成“多形程序設計語言”。 對象具有狀態(tài),行為和身份。這意味著一個對象可以有內(nèi)部數(shù)據(jù)(給它狀態(tài))、方法(生產(chǎn)行為),和每個對象可以獨特區(qū)別于其他對象把這放個在一個具體的容器中,在內(nèi)存每個對象都有一個唯一的地址。 1.2 對象的接口 亞里士多德或許是認真研究“類型”概念的第一人，他曾談及“魚類和鳥類”的問題。在世界首例面向對象 語言Simula-67 中，第一次用到了這樣的一個概念： 所有對象盡管各有特色都屬于某一系列對象的一部分，這些對象

10、具有通用的特征和行為。在 Simula-67 中，首次用到了class 這個關鍵字，它為程序引入了一個全新的類型。（clas 和 type 通?？苫Q使 用；注釋）。 ：有些人進行了進一步的區(qū)分，他們強調(diào)“類型”決定了接口，而“類”是那個接口的一種特殊實現(xiàn)方式。Simula是一個很好的例子。正如這個名字所暗示的，它的作用是“模擬”（Simulate）象“銀行出納員”這 樣的經(jīng)典問題。在這個例子里，我們有一系列出納員、客戶、帳號以及交易等。每類成員（元素）都具有一 些通用的特征：每個帳號都有一定的余額；每名出納都能接收客戶的存款；等等。與此同時，每個成員都有 自己的狀態(tài)；每個帳號都有不同的余額；

11、每名出納都有一個名字。所以在計算機程序中，能用獨一無二的實 體分別表示出納員、客戶、帳號以及交易。這個實體便是“對象”，而且每個對象都隸屬一個特定的 “類”，那個類具有自己的通用特征與行為。 因此，在面向對象的程序設計中，盡管我們真正要做的是新建各種各樣的數(shù)據(jù)“類型”（Type），但幾乎所有面向對象的程序設計語言都采用了“class”關鍵字。當您看到“type”這個字的時候，請同時想到 “class”；反之亦然。 由于一個類描述了一組具有相同特征的對象(數(shù)據(jù)元素)和行為(功能),因為一個浮點數(shù)，一個類可是一個數(shù)據(jù)類型,舉個例子,它也有一系列的特征和行為。所不同的是, 一個程序員定義一個類來適應

12、一個問題而不是被迫使用現(xiàn)有的用來代表一個單位的存儲在一臺機器的數(shù)據(jù)類型。你通過添加新的數(shù)據(jù)類型擴展編程語言達到你的特定需要。編程系統(tǒng)歡迎新類并且給他們所有的照顧和類型檢查這樣可以給內(nèi)置類型。面向對象的方法并不局限于創(chuàng)建模擬。無論你是否同意任何程序是一個模擬的系統(tǒng)設計、使用OOP技術可以很容易地大量的問題減少成一個簡單的解決方案。建好一個類后，可根據(jù)情況生成許多對象。隨后，可將那些對象作為要解決問題中存在的元素進行處理。事實上，當我們進行面向對象的程序設計時，面臨的最大一項挑戰(zhàn)性就是：如何在“問題空間”（問題實際存 在的地方）的元素與“方案空間”（對實際問題進行建模的地方，如計算機）的元素之間建

13、立理想的“一對一”對應或映射關系。 如何利用對象完成真正有用的工作呢？必須有一種辦法能向對象發(fā)出請求，令其做一些實際的事情，比如完 成一次交易、在屏幕上畫一些東西或者打開一個開關等等。每個對象僅能接受特定的請求。我們向對象發(fā)出 的請求是通過它的“接口”（Interface）定義的，對象的“類型”或“類”則規(guī)定了它的接口形式?！邦愋汀迸c“接口”的等價或對應關系是面向對象程序設計的基礎。 下面讓我們以電燈泡為例： 接口確定您可以針對特定對象的請求。然而，必須在有代碼的地方才可以滿足這一要求。這包括實施與隱藏的數(shù)據(jù)。從程序設計的角度來看，這并不復雜。類型有一個與每個可能的請求相關聯(lián)的方法，當您對某個

14、對象做了一個特定的請求時，該方法被調(diào)用。這個過程通常是通過說你“發(fā)送消息”（向一個對象發(fā)送一個請求）來概括，并且該對象將處理該消息（它執(zhí)行的代碼）。在這個例子中，類型類的名稱是 Light，可向 Light 對象發(fā)出的請求包括包括打開（on）、關閉（off）、 變得更明亮（brighten）或者變得更暗淡（dim）。通過簡單地聲明一個名字（lt），我們?yōu)?Light 對象創(chuàng)建 了一個“句柄”。然后用new關鍵字新建類型為 Light 的一個對象。再用等號將其賦給句柄。為了向對象發(fā) 送一條消息，我們列出句柄名（lt），再用一個句點符號（.）把它同消息名稱（on）連接起來。從中可以看出，使用一些預

15、先定義好的類時，我們在程序里采用的代碼是非常簡單和直觀的。 前面的圖是統(tǒng)一建模語言（UML）的格式。每一個類代表一個盒子而且在盒子的類型名稱在頂部，任何你關心的數(shù)據(jù)成員會在中間部分的描述，并且方法（屬于這個對象的功能，收到任何消息，你發(fā)送到該對象）在底部的部分。通常，只有類的公共方法的名稱是UML設計圖所顯示的，所以中間的部分是不顯示的，在這種情況下。如果你只對類名稱感興趣，那么下面的部分就不需要顯示了。 HYPERLINK /?aldtype=85&keyfrom=alading l # 1.3對象提供服務當你試圖開發(fā)或理解一個程序設計時，最好的方法之一是把對象當作“服務提供者”，你的程序本

16、身將為用戶提供服務，并且它將使用其他對象提供的服務來實現(xiàn)這個目標。你可以看Introduction to Objects 19 中提及的（甚至更好地定位在現(xiàn)有的代碼庫）一組對象解決問題提供最佳服務。開始做這件事的一個方法是問，“如果我能神奇地把他們從一頂帽子里拉出來，什么東西會馬上解決我的問題？例如，假設你正在創(chuàng)建一個記賬程序。你可能會想到一些對象包含預先定義的記賬式輸入屏幕，另一組的對象執(zhí)行的記賬計算，并且還有一個對象處理印刷的檢查和發(fā)票的所有不同類型的打印機。也許有些對象已經(jīng)存在，對于那些不喜歡的對象，他們會是什么樣子？這些對象提供什么服務，他們需要什么樣的目標來完成他們的義務？如果你繼續(xù)

17、這樣做，你最終會達到一個點，你可以說，“這個對象似乎很簡單，坐下來寫”或“我確信，對象必須存在”這是一個合理的方式來分解成一組問題的對象。思想的對象作為服務供應商有一個額外的好處：它有助于提高對象的凝聚力。高內(nèi)聚性是軟件設計的一個基本品質(zhì)：它意味著軟件組件的各個方面（例如一個對象，雖然這也適用于一個方法或一個對象庫）“適合”。一個問題就是在設計對象時就已經(jīng)把太多的功能放到一個對象。例如，在您的支票打印模塊，您可以決定您需要一個對象，知道所有的格式化和打印。你可能會發(fā)現(xiàn)，這對于一個對象來說太多了，你需要的是三個或更多的對象。一個對象可以是一個所有檢查布局的目錄，它可以查詢有關如何打印檢查的信息。

18、一個對象或一組對象可以是一個通用的打印接口，知道所有的不同類型的打印機（但沒有什么關于記帳這一個是購買而不是寫自己的候選人）。三個對象之中的任何一個對象可以使用其他的服務來完成任務。因此，每一個對象都有一個集合的服務提供。在一個良好的面向對象的設計中，每一個對象做一件事，但不會試圖做太多。這不僅允許現(xiàn)有的對象可以能夠購買（打印機接口對象），但它也產(chǎn)生新的對象，可能會再利用其他地方（檢查布局的目錄）。把對象作為服務提供者是一個很好的簡化工具。這不僅是在設計過程中游泳，而且在當別人試圖理解你的代碼或重用一個對象時也有用。如果他們能看到這個對象的價值，根據(jù)它提供的服務，它可以更容易地把它自己融入到設

19、計中去。 HYPERLINK /?aldtype=85&keyfrom=alading l # 1.4 HYPERLINK /?aldtype=85&keyfrom=alading l # o 清空 隱藏的實現(xiàn) 為方便后面的討論，讓我們先對這一領域的從業(yè)人員作一下分類。從根本上說，大致有兩方面的人員涉足面向對象的編程：“類創(chuàng)建者”（創(chuàng)建新數(shù)據(jù)類型的人）以及“客戶程序員”（在自己的應用程序中采用現(xiàn)成數(shù)據(jù)類型的人）。 對客戶程序員來講，最主要的目標就是收集一個充斥著各種類的編程“工具箱”，以便快速開發(fā)符合自己要求的應用。而對類創(chuàng)建者來說，他們的目標則是從頭構建一個類，只向客戶程序員開放有必要開放的

20、東西（接口），其他所有細節(jié)都隱藏起來。為什么要這樣做？隱藏之后，客戶程序員就不能接觸和改變那些細節(jié)，所以原創(chuàng)者不用擔心自己的作品會受到非法修改，可確保它們不會對其他人造成影響?！敖涌凇保?Interface）規(guī)定了可對一個特定的對象發(fā)出哪些請求。然而，必須在某個地方存在著一些代碼，以便滿足這些請求。這些代碼與那些隱藏起來的數(shù)據(jù)便叫作“隱藏的實現(xiàn)”。站在程式化程序編寫（ Procedural Programming ）的角度，整個問題并不顯得復雜。一種類型含有與每種可能的請求關聯(lián)起來的函數(shù)。一旦向對象發(fā)出一個特定的請求，就會調(diào)用那個函數(shù)。我們通常將這個過程總結為向對象“發(fā)送一條消息”（提出一個請

21、求）。對象的職責就是決定如何對這條消息作出反應（執(zhí)行相應的代碼）。對于任何關系，重要一點是讓牽連到的所有成員都遵守相同的規(guī)則。創(chuàng)建一個庫時，相當于同客戶程序員建立了一種關系。 對方也是程序員，但他們的目標是組合出一個特定的應用（程序），或者用您的庫構建一個更大的庫。若任何人都能使用一個類的所有成員，那么客戶程序員可對那個類做任何事情，沒有辦法強制他們遵守任何約束。即便非常不愿客戶程序員直接操作類內(nèi)包含的一些成員，但倘若未進行訪問控制，就沒有辦法阻止這一情況的發(fā)生 所有東西都會暴露無遺。有兩方面的原因促使我們控制對成員的訪問。第一個原因是防止程序員接觸他們不該接觸的東西 通常是內(nèi)部數(shù)據(jù)類型的設計

22、思想。若只是為了解決特定的問題，用戶只需操作接口即可，毋需明白這些信息。我們向用戶提供的實際是一種服務，因為他們很容易就可看出哪些對自己非常重要，以及哪些可忽略不計。進行訪問控制的第二個原因是允許庫設計人員修改內(nèi)部結構，不用擔心它會對客戶程序員造成什么影響。例如，我們最開始可能設計了一個形式簡單的類，以便簡化開發(fā)。以后又決定進行改寫，使其更快地運行。若接口與實現(xiàn)方法早已隔離開，并分別受到保護，就可放心做到這一點，只要求用戶重新鏈接一下即可。Java 采用三個顯式（明確）關鍵字以及一個隱式（暗示）關鍵字來設置類邊界： public，private，protected 以及暗示性的 friendl

23、y。若未明確指定其他關鍵字，則默認為后者。這些關鍵字的使用和含義都是相當直觀的，它們決定了誰能使用后續(xù)的定義內(nèi)容?！皃ublic”（公共）意味著后續(xù)的定義任何人均可使用。而在另一方面，“private”（私有）意味著除您自己、類型的創(chuàng)建者以及那個類型的內(nèi)部函數(shù)成員，其他任何人都不能訪問后續(xù)的定義信息。 private 在您與客戶程序員之間豎起了一堵墻。若有人試圖訪問私有成員，就會得到一個編譯期錯誤?！癴riendly ”（友好的）涉及“包裝”或“封裝”（Package）的概念即 Java 用來構建庫的方法。若某樣東西是“友好的”，意味著它只能在這個包裝的范圍內(nèi)使用（所以這一訪問級別有時也叫作“

24、包裝訪問”）?！?protected”（受保護的）與“ private”相似，只是一個繼承的類可訪問受保護的成員，但不能訪問私有成員。繼承的問題不久就要談到。2.外文原文Introduction to Objects“We cut nature up, organize it into concepts, and ascribe significances as we do, largely because we are parties to an agreement that holds throughout our speech community and is codified in t

25、he patterns of our language we cannot talk at all except by subscribing to the organization and classification of data which the agreement decrees.”Benjamin Lee Whorf (1897-1941)The genesis of the computer revolution was in a machine. The genesis of our programming languages thus tends to look like

26、that machine. But computers are not so much machines as they are mind amplification tools (“bicycles for the mind,” as Steve Jobs is fond of saying) and a different kind of expressive medium. As a result, the tools are beginning to look less like machines and more like parts of our minds, and also l

27、ike other forms of expression such as writing, painting, sculpture, animation, and filmmaking. Object-oriented programming (OOP) is part of this movement toward using the computer as an expressive medium.This chapter will introduce you to the basic concepts of OOP, including an overview of developme

28、nt methods. This chapter, and this book, assumes that you have someprogramming experience, although not necessarily in C. If you think you need morepreparation in programming before tackling this book, you should work through theThinking in C multimedia seminar, downloadable from HYPERLINK http:/www

29、.MindV. www.MindV.This chapter is background and supplementary material. Many people do not feel comfortable wading into object-oriented programming without understanding the big picture first. Thus, there are many concepts that are introduced here to give you a solid overview of OOP. However, other

30、 people may not get the big picture concepts until theyve seen some of the mechanics first; these people may become bogged down and lost without some code to get their hands on. If youre part of this latter group and are eager to get to the specifics of the language, feel free to jump past this chap

31、terskipping it at this point will not prevent you from writing programs or learning the language. However, you will want to come back here eventually to fill in your knowledge so you can understand why objects are important and how to design with them.The progress of abstractionAll programming langu

32、ages provide abstractions. It can be argued that the complexity of the problems youre able to solve is directly related to the kind and quality of abstraction. By “kind” I mean, “What is it that you are abstracting?” Assembly language is a small abstraction of the underlying machine. Many so-called

33、“imperative” languages that followed (such as FORTRAN, BASIC, and C) were abstractions of assembly language. These languages are big improvements over assembly language, but their primary abstraction still requires you to think in terms of the structure of the computer rather than the structure of t

34、he problem you are trying to solve. The programmer must establish the association between the machinemodel (in the “solution space,” which is the place where youre implementing that solution, such as a computer) and the model of the problem that is actually being solved (in the 16 Thinking in Java B

35、ruce Eckel “problem space,” which is the place where the problem exists, such as a business). The effort required to perform this mapping, and the fact that it is extrinsic to the programming language, produces programs that are difficult to write and expensive to maintain, and as a side effect crea

36、ted the entire “programming methods” industry.The alternative to modeling the machine is to model the problem youre trying to solve. Early languages such as LISP and APL chose particular views of the world (“All problems are ultimately lists” or “All problems are algorithmic,” respectively). Prolog

37、casts all problems into chains of decisions. Languages have been created for constraint-based programming and for programming exclusively by manipulating graphical symbols. (The latter proved to be too restrictive.) Each of these approaches may be a good solution to the particular class of problem t

38、heyre designed to solve, but when you step outside of that domain they become awkward.The object-oriented approach goes a step further by providing tools for the programmer to represent elements in the problem space. This representation is general enough that the programmer is not constrained to any

39、 particular type of problem. We refer to the elements in the problem space and their representations in the solution space as “objects.” (You will also need other objects that dont have problem-space analogs.) The idea is that the program is allowed to adapt itself to the lingo of the problem by add

40、ing new types of objects, so when you read the code describing the solution, youre reading words that also express the problem. This is a more flexible and powerful language abstraction than what weve had before.1 Thus, OOP allows you to describe the problem in terms of the problem, rather than in t

41、erms of the computer where the solution will run. Theres still a connection back to the computer: Each object looks quite a bit like a little computerit has a state, and it hasoperations that you can ask it to perform. However, this doesnt seem like such a bad analogy to objects in the real worldthe

42、y all have characteristics and behaviors.Alan Kay summarized five basic characteristics of Smalltalk, the first successful objectoriented language and one of the languages upon which Java is based. These characteristics represent a pure approach to object-oriented programming:1. Everything is an obj

43、ect. Think of an object as a fancy variable; it stores data, but you can “make requests” to that object, asking it to perform operations on itself. In theory, you can take any conceptual component in the problem youre trying to solve (dogs, buildings, services, etc.) and represent it as an object in

44、 your program.2. A program is a bunch of objects telling each other what to do by sending messages. To make a request of an object, you “send a message” to that object. More concretely, you can think of a message as a request to call a method that belongs to a particular object.3. Each object has it

45、s own memory made up of other objects. Put another way, you create a new kind of object by making a package containing existing objects. Thus, you can build complexity into a program while hiding it behind the simplicity of objects.4. Every object has a type. Using the parlance, each object is an in

46、stance of a class, in which “class” is synonymous with “type.” The most important distinguishing characteristic of a class is “What messages can you send to it?”5. All objects of a particular type can receive the same messages. This is actually a loaded statement, as you will see later. Because an o

47、bject of type “circle” is also an object of type “shape,” a circle is guaranteed to accept shape messages. This means you can write code that talks to shapes and automatically handle anything thatfits the description of a shape. This substitutability is one of the powerful concepts in OOP.Booch offe

48、rs an even more succinct description of an object:An object has state, behavior and identity.This means that an object can have internal data (which gives it state), methods (to produce behavior), and each object can be uniquely distinguished from every other objectto put this in a concrete sense, e

49、ach object has a unique address in memory.2An object has an interfaceAristotle was probably the first to begin a careful study of the concept of type; he spoke of “the class of fishes and the class of birds.” The idea that all objects, while being unique, are also part of a class of objects that hav

50、e characteristics and behaviors in common was used directly in the first object-oriented language, Simula-67, with its fundamental keyword class that introduces a new type into a program.Simula, as its name implies, was created for developing simulations such as the classic “bank teller problem.” In

51、 this, you have numerous tellers, customers, accounts, transactions, and units of moneya lot of “objects.” Objects that are identical except for their state during a programs execution are grouped together into “classes of objects,” and thats where the keyword class came from. Creating abstract data

52、 types (classes) is a fundamental concept in object-oriented programming. Abstract data types work almost exactly like built-in types: You can create variables of a type (called objects or instances in object-oriented parlance) and manipulate those variables (called sending messages or requests; you

53、 send a message and the object figures out what to do with it). The members (elements) of each class share some commonality: Every account has a balance, every teller can accept a deposit, etc. At the same time, each member has its own state: Each account has a different balance, each teller has a n

54、ame. Thus, the tellers, customers, accounts, transactions, etc., can each be represented with a unique entity in the computer program. This entity is the object, and each object belongs to a particular class that defines its characteristics and behaviors.So, although what we really do in object-orie

55、nted programming is create new data types, virtually all object-oriented programming languages use the “class” keyword. When you see the word “type” think “class” and vice versa.3Since a class describes a set of objects that have identical characteristics (data elements) and behaviors (functionality

56、), a class is really a data type because a floating point number, for example, also has a set of characteristics and behaviors. The difference is that a programmer defines a class to fit a problem rather than being forced to use an existing data type that was designed to represent a unit of storage

57、in a machine. You extend the programming language by adding new data types specific to your needs. The programming system welcomes the new classes and gives them all the care and type checking that it gives to built-in types.The object-oriented approach is not limited to building simulations. Whethe

58、r or not you agree that any program is a simulation of the system youre designing, the use of OOP techniques can easily reduce a large set of problems to a simple solution.Once a class is established, you can make as many objects of that class as you like, and then manipulate those objects as if the

59、y are the elements that exist in the problem you are trying to solve. Indeed, one of the challenges of object-oriented programming is to create a one-toone mapping between the elements in the problem space and objects in the solution space. But how do you get an object to do useful work for you? The

60、re needs to be a way to make a request of the object so that it will do something, such as complete a transaction, draw something on the screen, or turn on a switch. And each object can satisfy only certain requests. The requests you can make of an object are defined by its interface, and the type i