java思想,java思想pdf

本文目錄一覽：

• 1、JAVA編程思想一共有幾章
• 2、java編程思想怎麼理解？
• 3、學習java最重要的思想是什麼
• 4、java的核心思想是什麼？
• 5、Java面向對象的程序設計思想是什麼？
• 6、Java編程大神，常常說的Java編程思想是什麼？

JAVA編程思想一共有幾章

一共 17 章

強烈建議你去買這本書！雖然電子文檔很多，百度一下到處都是，但是不很方便！這本書看了真的思想都變了！！

第1章 對象入門

1.1 抽象的進步

1.2 對象的介面

1.3 實現方案的隱藏

1.4 方案的重複使用

1.5 繼承：重新使用介面

1.5.1 改善基礎類

1.5.2 等價和類似關係

1.6 多形對象的互換使用

1.6.1 動態綁定

1.6.2 抽象的基礎類和介面

1.7 對象的創建和存在時間

1.7.1 集合與繼承器

1.7.2 單根結構

1.7.3 集合庫與方便使用集合

1.7.4 清除時的困境：由誰負責清除？

1.8 違例控制：解決錯誤

1.9 多線程

1.10 永久性

1.11 Java和網際網路

1.11.1 什麼是Web？

1.11.2 客戶端編程

1.11.3 伺服器端編程

1.11.4 一個獨立的領域：應用程序

1.12 分析和設計

1.12.1 不要迷失

1.12.2 階段0：擬出一個計劃

1.12.3 階段1：要製作什麼？

1.12.4 階段2：開始構建？

1.12.5 階段3：正式創建

1.12.6 階段4：校訂

1.12.7 計劃的回報

1.13 Java還是C++？

第2章 一切都是對象

2.1 用句柄操縱對象

2.2 必須創建所有對象

2.2.1 保存在什麼地方

2.2.2 特殊情況：主類型

2.2.3 Java中的數組

2.3 絕對不要清除對象

2.3.1 作用域

2.3.2 對象的作用域

2.4 新建數據類型：類

2.4.1 欄位和方法

2.5 方法、自變數和返回值

2.5.1 自變數列表

2.6 構建Java程序

2.6.1 名字的可見性

2.6.2 使用其他組件

2.6.3 static關鍵字

2.7 我們的第一個Java程序

2.8 注釋和嵌入文檔

2.8.1 注釋文檔

2.8.2 具體語法

2.8.3 嵌入HTML

2.8.4 @see：引用其他類

2.8.5 類文檔標記

2.8.6 變數文檔標記

2.8.7 方法文檔標記

2.8.8 文檔示例

2.9 編碼樣式

2.10 總結

2.11 練習

第3章 控制程序流程

3.1 使用Java運算符

3.1.1 優先順序

3.1.2 賦值

3.1.3 算術運算符

3.1.4 自動遞增和遞減

3.1.5 關係運算符

3.1.6 邏輯運算符

3.1.7 按位運算符

3.1.8 移位運算符

3.1.9 三元if-else運算符

3.1.10 逗號運算符

3.1.11 字串運算符+

3.1.12 運算符常規操作規則

3.1.13 造型運算符

3.1.14 Java沒有「sizeof」

3.1.15 複習計算順序

3.1.16 運算符總結

3.2 執行控制

3.2.1 真和假

3.2.2 if-else

3.2.3 反覆

3.2.4 do-while

3.2.5 for

3.2.6 中斷和繼續

3.2.7 切換

3.3 總結

3.4 練習

第4章 初始化和清除

4.1 由構建器保證初始化

4.2 方法過載

4.2.1 區分過載方法

4.2.2 主類型的過載

4.2.3 返回值過載

4.2.4 默認構建器

4.2.5 this關鍵字

4.3 清除：收尾和垃圾收集

4.3.1 finalize()用途何在

4.3.2 必須執行清除

4.4 成員初始化

4.4.1 規定初始化

4.4.2 構建器初始化

4.5 數組初始化

4.5.1 多維數組

4.6 總結

4.7 練習

第5章 隱藏實施過程

5.1 包：庫單元

5.1.1 創建獨一無二的包名

5.1.2 自定義工具庫

5.1.3 利用導入改變行為

5.1.4 包的停用

5.2 Java訪問指示符

5.2.1 「友好的」

5.2.2 public：介面訪問

5.2.3 private：不能接觸

5.2.4 protected：「友好的一種」

5.3 介面與實現

5.4 類訪問

5.5 總結

5.6 練習

第6章 類再生

6.1 合成的語法

6.2 繼承的語法

6.2.1 初始化基礎類

6.3 合成與繼承的結合

6.3.1 確保正確的清除

6.3.2 名字的隱藏

6.4 到底選擇合成還是繼承

6.5 protected

6.6 遞增開發

6.7 上溯造型

6.7.1 何謂「上溯造型」？

6.8 final關鍵字

6.8.1 final數據

6.8.2 final方法

6.8.3 final類

6.8.4 final的注意事項

6.9 初始化和類裝載

6.9.1 繼承初始化

6.10 總結

6.11 練習

第7章 多形性

7.1 上溯造型

7.1.1 為什麼要上溯造型

7.2 深入理解

7.2.1 方法調用的綁定

7.2.2 產生正確的行為

7.2.3 擴展性

7.3 覆蓋與過載

7.4 抽象類和方法

7.5 介面

7.5.1 Java的「多重繼承」

7.5.2 通過繼承擴展介面

7.5.3 常數分組

7.5.4 初始化介面中的欄位

7.6 內部類

7.6.1 內部類和上溯造型

7.6.2 方法和作用域中的內部類

7.6.3 鏈接到外部類

7.6.4 static內部類

7.6.5 引用外部類對象

7.6.6 從內部類繼承

7.6.7 內部類可以覆蓋嗎？

7.6.8 內部類標識符

7.6.9 為什麼要用內部類：控制框架

7.7 構建器和多形性

7.7.1 構建器的調用順序

7.7.2 繼承和finalize()

7.7.3 構建器內部的多形性方法的行為

7.8 通過繼承進行設計

7.8.1 純繼承與擴展

7.8.2 下溯造型與運行期類型標識

7.9 總結

7.10 練習

第8章 對象的容納

8.1 數組

8.1.1 數組和第一類對象

8.1.2 數組的返回

8.2 集合

8.2.1 缺點：類型未知

8.3 枚舉器（反覆器）

8.4 集合的類型

8.4.1 Vector

8.4.2 BitSet

8.4.3 Stack

8.4.4 Hashtable

8.4.5 再論枚舉器

8.5 排序

8.6 通用集合庫

8.7 新集合

8.7.1 使用Collections

8.7.2 使用Lists

8.7.3 使用Sets

8.7.4 使用Maps

8.7.5 決定實施方案

8.7.6 未支持的操作

8.7.7 排序和搜索

8.7.8 實用工具

8.8 總結

8.9 練習

第9章 違例差錯控制

9.1 基本違例

9.1.1 違例自變數

9.2 違例的捕獲

9.2.1 try塊

9.2.2 違例控制器

9.2.3 違例規範

9.2.4 捕獲所有違例

9.2.5 重新「擲」出違例

9.3 標準Java違例

9.3.1 RuntimeException的特殊情況

9.4 創建自己的違例

9.5 違例的限制

9.6 用finally清除

9.6.1 用finally做什麼

9.6.2 缺點：丟失的違例

9.7 構建器

9.8 違例匹配

9.8.1 違例準則

9.9 總結

9.10 練習

第10章 Java IO系統

10.1 輸入和輸出

10.1.1 InputStream的類型

10.1.2 OutputStream的類型

10.2 增添屬性和有用的介面

10.2.1 通過FilterInputStream從InputStream里讀入數據

10.2.2 通過FilterOutputStream向OutputStream里寫入數據

10.3 本身的缺陷：RandomAccessFile

10.4 File類

10.4.1 目錄列表器

10.4.2 檢查與創建目錄

10.5 IO流的典型應用

10.5.1 輸入流

10.5.2 輸出流

10.5.3 快捷文件處理

10.5.4 從標準輸入中讀取數據

10.5.5 管道數據流

10.6 StreamTokenizer

10.6.1 StringTokenizer

10.7 Java 1.1的IO流

10.7.1 數據的發起與接收

10.7.2 修改數據流的行為

10.7.3 未改變的類

10.7.4 一個例子

10.7.5 重定向標準IO

10.8 壓縮

10.8.1 用GZIP進行簡單壓縮

10.8.2 用Zip進行多文件保存

10.8.3 Java歸檔（jar）實用程序

10.9 對象串聯

10.9.1 尋找類

10.9.2 序列化的控制

10.9.3 利用「持久性」

10.10 總結

10.11 練習

第11章 運行期類型鑒定

11.1 對RTTI的需要

11.1.1 Class對象

11.1.2 造型前的檢查

11.2 RTTI語法

11.3 反射：運行期類信息

11.3.1 一個類方法提取器

11.4 總結

11.5 練習

第12章 傳遞和返回對象

12.1 傳遞句柄

12.1.1 別名問題

12.2 製作本地副本

12.2.1 按值傳遞

12.2.2 克隆對象

12.2.3 使類具有克隆能力

12.2.4 成功的克隆

12.2.5 Object.clone()的效果

12.2.6 克隆合成對象

12.2.7 用Vector進行深層複製

12.2.8 通過序列化進行深層複製

12.2.9 使克隆具有更大的深度

12.2.10 為什麼有這個奇怪的設計

12.3 克隆的控制

12.3.1 副本構建器

12.4 只讀類

12.4.1 創建只讀類

12.4.2 「一成不變」的弊端

12.4.3 不變字串

12.4.4 String和StringBuffer類

12.4.5 字串的特殊性

12.5 總結

12.6 練習

第13章 創建窗口和程序片

13.1 為何要用AWT？

13.2 基本程序片

13.2.1 程序片的測試

13.2.2 一個更圖形化的例子

13.2.3 框架方法的演示

13.3 製作按鈕

13.4 捕獲事件

13.5 文本欄位

13.6 文本區域

13.7 標籤

13.8 複選框

13.9 單選鈕

13.10 下拉列表

13.11 列表框

13.11.1 handleEvent()

13.12 布局的控制

13.12.1 FlowLayout

13.12.2 BorderLayout

13.12.3 GridLayout

13.12.4 CardLayout

13.12.5 GridBagLayout

13.13 action的替用品

13.14 程序片的局限

13.14.1 程序片的優點

13.15 視窗化應用

13.15.1 菜單

13.15.2 對話框

13.16 新型AWT

13.16.1 新的事件模型

13.16.2 事件和接收者類型

13.16.3 用Java 1.1 AWT製作窗口和程序片

13.16.4 再探早期示例

13.16.5 動態綁定事件

13.16.6 將商業邏輯與UI邏輯區分開

13.16.7 推薦編碼方法

13.17 Java 1.1 UI API

13.17.1 桌面顏色

13.17.2 列印

13.17.3 剪貼板

13.18 可視編程和Beans

13.18.1 什麼是Bean

13.18.2 用Introspector提取BeanInfo

13.18.3 一個更複雜的Bean

13.18.4 Bean的封裝

13.18.5 更複雜的Bean支持

13.18.6 Bean更多的知識

13.19 Swing入門

13.19.1 Swing有哪些優點

13.19.2 方便的轉換

13.19.3 顯示框架

13.19.4 工具提示

13.19.5 邊框

13.19.6 按鈕

13.19.7 按鈕組

13.19.8 圖標

13.19.9 菜單

13.19.10 彈出式菜單

13.19.11 列表框和組合框

13.19.12 滑桿和進度指示條

13.19.13 樹

13.19.14 表格

13.19.15 卡片式對話框

13.19.16 Swing消息框

13.19.17 Swing更多的知識

13.20 總結

13.21 練習

第14章 多線程

14.1 反應靈敏的用戶界面

14.1.1 從線程繼承

14.1.2 針對用戶界面的多線程

14.1.3 用主類合併線程

14.1.4 製作多個線程

14.1.5 Daemon線程

14.2 共享有限的資源

14.2.1 資源訪問的錯誤方法

14.2.2 Java如何共享資源

14.2.3 回顧Java Beans

14.3 堵塞

14.3.1 為何會堵塞

14.3.2 死鎖

14.4 優先順序

14.4.1 線程組

14.5 回顧runnable

14.5.1 過多的線程

14.6 總結

14.7 練習

第15章 網路編程

15.1 機器的標識

15.1.1 伺服器和客戶機

15.1.2 埠：機器內獨一無二的場所

15.2 套接字

15.2.1 一個簡單的伺服器和客戶機程序

15.3 服務多個客戶

15.4 數據報

15.5 一個Web應用

15.5.1 伺服器應用

15.5.2 NameSender程序片

15.5.3 15.5.3 要注意的問題

15.6 Java與CGI的溝通

15.6.1 CGI數據的編碼

15.6.2 程序片

15.6.3 用C++寫的CGI程序

15.6.4 POST的概念

15.7 用JDBC連接資料庫

15.7.1 獲得學習示例

15.7.2 查找程序的GUI版本

15.7.3 JDBC API為何如何複雜

15.8 遠程方法

15.8.1 遠程介面概念

15.8.2 遠程介面的實施

15.8.3 創建根與干

15.8.4 使用遠程對象

15.8.5 RMI的替選方案

15.9 總結

15.10 練習

第16章 設計範式

16.1 範式的概念

16.1.1 單子

16.1.2 範式分類

16.2 觀察器範式

16.3 模擬垃圾回收站

16.4 改進設計

16.4.1 「製作更多的對象」

16.4.2 用於原型創建的一個範式

16.5 抽象的應用

16.6 多重派遣

16.6.1 實現雙重派遣

16.7 訪問器範式

16.8 RTTI有害嗎

16.9 總結

16.10 練習

第17章 項目

17.1 文字處理

17.1.1 提取代碼列表

17.1.2 檢查大小寫樣式

17.2 方法查找工具

17.3 複雜性理論

17.4 總結

17.5 練習

java編程思想怎麼理解？

說說我個人的理解：

java編程思想並不是一本適合初學者看的書，起碼要對面向對象有了一定的了解之後在看這本書，這本書我也有，斷斷續續的看，到現在看完一多半了，有的地方並沒有完全理解，我覺得，好書，是不可能一遍就看懂的，而且看一遍也不能完全理解，如果有時間的話，要反覆的看，隨著自己編程經驗的增加，理解也會越來越深入。

如果你沒有任何的基礎，建議先學一下C語言，把變數，函數，if，else，for循環這些基本的先掌握了，這些東西，是所有編程語言所共同的。

我不知道你的時間是否充裕，想學java的話，先學基礎（j2se），如果以後想學j2ee，學完基礎後要學習java web，包括html，javascript，css，servlet，jsp，學完這些之後，開始學習一些框架，像struts，spring，hibernate等等。要學的東西挺多的，如果是自學的話，我估計最少要1年，所以如果想學java，就要做好準備，不斷學習的準備！

希望以上這些對你有幫助！

學習java最重要的思想是什麼

當然是面向對象的思想咯。 　OOP的許多原始思想都來之於Simula語言，並在Smalltalk語言的完善和標準化過程中得到更多的擴展和對以前的思想的重新註解。可以說OO思想和OOPL幾乎是同步發展相互促進的。與函數式程序設計（functional-programming）和邏輯式程序設計（logic-programming）所代表的接近於機器的實際計算模型所不同的是，OOP幾乎沒有引入精確的數學描敘，而是傾向於建立一個對象模型，它能夠近似的反映應用領域內的實體之間的關係，其本質是更接近於一種人類認知事物所採用的哲學觀的計算模型。由此，導致了一個自然的話題，那就是OOP到底是什麼？[DT 1988][B.S 1991] .。在OOP中，對象作為計算主體，擁有自己的名稱，狀態以及接受外界消息的介面。在對象模型中，產生新對象，舊對象銷毀，發送消息，響應消息就構成OOP計算模型的根本。

對象的產生有兩種基本方式。一種是以原型（prototype）對象為基礎產生新的對象。一種是以類（class）為基礎產生新對象。原型的概念已經在認知心理學中被用來解釋概念學習的遞增特性，原型模型本身就是企圖通過提供一個有代表性的對象為基礎來產生各種新的對象，並由此繼續產生更符合實際應用的對象。而原型-委託也是OOP中的對象抽象，代碼共享機制中的一種。一個類提供了一個或者多個對象的通用性描敘。從形式化的觀點看，類與類型有關，因此一個類相當於是從該類中產生的實例的集合。而這樣的觀點也會帶來一些矛盾，比較典型的就是在繼承體系下，子集（子類）對象和父集（父類）對象之間的行為相融性可能很難達到，這也就是OOP中常被引用的—子類型（subtype）不等於子類（subclass）[Budd 2002]。而在一種所有皆對象的世界觀背景下，在類模型基礎上還誕生出了一種擁有元類（metaclass）的新對象模型。即類本身也是一種其他類的對象。以上三種根本不同的觀點各自定義了三種基於類（class-based）,基於原型（prototype-based）和基於元類（metaclass-based）的對象模型。而這三種對象模型也就導致了許多不同的程序設計語言（如果我們暫時把靜態與動態的差別放在一邊）。是的，我們經常接觸的C++,Java都是使用基於類的對象模型，但除此之外還有很多我們所沒有接觸的OOPL採用了完全不一樣的對象模型，他們是在用另外一種觀點詮釋OOP的內涵。

什麼是類型（type）?

類型以及類型系統的起源以及研究與發展是獨立於OOP的。早在五十年代的FORTRAN語言編譯器實現中，就已經採用類型系統作為類型檢查的一種手段。廣義的類型一般被定義為一種約束，也就是一種邏輯公式。而在對類型的研究過程中產生多種方法，比如[CW 1985]等。而代數方法（algebraic approach）是一種非常好的建立類型的形式化規範的方法。代數中的一個類型對應於一系列元素，在它們之上定義代數操作。同時在此基礎上二階λ演算已經被用於繼承和模板所支持的模型。在上面兩種方法中，類型被認為是一系列滿足確定約束條件的元素，更抽象的方式可以把一個類型當作規定一個約束條件，如果我們規定的約束條件越好，相對應的被定義元素的集合就越精密，所以邏輯公式（logical formulas）就成為描敘類型特徵的最合適工具。在這裡，我們不想深入的探究對於類型理論的各種不同的數學模型，我們需要明白的是類型（type）以及類型理論這個在編程語言中經常應用到的概念的內涵是極其豐富的，而其自身理論的發展並非局限於OOP之中，但當兩者相結合的時候就對我們的程序觀產生了巨大的影響。

類（class），類型(type)，介面（interface）

這三個概念是在OOP中出現頻率最多，也最容易混淆的。而對於這三個概念的澄清也是文章寫作的初衷。讓我們先看看大師們對於這三個概念的描敘—-

「The fundamental unit of programming in Java programming language is the class, but the fundamental unit of the object-oriented design is the type.while classes define types,it is very useful and powerful to be able to define a type without defining a class.Interface define types in an abstract form as a collection of methods or other types that form the contract for the type.」 [Jams 2000]。

「In C++,A class is a user definite type」[B.S 1998]。

「A type is a name used to denote a particular interface……An object may have many types,and widely different objects can share a type.Part of an object』s interface may be characterized by one type ,and other parts by other types.Two objects of the same type need only share parts of their interface.Interface can contain other interface as subset.We say that a type is a subtype of another if its interface contain the interface of its supertype.Often we speak of a subtype inheriting the interface of its supertype」[Gamma 1995]

在其中，一共出現了四個概念：類（class），類型(type)，介面（interface）以及契約（contract）。這裡我們說到的類型和上面提到的類型有所不同，是狹義的OOP中的類型。為了理解這幾個概念，我先劃分出三個概念域：一個是針對現實世界的，一個是針對特定程序設計范型的（在這裡就是OO設計范型），最後一個是針對編譯器實現的。也就是說，在現實世界中的概念必須有一種手段映射到OO范型中去，而OO范型中的概念也應該在編譯器實現中有相同的概念對應。由此，我們可以這樣說，類是做為現實世界中的概念，而傳統的OOPL都會提供class關鍵字來表示對現實世界模擬的支持。而介面，是作為OO程序設計范型中與類對應的一個概念。在OO設計中，我們所要做的就是針對介面進行設計和編程，而介面的實質含義就是對象之間的一種契約。而類型就是編譯器實現中針對類和介面所定義的對應概念。可以這樣說，類是現實世界中存在的客觀概念，是唯物的。介面是設計人員定義出來的，存在於設計人員心中的概念，是唯心的。而類型是類和介面這兩種概念的編譯器實現的映射概念，也是唯物的。類型主要是用來指導編譯器的類型檢查的謂詞，類是創建現實對象的模板，介面是OO設計中的關鍵概念。這三個概念相互區別（分別位於不同的概念域），又相互聯繫（都是代表相同的概念的不同概念域的映射）。有了上面的理解，我們看看下面最常見的Java語句：

people a=new man();

這代表了什麼？程序員向編譯器聲明了一個people類型（type）的對象變數a，而對象變數a本身卻指向了一個man類（class）的實體（而在編譯器中理解是對象變數a指向了一個類型為man的實體）。再讓我們回到[Jams 2000]，其中句子的根本含義我們可以概括如下：聲明一個類或者一個介面都同時向編譯器註冊了一個新的類型，而此類或者介面以及類型都是共享同樣的一個名字。也就是說。編譯器所能理解的全部都是類型，而程序員的工作是把現實中的類概念轉化為設計中的介面概念，而編譯器對應於上兩種概念都有直接的支持，那就是一個類聲明或者介面聲明在編譯器的理解來看就是一個類型聲明。但是反過來卻不一定成立。一個類可以有多個介面（一個類完全有可能實現了設計人員的多個契約條件），同時也就可能有多個類型（因為類型不過是介面這個設計域內的概念在編譯器中的實現）。

多態，替換原則，對象切割

多態作為OO中的核心機制之一擁有著豐富的內涵。顧名思義，多態就是一種名稱多種形態的意思。其主要有三種形式：函數多態，對象變數多態，泛型多態。函數多態主要包括函數重載（overload）和改寫(overriding)。泛型多態（genericity）主要是提供了一種創建通用工具的方法，可以在特定的場合將其特化。在這裡，我們重點要考量的是對象變數多態。在理解對象變數多態之前，我們首先了解一下OO核心機制之一的替換原則。靜態類型的OOPL的一個特徵就是一個變數所包含的值（value）的類型可能並不等於這個變數所聲明的類型，在傳統的編程語言中並不具備這樣的特徵，因為我們不可能把聲明為整型的變數賦上字元串的變數值。而替換原則發生作用的情況就隱含的描敘了兩種不同類型所具有的關聯—-類型繼承。Barbara Liskov曾經這樣描敘替換原則以及起作用的類型之間的關聯：對於類型為S的每個對象s，存在一個類型為T的對象t，對於根據類型T所定義的所有程序P，如果用對象s替換對象t，程序P的行為保持不變，那麼類型S就是類型T的子類型[Liskov 1988]

在理解了多態以及替換原則後，我們可以繼續深入理解繼承與替換原則相結合所帶來的新的觀點。可以說繼承與替換原則的引入影響了幾乎所有的OOPL，包括類型系統，值語義/引用語義，對象內存空間分配等等。下面，我將試圖逐步的撥開其中的各種因果。

首先考慮,people a; 這樣的代碼在編譯器中將如何實現？可以肯定是首先將把類型people綁定到對象a上，然後必須為對象a分配空間。同時，我們創建people的子類man，由於man IS A people。根據多態以及替換原則，我們當然可以讓對象a保存一個man類型的值（這就是替換原則的表現）。這是一種直觀的描敘，但在編程語言的實現過程中就出現一些困難。我們知道繼承是一種擴展介面與實現的方式，那麼我們就很難保證man類型不對people類型做擴展，而一旦做出擴展，我們如何能用存儲people對象的空間去存儲man類型的對象值呢？

people a；

man b=new man();

a=b;

這樣的代碼將首先把b對象進行切割，然後再存儲到a對象空間去。然而這並不是我們所期望的。那麼，為了支持OOP的繼承，多態，替換原則，但卻需要避免對象切割的發生，面對對象a我們將採用何種分配空間模型呢？常用的有下面三種方式：

1， 只為a分配基類people的存儲空間，不支持對象多態以及替換原則。這樣的模型內存分配緊湊，存儲效率很高。

2， 分配繼承樹中的最大類對象所需要空間（在這裡是man類的對象值空間），這樣的模型簡單，同時可以實現多態和替換原則而避免對象切割問題，但是十分浪費內存空間十分明顯。

3， 只分配用於保存一個指針所需要的存儲空間，在運行時通過堆來分配對象實際類型所需要的空間大小，這樣也可以實現多態和替換原則而避免對象切割問題。（也就是說a只是一個對象的引用，而不是真實的對象，真實對象的生成必須靠程序員顯式的聲明）。

對於上面提到的三種內存模型，1和3都被一些程序設計語言所採用。相信說到這裡，大家應該開始慢慢明白了。是的，C++作為C語言的繼承者，對於效率的追求迫使它必須採用第一種最小靜態空間分配的方式，由於基於棧空間的程序運行效率要比基於堆空間的程序運行效率高出許多，所以C++允許用棧空間保存對象，但同時也允許堆空間保存對象，可以說C++是採用了1和3兩種相混合的內存模型，而C++中基於1內存模型的對象，也就是說基於棧內存空間的對象是沒有辦法體現多態和替換原則的（請思考一下在C++中什麼對象是基於棧的），而基於3內存模型的對象將支持多態和替換原則（又想一想在C++中什麼對象是基於堆的）。這裡，我們終於可以揭開第一層迷霧了，很多人都知道在C++中只有指針和引用才能支持對象的多態行為，但是為什麼會如此？上面做出了最好的解釋。

Java語言由於設計理念和C++有著很大的區別，它採用的是第3種對象模型，一切對象（除了基本類型對象）都是基於堆分配的。這也是Java語言必須採用虛擬機的原因所在。在C++中很大一部分對象是不需要程序員進行管理的（靜態空間對象），而在Java中，如果不採用虛擬機機制，所有的對象都需要程序員管理，而這樣的開發代價將是巨大而不現實的。這也就揭開了第二層迷霧，當我們在對比C++和Java語言的時候總是為虛擬機是否有其價值而爭論不休，但當你拋開所謂的好與不好的簡單討論，進入到其語言本身的內在對象存儲本質的時候，也許對於各種聲音才會有一個屬於自己的清醒認識。

讓我們繼續望下走，不同的對象內存分配模型直接影響到其程序設計語言的賦值的含義。在各種編程語言中，賦值可以給出兩種不同的語義解釋：複製語義和指針語義。很明顯，由於C++支持兩種相混合的對象存儲模型（但是默認的存儲方式是棧存儲），所以在C++中默認賦值語義採用的是前者，但C++同時提供了指針語義的功能支持（在拷貝構造函數和=運算符重載中用戶進行自定義）。而在Java中採用的是後者。這也就是我們揭開的最後一道迷霧，不同的對象存儲模型直接導致了不同的賦值語義。

面向對象的計算模型和可計算性

編程就是用計算所需要的指令構成一種運算裝置，無論我們的程序設計思想以及程序設計語言如何發展和提高，最終我們所使用的底層計算數學模型並沒有改變。但高級程序設計語言給我們帶來的變革是在其語言環境中構建起了一個全新的，更抽象的虛擬計算模型。Smalltalk語言引入的對象計算模型從根本上改變了以前的傳統計算模型，以前的計算模型突出的是順序計算過程中的機器狀態，而現在的對象計算模型突出的對象之間的協作其計算結果由參加計算的所有的對象的狀態總體構成。而由於對象本身具有自身狀態，我們也可以把一個對象看成是一個小的計算機器。這樣，面向對象的計算模型就演變成了許多小的計算機器的合作計算模型。圖靈機作為計算領域內的根本計算模型，精確的抓住了計算的要點：什麼是可計算的，計算時間和空間存儲大小開銷有多大。計算模型清楚的界定了可計算性的範圍，也就界定了哪些問題是可求解，哪些問題是不可求解的。OOP為程序員提供了一種更加抽象和易於理解的新的計算模型，但其本身並沒有超越馮.諾依曼體系所代表的圖靈機數學計算模型。所以我們不能期望OOP能幫助我們解決更多的問題，或者減少運算的複雜度。但OOP卻能幫助我們用一種更容易被我們所理解和接受的方式去描敘和解決現實問題。

java的核心思想是什麼？

朋友你好，

我想你已經看過java的基礎書籍了，至於你提出這個問題我想你是不明白書上解釋的意義。

JAVA的核心思想：面向對象，一切事物皆對象。而面向對象的四個特性才構成了面向對象。下面我將不會為你解釋概念，只為你舉出一些例子幫助你理解：

1.抽象：比如，我們將水果看做一個對象，而水果中又有蘋果、梨子等等一系列的分類，在我們眼中，水果是對象，而蘋果、梨子等也都是對象，對一個蘋果而言，你會關心這個蘋果產自哪裡，蘋果是姓什麼嗎？不會，這就是抽象，去掉我們不關心的，我們只關心它就是個蘋果

2.繼承：繼續上面我們將水果看做一個對象，那麼所有的水果都有顏色、味道等一系列屬性，而這些屬性在蘋果、梨子等都是一定會有的，那麼我們的蘋果就可以繼承於水果，因為它具有水果的一切特性，但是它還有自己的特性，這就便於我們自己對其定義新屬性

3.封裝：繼續上面，水果的屬性有很多，顏色、味道等等，我們怎麼才能表達出最完整的水果？這就是封裝，將水果的特性包裝在一個javabean，這樣一個完美的水果就誕生了

4. 多態性：接著上面，一個蘋果具有水果的全部特性，但是僅僅是這樣嗎？蘋果還能作為蔬菜做飯（如蘋果醬等），那麼我們怎麼才確定它和蔬菜的關聯呢？這就是多態了，它不僅有一個水果的特性還有其他種類的特性，在具有水果的全部特性前提下（繼承），我們就需要為蘋果添加一個蔬菜的介面，介面中定義了蔬菜的特性方法，但是我們不必像繼承那樣實現所有的方法，我們只需要實現需要的做飯這一個特性方法就行了，這就是介面，這就是多態

說了這麼多，僅僅是個人體會，僅供參考，有不對的地方希望原理。

希望能對你有幫助。

Java面向對象的程序設計思想是什麼？

面向對象的程序設計簡稱OOP是當今主流的程序設計范型，面向對象的程序是由對象組成的，每個對象包含對用戶公開的特定功能部分和隱藏的實現部分。萬物皆對象的概念，由具有共同特徵和行為的對象抽象出此類對象的模型稱之為「類」

Java編程大神，常常說的Java編程思想是什麼？

編程思想的形成，靠的是去實踐，去練習不知道你java現在學到什麼程度了我就從頭說起吧 首先學習的是java的特性（安全，跨平台），學習java的語法，一些常用的類等等這時候你可以做一些簡單的練習比如書上的例子你寫到電腦上，運行，看看結果，一句一句的分析。每行代碼幹什麼的，然後試著去改變變數的值，修改一些語句。慢慢培養自己，熟悉java。但是要注意！你寫的根本就不是java程序，為什麼呢？你根本就沒有用到java的特點，比如類，繼承，封裝，多態….沒有這些，就是C語言用java語法寫了一遍。熟練的掌握java的基礎知識，這樣你就可以試著寫小程序了，推薦你寫一些遊戲，慢慢培養自己設計的能力。比如掃雷遊戲吧，整個遊戲要分為幾個部分，計時器，計雷器，雷區，界面，菜單….在將功能細化，比如每一個雷塊都是一個對象。。。對象有許多的方法。。。。慢慢的培養自己面向對象程序設計的思路。 一個完整的程序寫成了，你就會對編程有自己的把握了，你就可以試著寫更大項目。慢慢的你就成了老鳥。。。回過頭看自己剛學java的時候寫的遊戲，就會發現架構不好，設計不好，代碼重用度不好，擴展性不好。。。。 學java不難，只要肯堅持，多用頭腦去思考，也別想著一口吃成胖子