程序員對象的含義

㈠ 程序員能成為很多女生結婚對象的不二人選，這是為什麼

高中的教育告訴我們，不能孤立、形而上學看問題，而是要一分為二、從實際的因果來考慮問題，「程序員是不是理想的伴侶」這個問題就很容易陷入生硬的思維陷阱，而忽略他其他更加重要的首要標簽。我雖然不是程序員，但是身邊有關系很好的程序員朋友，可以從他們的職業要求，和性格特點來解釋他們的優點與缺點，但是一定要注意，不要孤立、靜止、僵硬地看問題。

㈡ 電腦培訓分享程序員需要了解的10個面向對象設計

面向對象設計原則是OOPS編程的核心，學習面向對象編程像「抽象」、「封裝」、「多態」、「繼承」等基礎知識是重要的，但同時為了創建簡潔、模塊化的設計，了解這些設計原則也同等重要。

(設計原則)底線是永遠追求高內聚、低耦合的編碼或設計。Apache和Sun的開源代碼是學習和OOPS設計原則的良好範例。它們向我們展示了，設計原則在編程中是如何使用的。JDK使用了一些設計原則：BorderFactory類中的工廠模式、Runtime類中的單例模式、.io類中的裝飾器模式。順便說一句，如果您真的對編碼原則感興趣，請閱讀JoshuaBloch的Effective，他編寫過API。我個人最喜歡的關於面向對象設計模式的是KathySierra的HeadFirstDesignPattern(深入淺出設計模式)，以及其它的關於深入淺出面向對象分析和設計。這些書對編寫更好的代碼有很大幫助，充分利用各種面向對象和SOLID的設計模式。

雖然學習設計模式(原則)最好的方法是現實中的例子和理解違反設計原則帶來的不便，本文的宗旨是向那些沒有接觸過或正處於學習階段的程序員介紹面向對象設計原則。

DRY_Don』trepeatyourself

我們第一個面向對象設計原則是：DRY，從名稱可以看出DRY(don』trepeatyourself)意思是不寫重復代碼，而是抽象成可復用的代碼塊。如果您有兩處以上相同的代碼塊，請考慮把它們抽象成一個單獨的方法；或者您多次使用了硬編碼的值，請把它們設置成公共常量。這種面向對象設計原則的優點是易於維護。重要的是不要濫用此原則，重復不是針對代碼而是針對功能來說。它的意思是，如果您使用通用代碼來驗證OrderID和SSN，這並不意味著它們是相同的或者他們今後將保持不變。通過把通用代碼用於實現兩種不同的功能，或者您把這兩種不同的功能密切地聯系在一起；當您的OrderID格式改變時，您的SSN驗證代碼將會中斷。所以要當心這種耦合，而且不要把彼此之間沒有任何關系卻類似的代碼組合在一起。

封裝經常修改的代碼

EncapsulateWhatChanges

在軟體領域永遠不變的是「變化」，所以把您認為或懷疑將來要被修改的代碼封裝起來。這種面向對象設計模式的優點是：易於測試和維護恰當封裝的代碼。如果您在用編程，那麼請遵守以下原則：變數和方法的訪問許可權默認設置為私有，並且逐步放開它們的訪問許可權，例如從「private」到「protected」、「notpublic」。中的一些設計模式使用了封裝，工廠設計模式就是一個例子，它封裝了創建對象的代碼而且提供了以下靈活性：後續生成新對象不影響現有的代碼。

打開/關閉設計原則

OpenClosedDesignPrinciple

類、方法/函數應當是對擴展(新功能)開放，對修改閉合。這是另外一個優雅的SOLID設計原則，以防止有人修改通過測試的代碼。理想情況下假如您添加了新功能，那麼您的代碼要經過測試，這就是打開/關閉設計原則的目標。順便說一句，SOLID中的字母「O」指的是打開/關閉設計原則。

單一職責原則

SingleResponsibilityPrinciple(SRP)

單一職責原則是另外一個SOLID設計原則，SOLID中的字母「S」指的就是它。按照SRP，一個類修改的原因應當有且只有一個，或者一個類應當總是實現單一功能。如果您在中的一個類實現了多個功能，那麼這些功能之間便產生了耦合關系；如果您修改其中的一個功能，您有可能就打破了這種耦合關系，那麼就要進行另一輪測試以避免產生新的問題。

依賴注入/反轉原則

不要問框架的依賴注入功能將會給你帶來什麼益處，依賴注入功能在spring框架里已經很好的得到了實現，這一設計原則的優雅之處在於：DI框架注入的任何一個類都易於用模擬對象進行測試，並且更易於維護，因為創建對象的代碼在框架里是集中的而且和客戶端代碼是隔離的。有多種方法可以實現依賴注入，例如使用位元組碼工具，其中一些AOP(面向切面編程)框架如切入點表達式或者spring里使用的代理。想對這種SOLID設計原則了解更多，請看IOC和DI設計模式中的例子。SOLID中的字母「D」指的就是這種設計原則。

優先使用組合而非繼承

ForCompositionoverInheritance

如果可以的話，要優先使用組合而非繼承。你們中的一些人可能為此爭論，但我發現組合比繼承更有靈活性。組合允許在運行時通過設置屬性修改一個類的行為，通過使用多態即以介面的形式實現類之間的組合關系，並且為修改組合關系提供了靈活性。甚至Effective也建議優先使用組合而非繼承。

里氏替換原則

根據里氏替換原則，父類出現的地方可以用子類來替換，例如父類的方法或函數被子類對象替換應該沒有任何問題。LSP和單一職責原則、介面隔離原則密切相關。如果一個父類的功能比其子類還要多，那麼它可能不支持這一功能，而且也違反了LSP設計原則。為了遵循LSPSOLID設計原則，派生類或子類(相對父類比較)必須增強功能，而非減少。SOLID中的字母「L」指的就是LSP設計原則。

介面隔離原則

介面隔離原則指，如果不需要一個介面的功能，那麼就不要實現此介面。這大多在以下情況發生：一個介麵包含多種功能，而實現類只需要其中一種功能。介面設計是一種棘手的工作，因為一旦發布了介面，您就不能修改它否則會影響實現該介面的類。在中這種設計原則的另一個好處是：介面有一個特點，任何類使用它之前都要實現該介面所有的方法，所以使用功能單一的介面意味著實現更少的方法。

編程以介面(而非實現對象)為中心

編程總是以介面(而非實現對象)為中心，這會使代碼的結構靈活，而且任何一個新的介面實現對象都能兼容現有代碼結構。所以在中，變數、方法返回值、方法參數的數據類型請使用介面。這是許多程序員的建議，Effective以及headfirstdesignpattern等書也這樣建議。

代理原則

不要期望一個類完成所有的功能，電腦培訓http://www.kmbdqn.com/認為可以適當地把一些功能交給代理類實現。代理原則的典範是：中的equals()和hashCode()方法。為了比較兩個對象的內容是否相同，我們讓用於比較的類本身完成對比工作而非它們的調用方。這種設計原則的好處是：沒有重復編碼而且很容易修改類的行為。

㈢ 程序員new對象是什麼梗

意思是：嘲諷程序員不用找對象，直接new一個對象。

提到程序員，很多人都會有一個刻板印象：呆板、木訥、不懂浪漫。甚至女生都會覺得，戀愛千萬不要找一個程序員，不然所有對戀愛的美好憧憬都會消失。

你印象里的程序員是穿著格子襯衫，戴著黑框眼鏡，只會敲擊鍵盤的樣子。但其實程序員的浪漫，是你們想像不到的。不知道你們有沒有看過程序員的情書，程序員的浪漫情話，就是由那些看起來枯燥的代碼組成的。

有網友說，感覺自己的高智商，在程序員男友面前就好像成了傻子。電腦網站進不去無法工作時，他會說一句「我來搞定」；找不到某一個文件或者網址的時候，他會說一句「交給我」。

明明自己是一個獨立性很強的女生，但只要普通的一句話一個問題，他就會分分鍾用他的高智商來搞定。網友說：在他面前，我不具備獨立思考和解決問題的能力。

程序員的工作辛苦程度和他們的收入其實成正比。我們會發現程序員經常會加班、忙著修復bug、甚至幾天不睡覺，但是不得不承認他們的工資收入很可觀。

有一個女生說，結婚之前她就知道男友的收入是她的兩倍，但他從來不懂節省。對於那些新款的手機或其他，他們只有想不想買。對於租的房子，也不怎麼在意價格，住著市中心。

但是領完證，他就好像變了一個人，開始計算自己的收入開支，甚至連游戲都不再充錢了。他說：以後不是我一個人的生活了，我得考慮我的家庭。

所以，程序員哪裡不懂愛情，他們心裡比誰都清楚什麼最重要。

我在知乎上看到一篇程序員寫的內容，標題是程序員能給女朋友做什麼浪漫的禮物。那篇文章是一篇教程文，詳細寫了如何製作一個能夠延時開關的燈。

起因是他的女朋友說了一句話：如果可以開著燈睡覺就好了，等我睡著了它就會自動斷電。所以他便開始研究這個能夠延時開關的燈，該如何製作。他一邊設計，一邊詢問女友的需求。

他說：我的目標用戶只有一個人。你看，雖然是一篇看起來枯燥的教程文，卻因為這樣一個前提多了幾分的浪漫。

別人也許會送你花、送你化妝品，而他卻只想讓自己的「目標用戶」過的更加舒心和自在。

㈣ java中對象有什麼用

一切都是對象

「盡管以C++為基礎，但Java是一種更純粹的面向對象程序設計語言」。
無論C++還是Java都屬於雜合語言。但在Java中，設計者覺得這種雜合並不象在C++里那麼重要。雜合語言允許採用多種編程風格；之所以說C++是一種雜合語言，是因為它支持與C語言的向後兼容能力。由於C++是C的一個超集，所以包含的許多特性都是後者不具備的，這些特性使C++在某些地方顯得過於復雜。
Java語言首先便假定了我們只希望進行面向對象的程序設計。也就是說，正式用它設計之前，必須先將自己的思想轉入一個面向對象的世界（除非早已習慣了這個世界的思維方式）。只有做好這個准備工作，與其他OOP語言相比，才能體會到Java的易學易用。在本章，我們將探討Java程序的基本組件，並體會為什麼說Java乃至Java程序內的一切都是對象。

2.1 用句柄操縱對象
每種編程語言都有自己的數據處理方式。有些時候，程序員必須時刻留意准備處理的是什麼類型。您曾利用一些特殊語法直接操作過對象，或處理過一些間接表示的對象嗎（C或C++里的指針）？
所有這些在Java里都得到了簡化，任何東西都可看作對象。因此，我們可採用一種統一的語法，任何地方均可照搬不誤。但要注意，盡管將一切都「看作」對象，但操縱的標識符實際是指向一個對象的「句柄」（Handle）。在其他Java參考書里，還可看到有的人將其稱作一個「引用」，甚至一個「指針」。可將這一情形想像成用遙控板（句柄）操縱電視機（對象）。只要握住這個遙控板，就相當於掌握了與電視機連接的通道。但一旦需要「換頻道」或者「關小聲音」，我們實際操縱的是遙控板（句柄），再由遙控板自己操縱電視機（對象）。如果要在房間里四處走走，並想保持對電視機的控制，那麼手上拿著的是遙控板，而非電視機。
此外，即使沒有電視機，遙控板亦可獨立存在。也就是說，只是由於擁有一個句柄，並不表示必須有一個對象同它連接。所以如果想容納一個詞或句子，可創建一個String句柄：
String s;
但這里創建的只是句柄，並不是對象。若此時向s發送一條消息，就會獲得一個錯誤（運行期）。這是由於s實際並未與任何東西連接（即「沒有電視機」）。因此，一種更安全的做法是：創建一個句柄時，記住無論如何都進行初始化：
String s = "asdf";
然而，這里採用的是一種特殊類型：字串可用加引號的文字初始化。通常，必須為對象使用一種更通用的初始化類型。

2.2 所有對象都必須創建
創建句柄時，我們希望它同一個新對象連接。通常用new關鍵字達到這一目的。new的意思是：「把我變成這些對象的一種新類型」。所以在上面的例子中，可以說：
String s = new String("asdf");
它不僅指出「將我變成一個新字串」，也通過提供一個初始字串，指出了「如何生成這個新字串」。
當然，字串（String）並非唯一的類型。Java配套提供了數量眾多的現成類型。對我們來講，最重要的就是記住能自行創建類型。事實上，這應是Java程序設計的一項基本操作，是繼續本書後余部分學習的基礎。

2.2.1 保存到什麼地方
程序運行時，我們最好對數據保存到什麼地方做到心中有數。特別要注意的是內存的分配。有六個地方都可以保存數據：
(1) 寄存器。這是最快的保存區域，因為它位於和其他所有保存方式不同的地方：處理器內部。然而，寄存器的數量十分有限，所以寄存器是根據需要由編譯器分配。我們對此沒有直接的控制權，也不可能在自己的程序里找到寄存器存在的任何蹤跡。
(2) 堆棧。駐留於常規RAM（隨機訪問存儲器）區域，但可通過它的「堆棧指針」獲得處理的直接支持。堆棧指針若向下移，會創建新的內存；若向上移，則會釋放那些內存。這是一種特別快、特別有效的數據保存方式，僅次於寄存器。創建程序時，Java編譯器必須准確地知道堆棧內保存的所有數據的「長度」以及「存在時間」。這是由於它必須生成相應的代碼，以便向上和向下移動指針。這一限制無疑影響了程序的靈活性，所以盡管有些Java數據要保存在堆棧里——特別是對象句柄，但Java對象並不放到其中。
(3) 堆。一種常規用途的內存池（也在RAM區域），其中保存了Java對象。和堆棧不同，「內存堆」或「堆」（Heap）最吸引人的地方在於編譯器不必知道要從堆里分配多少存儲空間，也不必知道存儲的數據要在堆里停留多長的時間。因此，用堆保存數據時會得到更大的靈活性。要求創建一個對象時，只需用new命令編制相關的代碼即可。執行這些代碼時，會在堆里自動進行數據的保存。當然，為達到這種靈活性，必然會付出一定的代價：在堆里分配存儲空間時會花掉更長的時間！
(4) 靜態存儲。這兒的「靜態」（Static）是指「位於固定位置」（盡管也在RAM里）。程序運行期間，靜態存儲的數據將隨時等候調用。可用static關鍵字指出一個對象的特定元素是靜態的。但Java對象本身永遠都不會置入靜態存儲空間。
(5) 常數存儲。常數值通常直接置於程序代碼內部。這樣做是安全的，因為它們永遠都不會改變。有的常數需要嚴格地保護，所以可考慮將它們置入只讀存儲器（ROM）。
(6) 非RAM存儲。若數據完全獨立於一個程序之外，則程序不運行時仍可存在，並在程序的控制范圍之外。其中兩個最主要的例子便是「流式對象」和「固定對象」。對於流式對象，對象會變成位元組流，通常會發給另一台機器。而對於固定對象，對象保存在磁碟中。即使程序中止運行，它們仍可保持自己的狀態不變。對於這些類型的數據存儲，一個特別有用的技巧就是它們能存在於其他媒體中。一旦需要，甚至能將它們恢復成普通的、基於RAM的對象。Java 1.1提供了對Lightweight persistence的支持。未來的版本甚至可能提供更完整的方案。

2.2.2 特殊情況：主要類型
有一系列類需特別對待；可將它們想像成「基本」、「主要」或者「主」（Primitive）類型，進行程序設計時要頻繁用到它們。之所以要特別對待，是由於用new創建對象（特別是小的、簡單的變數）並不是非常有效，因為new將對象置於「堆」里。對於這些類型，Java採納了與C和C++相同的方法。也就是說，不是用new創建變數，而是創建一個並非句柄的「自動」變數。這個變數容納了具體的值，並置於堆棧中，能夠更高效地存取。
Java決定了每種主要類型的大小。就象在大多數語言里那樣，這些大小並不隨著機器結構的變化而變化。這種大小的不可更改正是Java程序具有很強移植能力的原因之一。

主類型

大小

最小值

最大值

封裝器類型

boolean

1-bit

–

–

Boolean

char

16-bit

Unicode 0

Unicode 216- 1

Character

byte

8-bit

-128

+127

Byte[11]

short

16-bit

-215

+215 – 1

Short1

int

32-bit

-231

+231 – 1

Integer

long

64-bit

-263

+263 – 1

Long

float

32-bit

IEEE754

IEEE754

Float

double

64-bit

IEEE754

IEEE754

Double

void

–

–

–

Void1

①：到Java 1.1才有，1.0版沒有。

數值類型全都是有符號（正負號）的，所以不必費勁尋找沒有符號的類型。
主數據類型也擁有自己的「封裝器」（wrapper）類。這意味著假如想讓堆內一個非主要對象表示那個主類型，就要使用對應的封裝器。例如：
char c = 'x';
Character C = new Character('c');
也可以直接使用：
Character C = new Character('x');
這樣做的原因將在以後的章節里解釋。

1. 高精度數字
Java 1.1增加了兩個類，用於進行高精度的計算：BigInteger和BigDecimal。盡管它們大致可以劃分為「封裝器」類型，但兩者都沒有對應的「主類型」。
這兩個類都有自己特殊的「方法」，對應於我們針對主類型執行的操作。也就是說，能對int或float做的事情，對BigInteger和BigDecimal一樣可以做。只是必須使用方法調用，不能使用運算符。此外，由於牽涉更多，所以運算速度會慢一些。我們犧牲了速度，但換來了精度。
BigInteger支持任意精度的整數。也就是說，我們可精確表示任意大小的整數值，同時在運算過程中不會丟失任何信息。
BigDecimal支持任意精度的定點數字。例如，可用它進行精確的幣值計算。
至於調用這兩個類時可選用的構建器和方法，請自行參考聯機幫助文檔。

2.2.3 Java的數組
幾乎所有程序設計語言都支持數組。在C和C++里使用數組是非常危險的，因為那些數組只是內存塊。若程序訪問自己內存塊以外的數組，或者在初始化之前使用內存（屬於常規編程錯誤），會產生不可預測的後果（注釋②）。

②：在C++里，應盡量不要使用數組，換用標准模板庫（Standard TemplateLibrary）里更安全的容器。

Java的一項主要設計目標就是安全性。所以在C和C++里困擾程序員的許多問題都未在Java里重復。一個Java可以保證被初始化，而且不可在它的范圍之外訪問。由於系統自動進行范圍檢查，所以必然要付出一些代價：針對每個數組，以及在運行期間對索引的校驗，都會造成少量的內存開銷。但由此換回的是更高的安全性，以及更高的工作效率。為此付出少許代價是值得的。
創建對象數組時，實際創建的是一個句柄數組。而且每個句柄都會自動初始化成一個特殊值，並帶有自己的關鍵字：null（空）。一旦Java看到null，就知道該句柄並未指向一個對象。正式使用前，必須為每個句柄都分配一個對象。若試圖使用依然為null的一個句柄，就會在運行期報告問題。因此，典型的數組錯誤在Java里就得到了避免。
也可以創建主類型數組。同樣地，編譯器能夠擔保對它的初始化，因為會將那個數組的內存劃分成零。
數組問題將在以後的章節里詳細討論。

2.3 絕對不要清除對象
在大多數程序設計語言中，變數的「存在時間」（Lifetime）一直是程序員需要著重考慮的問題。變數應持續多長的時間？如果想清除它，那麼何時進行？在變數存在時間上糾纏不清會造成大量的程序錯誤。在下面的小節里，將闡示Java如何幫助我們完成所有清除工作，從而極大了簡化了這個問題。

2.3.1 作用域
大多數程序設計語言都提供了「作用域」（Scope）的概念。對於在作用域里定義的名字，作用域同時決定了它的「可見性」以及「存在時間」。在C，C++和Java里，作用域是由花括弧的位置決定的。參考下面這個例子：

{
int x = 12;
/* only x available */
{
int q = 96;
/* both x & q available */
}
/* only x available */
/* q 「out of scope」 */
}
作為在作用域里定義的一個變數，它只有在那個作用域結束之前才可使用。
在上面的例子中，縮進排版使Java代碼更易辨讀。由於Java是一種形式自由的語言，所以額外的空格、製表位以及回車都不會對結果程序造成影響。
注意盡管在C和C++里是合法的，但在Java里不能象下面這樣書寫代碼：

{
int x = 12;
{
int x = 96; /* illegal */
}
}
編譯器會認為變數x已被定義。所以C和C++能將一個變數「隱藏」在一個更大的作用域里。但這種做法在Java里是不允許的，因為Java的設計者認為這樣做使程序產生了混淆。

2.3.2 對象的作用域
Java對象不具備與主類型一樣的存在時間。用new關鍵字創建一個Java對象的時候，它會超出作用域的范圍之外。所以假若使用下面這段代碼：

{
String s = new String("a string");
} /* 作用域的終點 */

那麼句柄s會在作用域的終點處消失。然而，s指向的String對象依然占據著內存空間。在上面這段代碼里，我們沒有辦法訪問對象，因為指向它的唯一一個句柄已超出了作用域的邊界。在後面的章節里，大家還會繼續學習如何在程序運行期間傳遞和復制對象句柄。
這樣造成的結果便是：對於用new創建的對象，只要我們願意，它們就會一直保留下去。這個編程問題在C和C++里特別突出。看來在C++里遇到的麻煩最大：由於不能從語言獲得任何幫助，所以在需要對象的時候，根本無法確定它們是否可用。而且更麻煩的是，在C++里，一旦工作完成，必須保證將對象清除。
這樣便帶來了一個有趣的問題。假如Java讓對象依然故我，怎樣才能防止它們大量充斥內存，並最終造成程序的「凝固」呢。在C++里，這個問題最令程序員頭痛。但Java以後，情況卻發生了改觀。Java有一個特別的「垃圾收集器」，它會查找用new創建的所有對象，並辨別其中哪些不再被引用。隨後，它會自動釋放由那些閑置對象占據的內存，以便能由新對象使用。這意味著我們根本不必操心內存的回收問題。只需簡單地創建對象，一旦不再需要它們，它們就會自動離去。這樣做可防止在C++里很常見的一個編程問題：由於程序員忘記釋放內存造成的「內存溢出」。

2.4 新建數據類型：類
如果說一切東西都是對象，那麼用什麼決定一個「類」（Class）的外觀與行為呢？換句話說，是什麼建立起了一個對象的「類型」（Type）呢？大家可能猜想有一個名為「type」的關鍵字。但從歷史看來，大多數面向對象的語言都用關鍵字「class」表達這樣一個意思：「我准備告訴你對象一種新類型的外觀」。class關鍵字太常用了，以至於本書許多地方並沒有用粗體字或雙引號加以強調。在這個關鍵字的後面，應該跟隨新數據類型的名稱。例如：
class ATypeName {/*類主體置於這里}
這樣就引入了一種新類型，接下來便可用new創建這種類型的一個新對象：
ATypeName a = new ATypeName();
在ATypeName里，類主體只由一條注釋構成（星號和斜杠以及其中的內容，本章後面還會詳細講述），所以並不能對它做太多的事情。事實上，除非為其定義了某些方法，否則根本不能指示它做任何事情。

2.4.1 欄位和方法
定義一個類時（我們在Java里的全部工作就是定義類、製作那些類的對象以及將消息發給那些對象），可在自己的類里設置兩種類型的元素：數據成員（有時也叫「欄位」）以及成員函數（通常叫「方法」）。其中，數據成員是一種對象（通過它的句柄與其通信），可以為任何類型。它也可以是主類型（並不是句柄）之一。如果是指向對象的一個句柄，則必須初始化那個句柄，用一種名為「構建器」（第4章會對此詳述）的特殊函數將其與一個實際對象連接起來（就象早先看到的那樣，使用new關鍵字）。但若是一種主類型，則可在類定義位置直接初始化（正如後面會看到的那樣，句柄亦可在定義位置初始化）。
每個對象都為自己的數據成員保有存儲空間；數據成員不會在對象之間共享。下面是定義了一些數據成員的類示例：

class DataOnly {
int i;
float f;
boolean b;
}
這個類並沒有做任何實質性的事情，但我們可創建一個對象：
DataOnly d = new DataOnly();
可將值賦給數據成員，但首先必須知道如何引用一個對象的成員。為達到引用對象成員的目的，首先要寫上對象句柄的名字，再跟隨一個點號（句點），再跟隨對象內部成員的名字。即「對象句柄.成員」。例如：
d.i = 47;
d.f = 1.1f;
d.b = false;
一個對象也可能包含了另一個對象，而另一個對象里則包含了我們想修改的數據。對於這個問題，只需保持「連接句點」即可。例如：
myPlane.leftTank.capacity = 100;
除容納數據之外，DataOnly類再也不能做更多的事情，因為它沒有成員函數（方法）。為正確理解工作原理，首先必須知道「自變數」和「返回值」的概念。我們馬上就會詳加解釋。

1. 主成員的默認值
若某個主數據類型屬於一個類成員，那麼即使不明確（顯式）進行初始化，也可以保證它們獲得一個默認值。

主類型 默認值

Boolean false
Char '\u0000'(null)
byte (byte)0
short (short)0
int 0
long 0L
float 0.0f
double 0.0d

一旦將變數作為類成員使用，就要特別注意由Java分配的默認值。這樣做可保證主類型的成員變數肯定得到了初始化（C++不具備這一功能），可有效遏止多種相關的編程錯誤。
然而，這種保證卻並不適用於「局部」變數——那些變數並非一個類的欄位。所以，假若在一個函數定義中寫入下述代碼：
int x;
那麼x會得到一些隨機值（這與C和C++是一樣的），不會自動初始化成零。我們責任是在正式使用x前分配一個適當的值。如果忘記，就會得到一條編譯期錯誤，告訴我們變數可能尚未初始化。這種處理正是Java優於C++的表現之一。許多C++編譯器會對變數未初始化發出警告，但在Java里卻是錯誤。

2.5 方法、自變數和返回值
迄今為止，我們一直用「函數」（Function）這個詞指代一個已命名的子常式。但在Java里，更常用的一個詞卻是「方法」（Method），代表「完成某事的途徑」。盡管它們表達的實際是同一個意思，但從現在開始，本書將一直使用「方法」，而不是「函數」。
Java的「方法」決定了一個對象能夠接收的消息。通過本節的學習，大家會知道方法的定義有多麼簡單！
方法的基本組成部分包括名字、自變數、返回類型以及主體。下面便是它最基本的形式：

返回類型 方法名( /* 自變數列表*/ ) {/* 方法主體 */}

返回類型是指調用方法之後返回的數值類型。顯然，方法名的作用是對具體的方法進行標識和引用。自變數列表列出了想傳遞給方法的信息類型和名稱。
Java的方法只能作為類的一部分創建。只能針對某個對象調用一個方法（注釋③），而且那個對象必須能夠執行那個方法調用。若試圖為一個對象調用錯誤的方法，就會在編譯期得到一條出錯消息。為一個對象調用方法時，需要先列出對象的名字，在後面跟上一個句點，再跟上方法名以及它的參數列表。亦即「對象名.方法名(自變數1，自變數2，自變數3...)。舉個例子來說，假設我們有一個方法名叫f()，它沒有自變數，返回的是類型為int的一個值。那麼，假設有一個名為a的對象，可為其調用方法f()，則代碼如下：
int x = a.f();
返回值的類型必須兼容x的類型。
象這樣調用一個方法的行動通常叫作「向對象發送一條消息」。在上面的例子中，消息是f()，而對象是a。面向對象的程序設計通常簡單地歸納為「向對象發送消息」。

③：正如馬上就要學到的那樣，「靜態」方法可針對類調用，毋需一個對象。

2.5.1 自變數列表
自變數列表規定了我們傳送給方法的是什麼信息。正如大家或許已猜到的那樣，這些信息——如同Java內其他任何東西——採用的都是對象的形式。因此，我們必須在自變數列表裡指定要傳遞的對象類型，以及每個對象的名字。正如在Java其他地方處理對象時一樣，我們實際傳遞的是「句柄」（注釋④）。然而，句柄的類型必須正確。倘若希望自變數是一個「字串」，那麼傳遞的必須是一個字串。

④：對於前面提及的「特殊」數據類型boolean，char，byte，short，int，long，，float以及double來說是一個例外。但在傳遞對象時，通常都是指傳遞指向對象的句柄。

下面讓我們考慮將一個字串作為自變數使用的方法。下面列出的是定義代碼，必須將它置於一個類定義里，否則無法編譯：

int storage(String s) {
return s.length() * 2;
}

這個方法告訴我們需要多少位元組才能容納一個特定字串里的信息（字串里的每個字元都是16位，或者說2個位元組、長整數，以便提供對Unicode字元的支持）。自變數的類型為String，而且叫作s。一旦將s傳遞給方法，就可將它當作其他對象一樣處理（可向其發送消息）。在這里，我們調用的是length()方法，它是String的方法之一。該方法返回的是一個字串里的字元數。
通過上面的例子，也可以了解return關鍵字的運用。它主要做兩件事情。首先，它意味著「離開方法，我已完工了」。其次，假設方法生成了一個值，則那個值緊接在return語句的後面。在這種情況下，返回值是通過計算表達式「s.length()*2」而產生的。
可按自己的願望返回任意類型，但倘若不想返回任何東西，就可指示方法返回void（空）。下面列出一些例子。

boolean flag() { return true; }
float naturalLogBase() { return 2.718; }
void nothing() { return; }
void nothing2() {}

若返回類型為void，則return關鍵字唯一的作用就是退出方法。所以一旦抵達方法末尾，該關鍵字便不需要了。可在任何地方從一個方法返回。但假設已指定了一種非void的返回類型，那麼無論從何地返回，編譯器都會確保我們返回的是正確的類型。
到此為止，大家或許已得到了這樣的一個印象：一個程序只是一系列對象的集合，它們的方法將其他對象作為自己的自變數使用，而且將消息發給那些對象。這種說法大體正確，但通過以後的學習，大家還會知道如何在一個方法里作出決策，做一些更細致的基層工作。至於這一章，只需理解消息傳送就足le

㈤ Java 面向對象理解

java語言中有三個典型的面向對象的特性：封裝性、繼承性和多態性。1． 封裝性
java語言中，對象就是對一組變數和相關方法的封裝，其中變數表明了對象的狀態，方法表明了對象具有的行為。通過對象的封裝，實現了模塊化和信息隱藏。通過對類的成員施以一定的訪問許可權，實現了類中成員的信息隱藏。
◇ java類中的限定詞
java語言中有四種不同的限定詞，提供了四種不同的訪問許可權。
1） private
類中限定為private的成員，只能被這個類本身訪問。
如果一個類的構造方法聲明為private,則其它類不能生成該類的一個實例。
2） default
類中不加任何訪問許可權限定的成員屬於預設的（default）訪問狀態：friend，可以被這個類本身和同一個包中的類所訪問。
3） protected
類中限定為protected的成員，可以被這個類本身、它的子類（包括同一個包中以及不同包中的子類）和同一個包中的所有其他的類訪問。
4） public
類中限定為public的成員，可以被所有的類訪問。
【表3-1】java中類的限定詞的作用范圍比較
同一個類
同一個包
不同包的子類
不同包非子類

private
*

default
*
*

protected
*
*
*

public
*
*
*
*2． 繼承性
通過繼承實現代碼復用。Java中所有的類都是通過直接或間接地繼承java.lang.Object類得到的。繼承而得到的類稱為子類，被繼承的類稱為父類。子類不能繼承父類中訪問許可權為private的成員變數和方法。子類可以重寫父類的方法，及命名與父類同名的成員變數。但Java不支持多重繼承，即一個類從多個超類派生的能力。
◇ 成員變數的隱藏和方法的重寫
子類通過隱藏父類的成員變數和重寫父類的方法，可以把父類的狀態和行為改變為自身的狀態和行為。
例如：
class SuperClass{
int x; …
void setX( ){ x=0; } …
}
class SubClass extends SuperClass{
int x; //隱藏了父類的變數x
…
void setX( ) { //重寫了父類的方法 setX()
x=5; } ….
}
注意：子類中重寫的方法和父類中被重寫的方法要具有相同的名字，相同的參數表和相同的返回類型，只是函數體不同。
◇ super
java中通過super來實現對父類成員的訪問，super用來引用當前對象的父類。Super 的使用有三種情況：
1）訪問父類被隱藏的成員變數，如：
super.variable;
2）調用父類中被重寫的方法，如：
super.Method([paramlist]);
3）調用父類的構造函數，如：
super([paramlist]);【例3-5】
import java.io.*;
class SuperClass{
int x;
SuperClass( ) {
x=3;
System.out.println("in SuperClass : x=" +x);
}
void doSomething( ) {
System.out.println("in SuperClass.doSomething()");
}
}
class SubClass extends SuperClass {
int x;
SubClass( ) {
super( ); //調用父類的構造方法
x=5;//super( ) 要放在方法中的第一句
System.out.println("in SubClass :x="+x);
}
void doSomething( ) {
super.doSomething( ); //調用父類的方法
System.out.println("in SubClass.doSomething()");
System.out.println("super.x="+super.x+" sub.x="+x);
}
}
public class Inheritance {
public static void main(String args[]) {
SubClass subC=new SubClass();
subC.doSomething();
}
}3． 多態性
在java語言中，多態性體現在兩個方面：由方法重載實現的靜態多態性（編譯時多態）和方法重寫實現的動態多態性（運行時多態）。
1） 編譯時多態
在編譯階段，具體調用哪個被重載的方法，編譯器會根據參數的不同來靜態確定調用相應的方法。
2） 運行時多態
由於子類繼承了父類所有的屬性（私有的除外），所以子類對象可以作為父類對象使用。程序中凡是使用父類對象的地方，都可以用子類對象來代替。一個對象可以通過引用子類的實例來調用子類的方法。
◇ 重寫方法的調用原則：java運行時系統根據調用該方法的實例，來決定調用哪個方法。對子類的一個實例，如果子類重寫了父類的方法，則運行時系統調用子類的方法；如果子類繼承了父類的方法（未重寫），則運行時系統調用父類的方法。
在例3-6中，父類對象a引用的是子類的實例，所以，java運行時調用子類B的callme方法。【例3-6】
import java.io.*;
class A{
void callme( ) {
System.out.println("Inside A's callme()method");
}
}
class B extends A{
void callme( ) {
System.out.println("Inside B's callme() Method");
}
}
public class Dispatch{
public static void main(String args[]) {
A a=new B();
a.callme( );
}
}
◇ 方法重寫時應遵循的原則：
1）改寫後的方法不能比被重寫的方法有更嚴格的訪問許可權（可以相同）。
2）改寫後的方法不能比重寫的方法產生更多的例外。
4． 其它
◇ final 關鍵字
final 關鍵字可以修飾類、類的成員變數和成員方法，但final 的作用不同。
1） final 修飾成員變數：
final修飾變數,則成為常量，例如
final type variableName;
修飾成員變數時，定義時同時給出初始值，且以後不能被修改，而修飾局部變數時不做要求。
2） final 修飾成員方法：
final修飾方法，則該方法不能被子類重寫
final returnType methodName(paramList){
…
}3） final 類：
final修飾類，則類不能被繼承
final class finalClassName{
…
}
◇ 實例成員和類成員
用static 關鍵字可以聲明類變數和類方法，其格式如下：
static type classVar;
static returnType classMethod({paramlist}) {
…
}
如果在聲明時不用static 關鍵字修飾，則聲明為實例變數和實例方法。
1） 實例變數和類變數
每個對象的實例變數都分配內存，通過該對象來訪問這些實例變數，不同的實例變數是不同的。
類變數僅在生成第一個對象時分配內存，所有實例對象共享同一個類變數，每個實例對象對類變數的改變都會影響到其它的實例對象。類變數可通過類名直接訪問，無需先生成一個實例對象，也可以通過實例對象訪問類變數。
2） 實例方法和類方法
實例方法可以對當前對象的實例變數進行操作，也可以對類變數進行操作，實例方法由實例對象調用。
但類方法不能訪問實例變數，只能訪問類變數。類方法可以由類名直接調用，也可由實例對象進行調用。類方法中不能使用this或super關鍵字。
例3-7 是關於實例成員和類成員的例子。
【例3-7】
class Member {
static int classVar;
int instanceVar;
static void setClassVar(int i) {
classVar=i;
// instanceVar=i; // 類方法不能訪問實例變數
}
static int getClassVar()
{ return classVar; }
void setInstanceVar(int i)
{ classVar=i; //實例方法不但可以訪問類變數，也可以實例變數
instanceVar=i; }
int getInstanceVar( )
{ return instanceVar; }
}
public class MemberTest{
public static void main(String args[]) {
Member m1=new member();
Member m2=new member();
m1.setClassVar(1);
m2.setClassVar(2);
System.out.println("m1.classVar="+m1.getClassVar()+"
m2.ClassVar="+m2.getClassVar());
m1.setInstanceVar(11);
m2.setInstanceVar(22);
System.out.println("m1.InstanceVar="+m1.getInstanceVar
()+" m2.InstanceVar="+m2.getInstanceVar());
}
}
◇ 類java.lang.Object
類java.lang.Object處於java開發環境的類層次的根部，其它所有的類都是直接或間接地繼承了此類。該類定義了一些最基本的狀態和行為。下面，我們介紹一些常用的方法。
equals() ：比較兩個對象(引用)是否相同。
getClass()：返回對象運行時所對應的類的表示，從而可得到相應的信息。
toString()：用來返回對象的字元串表示。
finalize()：用於在垃圾收集前清除對象。
notify(),notifyAll(),wait()：用於多線程處理中的同步。

㈥ 對象是程序員是一種什麼樣的體驗

程序員一直被人們調侃成「程序猿」，他們一直給人的印象就是智商無敵，情商堪憂，薪資驚訝，加班驚嘆。對於這樣的認知，我還是不敢苟同，我接觸過幾個程序員感覺和正常的人沒有多大差別，並沒有那麼神秘，有時講的段子會讓你笑掉大牙，所以說有個程序員對象還是蠻不錯的，但是劣勢也很明顯。

魚和熊掌不能兼得，既然選擇了程序員作為對象，那就多看他的優點，包容行業的缺點，那幸福就會一直陪伴左右。

㈦ 程序員小白如何理解面向對象

核心是封裝狀態和相應的過程。通常面向對象是通過改變內部狀態實現最終目的。調用對象過程的主要目的是產生改變其內部狀態這個副作用（side effect）。這樣封裝的初衷是避免多個主體訪問、修改同一狀態造成混亂。在不少場合這樣的封裝確實也達到了目的，所以面向對象的方式才這么普及。