跨編譯單元抽象

『壹』 抽象類的抽象方法可以用private修飾嗎

C#用多種修飾符來表達類的不同性質。根據其保護級C#的類有五種不同的限制修飾符： public可以被任意存取； protected只可以被本類和其繼承子類存取； internal只可以被本組合體（Assembly）內所有的類存取，組合體是C#語言中類被組合後的邏輯單位和物理單位，其編譯後的文件擴展名往往是「.DLL」或「.EXE」。 protected internal唯一的一種組合限制修飾符，它只可以被本組合體內所有的類和這些類的繼承子類所存取。 private只可以被本類所存取。 如果不是嵌套的類，命名空間或編譯單元內的類只有public和internal兩種修飾。 new修飾符只能用於嵌套的類，表示對繼承父類同名類型的隱藏。 abstract用來修飾抽象類，表示該類只能作為父類被用於繼承，而不能進行對象實例化。抽象類可以包含抽象的成員，但這並非必須。abstract不能和new同時用。下面是抽象類用法的偽碼： abstract class A{public abstract void F();}abstract class B: A{public void G() {}}class C: B{public override void F(){//方法F的實現}}抽象類A內含一個抽象方法F()，它不能被實例化。類B繼承自類A，其內包含了一個實例方法G(),但並沒有實現抽象方法F()，所以仍然必須聲明為抽象類。類C繼承自類B，實現類抽象方法F()，於是可以進行對象實例化。 sealed用來修飾類為密封類，阻止該類被繼承。同時對一個類作abstract和sealed的修飾是沒有意義的，也是被禁止的。

『貳』 java語言的編譯環境和c++有什麼區別，java的特色是什麼

Java不是編譯成本機機器代碼，而是編譯成自己的虛擬機代碼，由虛擬機解釋執行，C++是編譯成本機代碼執行的。
Java是一種跨平台，適合於分布式計算環境的面向對象編程語言。
具體來說，它具有如下特性：
簡單性、面向對象、分布式、解釋型、可靠、安全、平台無關、可移植、高性能、多線程、動態性等。
下面我們將重點介紹Java語言的面向對象、平台無關、分布式、多線程、可靠和安全等特性。
1.面向對象
面向對象其實是現實世界模型的自然延伸。現實世界中任何實體都可以看作是對象。對象之間通過消息相互作用。另外，現實世界中任何實體都可歸屬於某類事物，任何對象都是某一類事物的實例。如果說傳統的過程式編程語言是以過程為中心以演算法為驅動的話，面向對象的編程語言則是以對象為中心以消息為驅動。用公式表示，過程式編程語言為：程序=演算法+數據；面向對象編程語言為：程序=對象+消息。
所有面向對象編程語言都支持三個概念：封裝、多態性和繼承，Java也不例外。現實世界中的對象均有屬性和行為，映射到計算機程序上，屬性則表示對象的數據，行為表示對象的方法（其作用是處理數據或同外界交互）。所謂封裝，就是用一個自主式框架把對象的數據和方法聯在一起形成一個整體。可以說，對象是支持封裝的手段，是封裝的基本單位。Java語言的封裝性較強，因為Java無全程變數，無主函數，在Java中絕大部分成員是對象，只有簡單的數字類型、字元類型和布爾類型除外。而對於這些類型，Java也提供了相應的對象類型以便與其他對象交互操作。
多態性就是多種表現形式，具體來說，可以用「一個對外介面，多個內在實現方法」表示。舉一個例子，計算機中的堆棧可以存儲各種格式的數據，包括整型，浮點或字元。不管存儲的是何種數據，堆棧的演算法實現是一樣的。針對不同的數據類型，編程人員不必手工選擇，只需使用統一介面名，系統可自動選擇。運算符重載（operatoroverload)一直被認為是一種優秀的多態機制體現，但由於考慮到它會使程序變得難以理解，所以Java最後還是把它取消了。
繼承是指一個對象直接使用另一對象的屬性和方法。事實上，我們遇到的很多實體都有繼承的含義。例如，若把汽車看成一個實體，它可以分成多個子實體，如：卡車、公共汽車等。這些子實體都具有汽車的特性，因此，汽車是它們的「父親」，而這些子實體則是汽車的「孩子」。Java提供給用戶一系列類（class），Java的類有層次結構，子類可以繼承父類的屬性和方法。與另外一些面向對象編程語言不同，Java只支持單一繼承。
2�平台無關性
Java是平台無關的語言是指用Java寫的應用程序不用修改就可在不同的軟硬體平台上運行。平台無關有兩種：源代碼級和目標代碼級。C和C++具有一定程度的源代碼級平台無關，表明用C或C++寫的應用程序不用修改只需重新編譯就可以在不同平台上運行。
Java主要靠Java虛擬機（JVM）在目標碼級實現平台無關性。JVM是一種抽象機器，它附著在具體操作系統之上，本身具有一套虛機器指令，並有自己的棧、寄存器組等。但JVM通常是在軟體上而不是在硬體上實現。（目前，SUN系統公司已經設計實現了Java晶元，主要使用在網路計算機NC上。
另外，Java晶元的出現也會使Java更容易嵌入到家用電器中。）JVM是Java平台無關的基礎，在JVM上，有一個Java解釋器用來解釋Java編譯器編譯後的程序。Java編程人員在編寫完軟體後，通過Java編譯器將Java源程序編譯為JVM的位元組代碼。任何一台機器只要配備了Java解釋器，就可以運行這個程序，而不管這種位元組碼是在何種平台上生成的。另外，Java採用的是基於IEEE標準的數據類型。通過JVM保證數據類型的一致性，也確保了Java的平台無關性。
Java的平台無關性具有深遠意義。首先，它使得編程人員所夢寐以求的事情（開發一次軟體在任意平台上運行）變成事實，這將大大加快和促進軟體產品的開發。其次Java的平台無關性正好迎合了「網路計算機」思想。如果大量常用的應用軟體（如字處理軟體等）都用Java重新編寫，並且放在某個Internet伺服器上，那麼具有NC的用戶將不需要佔用大量空間安裝軟體，他們只需要一個
Java解釋器，每當需要使用某種應用軟體時，下載該軟體的位元組代碼即可，運行結果也可以發回伺服器。目前，已有數家公司開始使用這種新型的計算模式構築自己的企業信息系統。
3�分布式
分布式包括數據分布和操作分布。數據分布是指數據可以分散在網路的不同主機上，操作分布是指把一個計算分散在不同主機上處理。
Java支持WWW客戶機/伺服器計算模式，因此，它支持這兩種分布性。對於前者，Java提供了一個叫作URL的對象，利用這個對象，你可以打開並訪問具有相同URL地址上的對象，訪問方式與訪問本地文件系統相同。對於後者，Java的applet小程序可以從伺服器下載到客戶端，即部分計算在客戶端進行，提高系統執行效率。
Java提供了一整套網路類庫，開發人員可以利用類庫進行網路程序設計，方便得實現Java的分布式特性。
4�可靠性和安全性
Java最初設計目的是應用於電子類消費產品，因此要求較高的可靠性。Java雖然源於C++，但它消除了許多C++不可靠因素，可以防止許多編程錯誤。首先，Java是強類型的語言，要求顯式的方法聲明，這保證了編譯器可以發現方法調用錯誤，保證程序更加可靠；其次，Java不支持指針，這杜絕了內存的非法訪問；第三，Java的自動單元收集防止了內存丟失等動態內存分配導致的問題；第四，Java解釋器運行時實施檢查，可以發現數組和字元串訪問的越界，最後，Java提供了異常處理機制，程序員可以把一組錯誤代碼放在一個地方，這樣可以簡化錯誤處理任務便於恢復。
由於Java主要用於網路應用程序開發，因此對安全性有較高的要求。如果沒有安全保證，用戶從網路下載程序執行就非常危險。Java通過自己的安全機制防止了病毒程序的產生和下載程序對本地系統的威脅破壞。當Java位元組碼進入解釋器時，首先必須經過位元組碼校驗器的檢查，然後，Java解釋器將決定程序中類的內存布局，隨後，類裝載器負責把來自網路的類裝載到單獨的內存區域，避免應用程序之間相互干擾破壞。最後，客戶端用戶還可以限制從網路上裝載的類只能訪問某些文件系統。
上述幾種機制結合起來，使得Java成為安全的編程語言。
5�多線程
線程是操作系統的一種新概念，它又被稱作輕量進程，是比傳統進程更小的可並發執行的單位。
C和C++採用單線程體系結構，而Java卻提供了多線程支持。
Java在兩方面支持多線程。一方面，Java環境本身就是多線程的。若干個系統線程運行負責必要的無用單元回收，系統維護等系統級操作；另一方面，Java語言內置多線程式控制制，可以大大簡化多線程應用程序開發。Java提供了一個類Thread，由它負責啟動運行，終止線程，並可檢查線程狀態。Java的線程還包括一組同步原語。這些原語負責對線程實行並發控制。利用Java的多線程編程介面，開發人員可以方便得寫出支持多線程的應用程序，提高程序執行效率。必須注意地是，Java的多線程支持在一定程度上受運行時支持平台的限制。例如，如果操作系統本身不支持多線程，Java的多線程特性可能就表現不出來。

『叄』 C++題目，有大佬過來看看么 定義學生類。 （1）類名：STUDENT；

預備知識：

c++中我們cpp文件和.h文件的區別是，cpp文件是需要編譯的文件，成為一個獨立的編譯單元，而h文件從來是不需要編譯，只是用於預處理。

通常我們在cpp文件中，完成函數的實現，然後在h中則是對於函數的聲明，由於默認情況下，全局變數和全局函數存儲類型都是extern類型的，所以我們不需要顯示的使用extern

這樣，我們其他的cpp文件，只要#include .h文件，則在cpp中實現的函數，就能在其他cpp中使用，因為我們已經用.h文件，完成了extern函數聲明的操作。

c++類的定義，其實就是定義一個類型。

class A{

public：

void fun（int n）；

int fun1（void）；

public：

int num；

}；

其實就是定義了一種類型。和我們通常所說的定義不一樣。

類的定義，是不能重復定義的，在同一個編譯單元中，只能定義類一次。如果重復定義，會出錯。同時類聲明和類定義都是內部鏈接。只是為當前編譯單元所用。

因此，把類的定義，放在.h文件中，類的實現放在專門的cpp中。這樣包含.h的其他cpp，就可以使用cpp中實現的函數。。

同時注意：類的實現cpp文件的編譯，必須依賴於類的定義文件.h，所以我們在類實現文件cpp中必須#include< ........h>，用於編譯，否則會出錯。這是不同於普通的函數。

//student.h(這是頭文件，在此文件中進行類的聲明)
classStudent//類聲明
{public:
voiddisplay();
private:
intnum;
charname[20];
charsex;
};
//student.cpp//在此文件中進行函數的定義
#include<iostream>
#include″student.h″
voidStudent∷display()
{cout<<″num:″<<num<<endl;
cout<<″name:″<<name<<endl;
cout<<″sex:″<<sex<<endl;
}
//main.cpp主函數模塊
#include<iostream>
#include″student.h″
intmain()
{Studentstud;
stud.display();
return0;
}

類中只有static成員變數。具有外部鏈接特性。所以這要求，static成員變數的初始化一定要在.Cpp文件中。如果在h文件中。那麼多個cpp文件#include,則發生多次重復定義的錯誤。

類定義和類實現分離的好處：

1/快編譯速度

當然可以啊。相反，如果你把類的所有代碼都內聯定義到頭文件中，那麼所有需要用到這個類的CPP文件實際上都包含了更多的代碼，編譯器編譯每個這樣的CPP文件時都編譯了這些代碼。而分開定義，這些代碼就只被編譯了一遍，也就是在編譯實現那個類的CPP文件時。

在特殊情況下確實可以的
假如我有一個類a被幾百個cpp同時包含，如果定義和聲明放在一起，只要我對a進行任何修改，那幾百個文件都必須被重新編譯。而如果頭文件只包含聲明，修改a的實現不會導致那些文件被重新編譯，有時可以極大的提高速度

在C++中，類的定義方法如下：

class 類名{
訪問范圍說明符：
成員變數1
成員變數2
成員函數聲明1
成員函數聲明2

訪問范圍說明符：
更多成員變數
更多成員函數聲明
...
};

類的定義要以;結束。

「訪問范圍說明符」一共有三種，分別是 public、private 和 protected。三者的區別後面會詳細介紹，目前暫且都用 public。「訪問范圍說明符」可以出現任意多次。

「成員變數」的寫法與普通的變數定義相同。稱其為成員變數，是因為這些變數是一個類的成員。

同樣地，「成員函數聲明」的寫法也與普通的函數聲明相同。

一個類的成員函數之間可以互相調用。類的成員函數可以重載，也可以設定參數的默認值。

以前所學的函數不是任何類的成員函數，可稱為「全局函數」。

成員變數就代表對象的「屬性」，成員函數就代表對象的「方法」。成員變數和成員函數出現的先後次序沒有規定。

成員函數的實現可以位於類的定義之外，格式如下：

返回值類型 類名:函數名()
{
函數體
}

定義類之後，就可以定義對象了。定義對象的基本方法如下：

類名 對象名;

此處，「對象名」的命名規則和普通變數相同。對象也可以看作「類變數」

類的示常式序剖析

下面來看一個用面向對象的方法進行 C++ 程序設計的例子。

例題：編寫一個程序，輸入矩形的寬度和高度，輸出其面積和周長。

這個程序比較簡單，實際上根本不需要用面向對象的方法進行設計，這里只是為了使讀者更容易理解類和對象的概念。

首先要做的事情是分析問題中有哪些「對象」。比較明顯，只有「矩形」這種對象。然後要進行「抽象」，即概括「矩形」這種對象的共同特點。

矩形的屬性就是寬度和高度。因此需要兩個變數，分別代表寬度和高度。

一個矩形可以有哪些方法（即可以對矩形進行哪些操作）呢？在本程序中，矩形可以有設置寬度和高度、計算面積和計算周長三種行為，這三種行為可以各用一個函數實現，它們都會用到寬度和高度這兩個變數。

「抽象」完成後，就可以用 C++ 提供的語法特性寫出一個「矩形類」，將矩形的屬性和方法「封裝」在一起。程序如下：

#include <iostream>
using namespace std;
class CRectangle
{
public:
int w, h; //成員變數，寬和高
void init( int w_,int h_ ); //成員函數，設置寬和高
int area(); //成員函數， 求面積
int perimeter(); //成員函數，求周長
}; //必須有分號
void CRectangle::init( int w_,int h_ )
{
w = w_; h = h_;
}
int CRectangle::area()
{
return w * h;
}
int CRectangle::perimeter()
{
return 2 * ( w + h);
}
int main( )
{
int w,h;
CRectangle r; //r是一個對象
cin >> w >> h;
r.init( w,h);
cout << "It's area is " << r.area() << endl;
cout << "It's perimeter is " << r. perimeter();
cout << sizeof(CRectangle) << endl;
return 0;
}

『肆』 什麼是語言描述方法有哪些分類急！請以<荷塘月色>234段為例說明！

第一節、設計和開發的原則

關於程序設計的指導性原則沒有唯一的標准，這里顯示已被應用的一種可選方案。

一、軟體開發的「流程化」

1）軟體開發的各個環節是相互依存的

軟體開發過程當中不只有程序設計環節中的編碼和調試。

設計、編碼、調試可被明確定義，在實際開發中不能嚴格在時間和空間上獨立，彼此是相聯系，互相作用的。

2）明確的開發模型

避免「瀑布式」的開發模型，在目標明確的情況下，整體性地關注並適當進入細節，不應彼此脫節。

3）理想的開發流水線

二、軟體開發的「結構化」

1）嚴格的框架式開發

編碼員和設計者分工時，遵循標準的框架，可以獲得較少的通信和經驗總結。

2）嚴格的規范

制定有效的命名法，文檔格式，注釋，調試等指導性原則，在適當的地方更靈活地完成，而在一些地方按照基本法則行事。

三、軟體開發的「模塊化」

1）可選材料的改制和擴展

內部改制可能是不被允許的，但在原規范上的、基於某種具備前瞻性的實現手段的擴充可能總是可行的，前者形如已編譯鏈接庫中的代碼片斷，後者可基於類和模板的實現。或者實現為一類組件對象模型的用戶，向下派生出具備擴充能力的兼容介面。

2）盡可能設計滿足通用需求的組件

設計通用的組件不一定是最高效的，但應該具備廣泛的兼容性，以便在各種場合均能派上用場。為此局部系統在實現的時候將可能作一些妥協。

3）簡單、易用、可維護性的介面和實現

一個系統應建立於多個抽象層次之上，並使每個層次有著類似的應用規范，即它們都具有：

1、界面

2、上下文數據

3、同抽象層次間的通信

4、可擴展

5、信息隱蔽

6、可被視為完整、獨立的邏輯單元

四、軟體開發的「簡潔性」

任一種程序設計范性的最一般表述層：引導對象和行為的呈現，應基於可被良好理解的一般性的邏輯結構上，過於追求「擬真」的效果和「華麗」的語法修飾可能為項目帶來效率、維護等方面不可預知的額外開銷。

第二節、發現和描述類

一、類設計的主要環節

1）基本概念、相互關系

2）初始化和簡要操作

3）細化、依賴關系

4）公用操作、內部構造、擴展介面等界面實現

二、發現類

1）從應用出發，兼顧已有實現

2）函數對象是一種擬函式，仿照函數語法，操控符是帶有參數和函數指針的特殊類，通過流的輸入、輸出運算符的重載，影響流的行為

3）附帶類「特徵」、「分類」信息的繼承結構，使得使用者可根據其特性選擇不同動作，通過重載 / RTTI 及其他簿記機制等

4）用例（use case）是一個系統在一次特定使用的描述，發現更多的用例，且不能指望得到所有的用例（排除部分使用情況有限的系統功能），了解哪些是主要的，哪些是次要的。以完成當前這一輪的設計和實現工作

5）不要嘗試設計「理想系統」

三、描述操作

1）尋找最小的操作集

2）提供協助函數

3）過於單一的實現策略和對資源的依賴將限制系統的可擴展性、依賴性

4）操作的類別

1、對象構成

2、詢問

3、更新

4、行為、生成

5、附加的操作符、迭代器、切割符

上述操作相互之間可能是互相覆蓋：迭代器被解引用將查詢數據，被執行偏移將可能引起數據的讀出或者寫入；更新的操作可以返回舊值以備用；行為、生成操作可能引起狀態更新，如文件讀寫，或者導致不支持再讀取 / 寫入狀態，如關閉一個文件。

C++ 中對上述類型操作的支持技術：

1、對象構成：構造、復制構造、序列輸入、析構

2、詢問：const 支持對常量對象的優先訪問和承諾不修改對象內部信息

3、更新：static 靜態數據成員是對象間共享的，任何一個對象對該成員的更改將影響其他對象；private 數據僅由當前對象的成員方法或者友元訪問，外部訪問通過指定方法修改更新而不涉及過多的細節，使用虛函數形成界面規范；protected 則向派生類公開數據訪問的許可權

4、行為、生成：運算符重載、類型轉換

5、迭代器、切割器：迭代器將當前對象的數據索引形成包裝在一種類似指針行為的對象中，由其代為迭代元素；切割器接受有關規則描述，以及宿主對象的數據索引形式（如數據區指針）

四、依賴關系

不應試圖讓一個類作所有的事情，有一些局部性工作的類或者過程完成這些操作。

五、界面分離

為用戶和擴展分別提供公用界面和保護界面。

一個類應提供位於同一個抽象層次的操作。

* 在「設計中心」實現更一般的類。

第三節、系統設計要點

一、參照模型

為新項目的實施選擇可參照的已有模型，使設計者可以立即將注意力投入到一些精確的描述細節。

從模型可選方案中去考察應用到當前項目的可行性，並從其獲得幫助，而不是一種純粹的模仿，「設計的重用」。

二、模式

為設計中的一般性元素，設計針對問題、使用條件等的描述的建檔，稱為「模式」。

三、原型的構造

1）暗礁

原型可以忽視內部實現技巧、效率，並因此近於產品的外在特性，而可能被改良作為產品發布，並由此再在不良設計之上進行投入，並試圖在下一個版本進行性能優化，但這是違背原型在設計中的作用。

2）原型是為了分析構建細節和考察可行方案，性能和設計不是其注意力

四、調試

測試時，嘗試設計一些特定數據結構用於記載程序運行狀態和調試數據，並可能在適當的時候請求假定用戶的幫助。

assert 斷言分析一段代碼的狀態碼真值，該斷言在發布版本中被自動忽略，使用 exception 異常類的拋出以便總是產生程序中斷。

五、軟體維護

1）什麼是軟體維護

重新設計和重新實現。

2）什麼有利於軟體維護

1、命名、格式規范

2、明確的類層次和構造法則

3、易於拆解或分析的依賴性

4、界面友好、可擴展和移植

3）不利於軟體維護的項目給維護人員帶來的問題

1、可能僅靠實現去推測系統構成

2、局部補丁使系統不斷惡化

六、優化

1）為支持有效性能優化、局部調整，應當給出清晰簡單的設計

2）不要依賴直覺

七、可重用

1）在某個確定的框架，可簡化工作量的類型或者實用代碼

2）有意識地為重用涉及代碼，為未來的維護和可移植性提供空間

八、維持設計的完整性

每個小組成員進入細節的時候應仍把握他們的整體設計。

「整體設計文檔」——一小部分人應總是關心整體性的把握。

九、個人

1）一個組織指望一個可互換的團隊，意味著不允許他們利用自己更加擅長的技能高於實現所需的能力進行更好的工作

2）管理者應具備相當的技能和教育以便評估小組和項目的完成進度和小組成員的完成質量，而不是簡單地依靠：

1、代碼行數

2、錯誤修復數

3、運行時效率、外觀

這會導致：

1、拒絕重用

2、故意製造錯誤

3、為優化局部性能而寫出脆弱的難看的代碼

3）關鍵技術人員應保持其低替換率

管理者需要他們以及最新的相關技術知識。關鍵技術人員也需要勝任的管理者支持以及非技術環境的最低程度的理解。

4）不希望改變的人應適從於不需過多改變的領域而不是在一個顯著改變了成功條件的地方

第四節、語言相關的設計要點

一、熟悉語言特性

描述語言特性的材料的選擇可能影響到設計本身，設計者需要熟知語言的特性，避免在特定語言中表現不佳的應用方式。

二、不同語言環境下的設計經驗

在其他語言環境中的「不適當」的經驗用於當前語言可能引入歧途，「錯誤、生硬、低效率」。

在其他語言環境中的「過時」的經驗將不能發揮當前語言界已實現的更高抽象能力，而產生冗長乏味的重復代碼片斷。

使用其他語言的經驗可能帶來偏見，不能正確地看待當前語言環境的設計哲學。

在實現一種設計中，設計師優先從語言支持的特性中尋找直接對應的語法工具，而後才考慮更「笨拙」的實現。

明確在當前語言中能可用的，但被廣泛描述為「不建議使用」的語法特性，了解這么做的原因。

三、依賴關系的語言特性支持

在語言特徵上支持依賴關系，使得顯式聲明彼此相關 / 無關的部分成為可行的、有幫助的。並給其他用戶提供良好的規范用法以及為幫助程序提供產生依賴圖的參考。

四、C++ 提供的語法工具

1）類信息、隱藏、依賴關系的描述

2）虛函數為繼承依賴關系維護一張調用表，以便總是訪問正確的方法，如虛析構函數

3）模板提供參數表，以在不同用戶需求時編譯成不同的專門化版本

4）異常藉助異常類的組織和堆棧回退對象析構機制來更好地管理和處理運行時異常

五、對 C++ 使用的偏差

1）C 子集，而忽略類

2）類的實施，而忽略類繼承關系

3）「純」面向對象。而忽視不能對象化的一般全局概念

所有這些不適當的使用都可能導致並不是很良好的設計並可能帶來不必要的負擔。

六、忽視類

1）代碼無法直接反映設計，缺乏類型系統

2）可能需要有高端的設計生成器

3）功能分解的設計將抵觸試圖進行的類風格的應用

4）不同的實現者可能不能協調，為了進行並行開發可能需要關注彼此更多的實現

5）公共數據對任何成員也是可訪問的，它可能散布在大量的實現細節中

6）類應總是被作為設計時的一種思考方式，而不是僵硬的使用

七、忽視繼承

1）原因可能是「繼承」破壞了信息隱藏，任何有心者可能會繼承一個已有類型，並暴露出內部信息

2）合理使用保護成員

3）什麼時候使用繼承：集合處理（接受基類指針的集合）、擴展描述一種設計概念

八、靜態類型檢查

編譯器的靜態類型檢查要求更良好的類型傳遞和使用，通過精確描述和強類型界面為編譯時提供良好的參考。

缺失的靜態類型檢查意味著不完整的規范。

* 為訪問到共同基類界面的集合操作使用基類指針傳遞，為訪問到明文一致的不同基類的操作使用模板函數。

九、實現良好的框架和系統

1）不論在哪個領域十分成功的應用框架，都不能消除程序設計的工作。應用框架在涉及更為精細的實踐中，其有效性會迅速降低

2）有優勢的規范系統應在代碼結構、外觀、基本思想與直接語言環境能夠良好融合

第五節、類的設計和實現

一、類的相互關系

二、類的分類

1）用戶類

2）資源類：硬體訪問、系統抽象

3）結構

4）內部類型、輔助結構

三、類的抽象層次

避免無意義的跨抽象層次的描述形式。

四、派生類和基類的類間依賴

一般認為派生類總是依賴於基類。同時，基類也可能依賴於派生類，如虛函數和保護成員。故基類可能在不知情的情況下訪問派生類的此類實現，其派生類應是可預期的行為。盡管基類對派生類的依賴不表現在明文上定義的先後順序。

五、虛函數在基類被聲明為 private 訪問許可權，派生類並不能直接訪問，但可以在派生類重載為公有的或者保護許可權的

六、包容

在類型中具有其他類型對象稱為對該類型的「包容」。

1）一個引用類型的成員對象應總是在初始化式中初始化引用

2）若要在運行時更改包含對象，優先選擇指針對象

3）在初始化式中的類對象構造式

class ClassType {

Inner inn;

ClassType()

: inn()

{

constructor-fields

}

class-fields

};

4）明確包含的關系，優先選擇對象類型

5）利用指針連接關系建立「對象層次結構」

七、is-has 關系

一個派生類對象同時是一個基類對象。

一個包容類對象具有一個成員類對象。

八、私有、保護派生稱為「實現繼承」

通過私有、保護派生的類型將無法隱式和靜態轉換到其基類 / 引用 / 指針，即使靜態類型轉換、基類復制構造是可行的。

和「實現繼承」相對立的是公有繼承中的「多態」，作為不同基類型的指針，對象具備不同的行為界面。

九、A 類使用 B 類的情況

1）聲明為友元類，或 B 類的某個成員函數作為 A 類的友元

2）調用 / 讀寫 B 類的相關成員

3）顯式 / 隱式創建 B 類對象，如作為函數返回值等

4）取 B 類型大小

十、為設計概念找到一種到程序設計的一一映射關系，並總是貫徹它，以支持語言不直接具有的特性

十一、類的不變式

1）具有對象的引用 / 指針成員，形成對象層次結構，這些值稱之為狀態

2）滿足某種限定條件的狀態，這種限制條件稱為對象的不變式

3）利用異常類，限定條件枚舉，檢查函數等在執行狀態更新時維護「不變式」邏輯

4）斷言，對不符合某種條件的表達式執行一種預定義動作

標准庫函數 cassert 在不設置 NDEBUG 預處理器符號的情況下，輸出錯誤文件名、行號，並執行 abort()。

十二、組件

1）可用於構造組件的設施：類、類繼承、名稱空間

2）類界面不應當依賴於類實現所依賴的環境

十三、模板

虛基類和模板分別支持對象化的和參數化的通用演算法技巧。前者基於統一基類的虛函數表提供一致界面，後者基於提供明文一致的函數形式以及。虛方法佔用運行時時間，模板佔用編譯時時間。

十四、界面與實現

1）使用包含類型的指針，引用以避免界面上的依賴，並在實現上使用此類指針 / 引用數據的成員，稱為類定義界面和實現的分離

2）界面上包含成員定義將使實現向編譯單元透明，以便在線化，其中涉及的細節應避免過於依賴的外部類型的成員訪問

3）界面上的成員定義盡可能使用簡單類型和標准庫類型

4）交集不明顯，但因錯誤 / 不良的設計指導風格而制定兼容多種界面的基類的形式易產生「肥大的界面」

第六節、運行時的類

一、具體類型

1）描述一種實體概念，不作為類層次結構的一部分

2）具體類型具有最小的依賴性

3）具體類的用戶對類實現反應敏感

4）具體類藉助模板演算法提供編譯時類型檢查，以提供靈活的 / 不損失性能的處理機制。為此為近似的操作提供明文一致的界面，或者使用輔助類型暴露通用的界面，如迭代器

二、抽象類

1）抽象類作為一系列派生類型的類型並定義一組通用的操作界面

2）依賴於抽象基類的用戶代碼在實際構造時使用的派生類發生修改時（派生類的定義和實例化位於和使用基類的用戶代碼不同的編譯單元），不引起重新編譯

3）抽象類為有意義的操作界面維護在虛函數表，無法完成在線化

三、結點

有意的概念描述類的實現稱為「結點」，結點使用基類服務，並具有一定的構造策略和實現，但並不被推薦構造最終的對象，而是作為該對象的局部實現。

通過 RTTI 嘗試訪問預期的界面。

四、動作

可以使用類以描述一組動作。

1）實現的動作需要在不同的場合攜帶有效數據並以一種預期的格式傳遞，則該動作並不能由純粹的函數實現，如演算法中的仿函式和輸入 / 輸出流的操控符

2）仿函式使用 operator() 作為動作識別，規范操控符分別將可能格式登記到 operator << 或 operator >> 運算符的重載列表中，並利用打包對象對輸入 / 輸出流狀態執行更改

3）設計使用不同的動作識別，作為一組動作序列統一進行處理

五、界面類

1）類型檢查、異常處理在界面類中進行處理，並將實現交給其基類或者包含的類對象 / 指針 / 引用

2）多重繼承的同名現象，使用包裝界面類提供新的可覆蓋虛函數間接訪問原有同名虛函數的實現，原虛函數將通過私有繼承而限制後續派生類的訪問

3）為什麼需要界面類：

1、向當前的設計風格妥協

2、適合於某種約定界面限制，以執行通用演算法

3、符合某種文化差異

4、隱藏不安全的界面

4）界面類又稱為包裝類 wapper。

六、句柄

1）為利用虛函數機制，需要使用指針、引用操作，這需要用戶參與管理。句柄是一種替為管理資源的類對象，並盡可能維護一組系統化的句柄類型

2）提供了比指針更多的附加信息

3）可以進行引用計數

4）應該是代價低廉的

『伍』 Turbo C V2.0

C++筆記(一)
變數與函數

變數聲明：
extern int i;
函數聲明：
extern float f(float);
float f(float); //extern在此不是必須的
float f(float a); //聲明中起作用的只有類型，與變數名無關
變數定義：（變數在第一次定義時被聲明）
int i;
函數定義：（有函數體的函數聲明就成了函數定義）
float f(float a) { return a + 1; }
有了聲明就必須有定義，有了定義聲明就可以不要，因為定義包含了聲明。

函數在定義時可以有未命名的參數。比如某參數在函數體中未被使用，則刪去此參數的名稱後編譯時就不會有變數未使用的警告。

func()在C++中表示沒有參數的函數，而在C中表示不確定的參數（這種情況下就會忽略類型檢查）。func(void)在C和C++中都表示沒有參數的函數。

C++中可以在程序的任何地方定義變數，但有些格式是不允許的。比如：
for (int i = 0, int j = 0; ...; ...;) // 只允許在for中定義一個變數
while ((char c = cin.get()) != 'q') // 定義變數時不允許使用括弧

局部變數都是auto的，因此沒有必要顯式地使用auto來修飾局部變數。

只能在塊中定義register變數。register變數不能被取址。（不推薦使用）

定義為static的變數可以在塊外繼續存在，但卻只能在塊內被訪問。比如在函數中定義時可以像全局變數一樣維持原有的值，但不像全局變數可以被程序的其他部分修改。（靜態存儲）

static修飾全局變數或函數時表示該變數或函數只在當前文件中有效（內部聯接）。（靜態可見性）

用extern修飾的變數或函數的定義可以在其他文件中出現（外部聯接）。全局變數和函數默認都是extern的（C++中的const除外）。

const修飾的變數在C++中只在文件內部有效（內部聯接），若要使它在其他文件中有效需要加上extern修飾。而在C中的const默認是extern的，因此不同文件中不允許有重名的const。

使用volatile修飾的變數會在每次需要的時候被重新讀取，編譯器不會對其加優化。

在成員函數里要使用同名的全局變數或函數時，在全局的函數名或變數名前加::，表示全局的域。

結構和數組

被嵌套的結構不能訪問嵌套其的結構私有成員，必須先聲明被嵌套的結構，再聲明其為friend，最後定義此結構。

對象在域結束後會被自動銷毀。析構函數會被自動調用，即使是使用goto語句跳出域也一樣。但是使用C標准庫中的setjmp()和longjmp()跳出時析構函數不會被調用。

如果給定一個數組的初始值小於數組的大小，數組中剩餘的元素會被初始化為0。如：
int b[6] = {0};
但只有數組定義沒有初始值時就沒有這種效果。

結構體的初始化也一樣：
struct X {
int i;
float f;
char c;
};
X x1 = { 1, 2.2, 'c' };
但當結構體中有構造函數時，必須通過構造函數初始化：
struct Y {
float f;
int i;
Y(int a);
};
Y y1[] = { Y(1), Y(2), Y(3) };

union中也能定義訪問控制、成員函數和構造/析構函數，但是union不能被繼承。

也可以定義匿名的union，這時訪問union中的成員不需要加上域標識符。

const

const int* u;和int const* v都表示指向常量的指針。int* const w;才表示指針常量。即const在*左邊表示指向常量的指針，const在*右邊表示指針常量。也可以理解為const只修飾它左邊的東西。

字元串數組應該是常量，因此像char* cp = "howdy";這樣的寫法按理不能修改字元串的內容，而應該寫成char cp[] = "howdy";。但為了與C代碼兼容，編譯器通常會容許這個錯誤。

只有不是const的返回值能被用作lvalue，因此若不希望函數返回的對象被用作lvalue，可以用const來修飾。

在表達式或函數求值的過程中編譯器生成的臨時對象都是const的。因此如果函數要以引用方式接受臨時對象作為參數時，參數引用也需要用const修飾。

類中的const只表示在初始化後不能改變，需要在構造函數初始化列表中初始化。如：
Fred::Fred(int sz) : size(sz) {}
這就使得const能在構造函數被定義時就被初始化。對於非const的類型的初始化也可以這樣進行。對於內置類型的初始化也可以用這種像是調用構造函數的形式。

類中以static修飾的const變數表示被這個類的所有對象共用。必須在定義時就被初始化。在舊的編譯器下，一般使用enum來代替。如static const int size = 100;就用enum { size = 100 };代替。

被聲明為const的對象只能調用其為const的成員函數。聲明為const的成員函數中不能對對象的內容進行修改或調用非const的成員函數。定義時const放在函數參數列表之後（放在前面會與const的返回值混淆）。

非const的對象也能調用const的成員函數。因此把不會改變對象內容的成員函數定義為const的就能具有最大的通用性。構造函數和析構函數不能是const的。

在const的成員函數中修改對象的成員：
1、將this轉換為普通的指針（const成員函數中的this是const指針），就能通過其來改變對象的成員，如：
((Y*)this)->i++;
或
(const_cast<Y*>(this))->i++;
2、以mutable修飾的成員能在const的成員函數中被修改。

關於預處理

#define的常量用const取代，宏用inline函數取代。

在類定義中定義的函數自動為內聯函數。也可以使用inline修飾函數使其成為內聯的。inline只有在函數定義時才會發揮作用。因此頭文件中的內聯函數都是有函數體的。inline的函數也是內部聯接的。
friend的函數也可以是inline的。

inline只是對編譯器的優化提示，編譯器不一定會對所有的inline進行內聯。

不可替代的預處理功能：
字元串化（#，將標識符轉化為字元串）：#define DEBUG(x) cout << #x " = " << x << endl
記號粘貼（##，連接兩個標識符形成一個新的標識符）：#define FIELD(a) char* a##_string; int a##_size

static

編譯器保證對static的內置類型賦初值。對於static的對象調用其默認的構造函數。

static對象的析構函數會在main()函數結束或調用exit()時被自動調用。因此在static對象的析構函數中調用exit()可能會導致遞歸調用。調用abort()時不會自動調用static對象的析構函數。

全局的對象是static的。因此全局對象的構造和析構函數可以用來在進入main()之前和退出main()之後完成一些工作。

對於全局的對象來說，因為其本身是靜態存儲的，因此使用static修飾的效果只是使其變為內部聯接。

靜態數據成員的定義：
class A {
static int i;
public:
//...
};
int A::i = 1;
只有static const的整型才能在類內部被初始化，其他類型都必須在外部（文件域中）被初始化。因此本地類（在函數中定義的類）中不能定義靜態成員。

static的成員函數在類中定義。為所有該類的對象共用，調用時可以直接使用類名::函數名。

static的成員函數只能訪問static的成員，因為static的成員沒有this。

static初始化的依賴關系（最好避免）。可參考iostream的實現（cin、cout和cerr都是在不同文件中的static對象）或另一種（居然無名！）方法。

namespace

#include <iostream.h>
意味著
#include <iostream>
using namespace std;
因為在標准化之前不存在名字空間，.h中的所有內容都是暴露的

namespace定義只能出現在全局域或另一個namespace中。定義的{}後沒有分號。可以跨越多個文件定義（不算重復定義）。也可以定義別名。如：
namespace Bob = BobsSuperDuperLibrary;

每個編譯單元都有一個未命名的namespace。通過將變數放入這個namespace中就可以不必將它們聲明為static的（內部聯接）。C++中要達到文件內的靜態就使用這種方法。

類中聲明的友元也會進入這個類所在的namespace。

using namespace只在當前域內有效（將namespace中的所有名稱注入當前域）。using namespace中引入的名稱可以被覆蓋。

聯接方式。比如需要在C++中調用C的庫中的函數：
extern "C" float f(int a, char b);
否則的話聯接程序可能無法解析函數調用。通常編譯器都會自動處理這種情況。

引用和指針

引用必須在創建時被初始化為引用某一個變數，並且一旦在初始化後就不能再改變被引用的對象。

函數返回引用時要注意引用的對象不能在函數返回後就不存在了，比如函數內部的變數。

拷貝構造函數接受的是本類的引用。定義拷貝構造函數就必須定義構造函數。

通過聲明一個private的拷貝構造函數可以防止對象被傳值。

指向特定類中成員的指針：
聲明：
int ObjectClass::*pointerToMember;
初始化：
int ObjectClass::*pointerToMember = &ObjectClass::a;
使用：
objectPointer->*pointerToMember = 47;
object.*pointerToMember = 47;
對於成員函數也適用

運算符重載

重載的運算符必須接受至少一個自定義類型。接受的參數都為內置類型的運算符無法被重載。

運算符作為類的成員函數被重載時，類的對象就作為第一個參數。注意此時函數的返回方式。

重載++a會調用operator++(a)，重載a++會調用operator++(a, int)，其中第二個int參數是不會被用到的，只是用來區分前綴和後綴調用。--的重載也是一樣。

=和[]只能作為成員函數被重載。()只能作為成員函數被重載，可以帶任意多個參數。（若可以不作為成員函數被重載，則對於內置類型的運算就可以被重載，這是沒有意義的）

->和->*也只能作為成員函數被重載，但對返回值有一定的限制。

.和.*不能被重載

返回值優化：
Integer tmp(left.i + right.i);
return tmp;
這樣編譯器需要三步才能完成（構造，拷貝，析構），而
return Integer(left.i + right.i);
則只需要一步

重載時作為成員或非成員函數的選擇：
所有的一元運算符 推薦作為成員
= () [] -> ->* 必須作為成員
+= -= /= *= ^=
&= |= %= >>= <<= 推薦作為成員
所有其他的二元運算符 推薦作為非成員

當對象還沒有被創建時，=調用的是構造函數或拷貝構造函數，為的是初始化對象；當對象已被創建時，=調用的才是operator=。因此
Fee fee(1);
Fee fum(fi);
這樣的寫法要比
Fee fee = 1;
Fee fum = fi;
這樣的寫法清晰。

在重載賦值運算符時，首先檢查是否是對自身賦值是個好習慣。

當對象中有指針時，拷貝構造函數通常需要連同復制出指針所指向的內容。而當此內容很大時，通常採用引用計數的方法，只在需要修改數據且引用數大於1時才復制內容。這種技術被稱為-on-write。

當構造函數接受一個其他類型的對象作為參數時，編譯器可以用它來進行自動類型轉換。如果不需要這樣的自動轉換，在構造函數前加上explicit。

也可以重載operator 類型名 來定義自動類型轉換。由於這種類型轉換是由源對象完成的（不像構造函數的類型轉換是由目標對象完成的），因此可以完成自定義對象到內置類型的轉換。

運算符重載為非成員函數時，運算符兩邊都可以進行自動類型轉換。

提供自動類型轉換時注意兩種類型之間只需提供一條轉換路徑，否則會出現二義性錯誤。

new和delete

new為對象分配空間並調用構造函數。delete調用對象的析構函數後釋放對象的空間。

delete對於零指針無效，因此人們通常在delete之後將指針設為零，以防止多次delete帶來的問題。

delete void*可能會帶來問題。由於編譯器不知道具體的類型，將導致對象的空間被釋放而沒有調用析構函數。這可能會引起內存泄漏。

a* p = new a[100];為數組中的每個對象分配空間並調用構造函數進行初始化。
delete []p;則完成相反的事。delete後的[]表示指針只是數組的首地址，編譯器會自
動獲取數組的大小完成釋放工作。由於表示首地址，最好定義為常量：
a* const p = new a[100];

當new找不到空間分配時，會調用new-handler。其默認行為是拋出異常。可以通過使用new.h中的set_new_handler()來定義作為new-handler的函數。

operator new和operator delete都可以被重載，用來完成一些自定義的內存管理功能：
void* operator new(size_t sz)
void operator delete(void* m)

當new和delete作為類的成員函數被重載時，為該類的對象分配空間時就會調用這些重載的操作符。

用於為數組分配空間的operator new[]和operator delete[]也能被重載。實際佔用的空間比分配的要多4個位元組，被系統用於存儲數組的大小。

重載的new可以接受任意多個參數，比如定義第二個參數，用於指明在何處分配空間：
void* operator new(size_t, void* loc)
使用時：
X* xp = new(a) X;
其中的a就是第二個參數。採用這種形式的new可能需要顯式調用析構函數：
xp->X::~X();
（因為對象可能不是構建在堆上，使用delete只能釋放堆上的空間）

繼承

合成和繼承都需要在構造初始化列表中對子對象進行初始化。

一旦在子類中定義了一個與超類中同名的函數，超類中所有同名的函數，不管函數特徵是否相同，都會變得不可見。

構造函數，析構函數，operator=不會在繼承時進入子類。

繼承默認是private的，即超類中的public成員在子類中也會變成private的。若只想暴露某些成員，可以在子類中的public部分使用using。這種情況下同名的重載函數會被全部暴露。

多態

C++中使用virtual關鍵字來聲明函數為延遲綁定的（或動態綁定）。函數的定義中不需要virtual。使用了virtual之後， upcast時調用的就是子類的重載函數，否則只能調用基類的。（C++使用virtual來使得動態綁定成為可選的，這是出於效率的考慮。其他語言如 Java和Python等默認就是使用動態綁定的）

擁有純虛函數的類是抽象類（提供了一個介面）。純虛函數在virtual定義後加上=0。

繼承抽象類的子類必須實現基類中所有的純虛函數，否則就還是抽象類。

純虛函數不能內聯定義。在定義後則可以被子類使用。

傳值的upcast會把對象切割，即子類會被切到只剩下基類的部分。抽象的基類可以避免這種情況，因為抽象類不允許實例化。

構造函數不能是virtual的，而析構函數可以。

模板

繼承可以重用對象，而模板可以重用代碼。

定義template時可以使用內置類型。它們的值可以是常量。如：
template<class T, int size = 100>

template不僅可以用來創建類模板，還能用來創建函數模板。

雜項

之間沒有標點符號的字元數組會被自動連接起來

C++標准中包含的不是STL，而是C++標准庫，它是由STL演變來的。

?運算符中:的兩邊必須都有表達式。

以,分隔的表達式，最後一個表達式的值會被返回。

C++中的類型轉換可以函數的形式，如float(n)等價於(float)n。

C++中的顯示類型轉換（提供一種容易辨別的形式）：
static_cast：類型收窄時可以避免編譯器的警告信息；同樣可用於類型放寬、void*的強制轉換和自動隱式轉換。
const_cast：用於轉換const和volatile，比如將一個普通指針指向一個const
reinterpret_cast：把一種類型當成另一種類型
dynamic_cast：用於downcast

sizeof是運算符而不是函數，用於類型時要加括弧，如sizeof(double)，用於變數時不用，如sizeof x。

顯式運算符：
邏輯運算符
and &&
or ||
not !
not_eq !=
位運算符
bitand &
bitor |
xor ^
and_eq &=
or_eq |=
xor_eq ^=
compl ~

『陸』 java 抽象怎麼理解

1. 抽象是一種面向對象的編程實踐的核心原則， Java具有所有OOPs原則，抽象是一個Java語言的主要構建塊。

2. 數據抽象的跨度從創建簡單的數據對象集合的實現復雜如HashMap或HashSet。

3. 控制抽象是結構化編程背後主要驅動力。

『柒』 java學習、：技術文章 |JAVA學習基礎

2、源文件聲明規則

當在一個源文件中定義多個類，並且還有import語句和package語句時，要特別注意這些規則。

一個源文件中只能有一個public類

一個源文件可以有多個非public類

源文件的名稱應該和public類的類名保持一致。例如：源文件中public類的類名是Employee，那麼源文件應該命名為Employee.java。

如果一個類定義在某個包中，那麼package語句應該在源文件的首行。

如果源文件包含import語句，那麼應該放在package語句和類定義之間。如果沒有package語句，那麼import語句應該在源文件中最前面。

import語句和package語句對源文件中定義的所有類都有效。在同一源文件中，不能給不同的類不同的包聲明。

類有若干種訪問級別，並且類也分不同的類型：抽象類和final類等。這些將在訪問控制章節介紹。除了上面提到的幾種類型，Java還有一些特殊的類，如：內部類、匿名類。

3、Java包：

包主要用來對類和介面進行分類。當開發Java程序時，可能編寫成百上千的類，因此很有必要對類和介面進行分類。（即包中包含很多種類的類和介面）

當編譯一個.java文件（即一個編譯單元）時，在.java文件中的每個類都會有一個輸出文件，而該輸出文件的名稱與.java文件中每個類的名稱相同，只是多了一個後綴名.class。因此在編譯少量.java文件之後，會得到大量的.class文件。每一個.java文件編譯以後都會有一個public類，以及任意數量的非public類。因此每個.java文件都是一個構件，如果希望許許多多的這樣的構件從屬於同一個群組，就可以在每一個.java文件中使用關鍵字package。而這個群組就是一個類庫。

如果使用package語句，它必須是.java文件中除注釋以外的第一句程序代碼。

4、許可權修飾符

Java中有四種許可權修飾符，這些修飾符控制對類，類的成員方法，類的成員變數的訪問；其作用范圍如下：

public：所有的類都可以訪問。

private：只有在同一個類中才可以訪問。

protected：同一個類中、同一個包中、子類中都可以訪問，其他包不可以。

包類型的，即默認類型同一個類中、同一個包中可以訪問到，其他包和子類不可以。

5、數據類型

byte: Java數據類型和c/c++基本類似，但Java中有byte類型，表示8位2進制的整數，相當於c/c++中的char.

常量：Java中常量用final表示，相當於const，final中的值是可以改變的；

-包裝類: 在開發過程中，有時候需要使用對象，而不是內置數據類型，因此java為每個內置數據類型提供了對應的包裝類所有的包裝類（Integer、Long、Byte、Double、Float、Short）都是抽象類Number的子類，對於字元也有相應的Character類。每個類具有相應的函數。

數組：java數組是對象，與c++不同，語法上與c++類似，java數組具有一個屬性length可以獲取數組的長度。（數組a，a.length為數組長度），Array類具有一些函數可以對數組進運算。

Java高級特性

1、Java中的介面

Java中類繼承只允許一個父類，當需要進行多個繼承時，需要使用介面。介面類似於類，定義時用interface替代類定義中的class，但裡面的方法只有定義沒有實現。介面文件的文件名必須與介面名相同。繼承介面的關鍵字為implement，與類的繼承extends相似，可以進行多繼承。介面繼承必須實現介面中的所有方法。

介面是規范，規定某個實現類里必須有那些方法，只要事先定義好介面，當大家一起合作的時候就不用特別麻煩的交互，而是每個人寫好自己的介面實現類，最後拼接到一起就可以了比如資料庫連接類，介面規定好有哪些方法、方法的功能，然後每個資料庫廠商根據介面去實現具體的類，達到統一的目的，要不每個資料庫廠商自己實現一套，那麼你編程的時候就要根據不同驅動使用不同的方法，造成不必要的麻煩。

2、Java中的抽象類

只聲明方法的存在而不具體實現的類，抽象類不能實例化（不能創建相應對象）定義方式：在class前加上abstract，ex：

abstractclass 類名{ ;;;}

抽象類中定義的沒有實際意義的，必須在子類重寫的方法為抽象方法，定義時前面加abstract：abstract type name(agrs)。

一般方法定義與在正常類中定義一樣。

java對象創建一般方式：ClassName obj = new ClassName();