面向對象的基本概念

1.類

一些具有共性的事物，把共性集合在一起抽象出來的概念。
數據 + 行爲。數據用來描述對象的性質，狀態。行爲描述對象的行爲。

2.對象

抽象的概念它實體的反饋
是類的實體，這個實體將擁有具體的數據，能夠執行具體的行爲

3.對象和類

類是創建對象的模板，有了一個類以後，就可以創建這個類的對象，然後操作對象

4.接口、實現和消息傳遞

• 類的接口由對外公開的操作和屬性構成。它規定了我們能向特定的對象發出什麼請求。
• 類的實現主要由操作代碼構成。
• 向對象發出請求讓它執行某個操作或詢問對象本身的狀態，稱爲向對象發送消息。

5.信息隱藏和實現隱藏

信息隱藏：從外部看不到對象內部信息
實現隱藏：從外部看不到內部的實現步驟
所以提高了安全性

6.繼承

繼承允許在已有類的基礎上定義新類（派生類），
派生類自動擁有已有類（基類）的屬性和操作；
派生類可以增加自己特有的功能，也可以修改繼承得到的功能（覆蓋）。
軟件重用思想

7.多態性

類的多態性是指在一般類中定義的屬性或行爲，被特殊類
繼承之後，可以具有不同的數據類型或表現出不同的行爲。
靜態多態：通過函數重載、運算符重載或模板實現。
動態多態：通過類的繼承關係和虛函數機制實現。

類和對象的定義和使用

1.類和對象的定義和引用

類的定義一般包括兩個部分：聲明部分和實現部分。

class <類名> 
{
 public: <數據成員或成員函數的聲明>
 protected: <數據成員或成員函數的聲明> 
private: <數據成員或成員函數的聲明> 
};

• 類的實現主要是指類的成員函數的定義；
• 類的成員函數定義可在類體外進行，也可在類體內進行；
• 類定義中聲明的數據成員和成員函數都具有類作用域；
• 在類體外定義成員函數時，需用類名加域運算符“::”進行限定；~

例如：

下面是把display的定義寫在類外面，但必須在類內聲明並且在類外使用域運算符

2.構造函數

剛剛舉例的代碼裏有個毛病
我們發現渣男沒有被初始化，可以由客戶程序員
去定義一個函數去初始化，但是很麻煩，
所以類有構造函數
構造函數在對象被創建時使用特定的值構造對象，或者說將對象初始化爲一個特定的狀態。
構造函數是類中一個特殊的成員函數，其語法形式爲：

ClassName(<形參表>)
 {   ...  
}

或者

 ClassName::ClassName(<形參表>)
 {   ...  
}

舉例

構造函數特點
① 構造函數的函數名必須與類名相同
② 不能指定構造函數返回值的類型
③ 構造函數可以重載
④ 構造函數由系統調用
⑤ 構造函數一般是公有的或保護的成員函數
⑥ 若沒有定義構造函數，系統會提供一個默認構造函數

3.類和對象的定義和引用

對象成員的引用：
一種方法：
  	對象名. 成員名
另一種方法：
  	指針變量->成員名

4.常數據成員

• 在類中用const限定的數據成員爲常數據成員； 
• 常數據成員只能在構造函數的初始化列表中初始化； 
• const數據成員的值在對象的整個生命週期中都不會發生變化。

5.函數成員

• 將一個成員函數的聲明用const進行限制，能保證對象 的常量性；
• 常對象不能調用無const修飾的成員函數。 
• 常對象可以調用其 const成員函數。 
• 成員函數的實現部分也要帶有const關鍵字。

非常對象可以調用其 const成員函數。 
常成員函數的實現部分也要帶有const關鍵字。

6.友元函數

友元函數不是類的組成部分，但必須在被訪問的類內說明，
一般在類外定義，一般格式爲

friend <類型名> 友元函數名(形參表);

注意：
友元函數的說明可以出現在類的任何地方
友元函數可以訪問該類中的所有成員
友元關係不具有交換性和傳遞性
應謹慎使用友元函數

類的繼承

繼承和派生

1.保持已有類的特性而構造新類的過程稱爲繼承，在已有類的基礎上新增自己的特性而產生新類的過程稱爲派生。      
2.基類（父類）和派生類 ( 子類 能夠派生出其它類的類稱爲基類（父類），從基類派生出的新類稱爲派生類（子類）
3.單一繼承和多重繼承 當一個類僅由一個基類派生時，稱爲單一繼承；當 一個類由多於一個基類派生時，稱爲多重繼承

C++訪問控制權限

公有繼承

1.基類的所有成員在派生類中保持各個成員的訪問權限不變；
2.派生類中的成員函數可以直接訪問基類中的public和 protected成員，但不能直接訪問基類的private成員；
3.公有派生類繼承了基類的接口，能夠發送給基類對象的消息派生類對象也可以接收

class A
{
      int x;//不寫訪問權限默認是私有 
protected:
      int y;
public:
      int z;
      A(int a, int b, int c) {
            x = a; y = b; z = c;
      }
      int Getx() {
            return x;
      }
      int Gety() {
            return y;
      }
      void ShowA() {
      cout << x <<" " << y << " " << z << endl;
      }
};


class B :public A
{
      int Length, Width;
public:
      B(int a, int b, int c, int d, int e) :A(a, b, c) {
            Length = d; Width = e;
      }
      void ShowB() {
      cout << Length << " " << Width<< endl;
      cout << Getx() << " " << y <<" " << z << endl;
      }
      int Sum() {
            return (Getx() + y + z + Length + Width);
      }
};
int main(void) {
      B b1(1, 2, 3, 4, 5);
      b1.ShowA();
      b1.ShowB();
      cout << "Sum=" << b1.Sum() << endl;
      cout << "y=" << b1.Gety() << endl;
      cout << "z=" << b1.z << endl;
      return 0;
}