2. 程式人生 > >c++單繼承、多繼承、菱形繼承記憶體佈局（虛擬函式表結構）

c++單繼承、多繼承、菱形繼承記憶體佈局（虛擬函式表結構）

阿新 • • 發佈：2019-02-17

這裡寫圖片描述

單繼承：只有一個基類和一個派生類

class Base
{
public:
    virtual void fun1()
    {
        cout << "Base::func1()" << endl;
    }
    virtual void fun2()
    {
        cout << "Base::func2()" << endl;
    }
private:
    int b;
};
class Derive :public Base
{
public:
    virtual void fun1()           //重寫基類虛擬函式,實現多型
 

    {
        cout << "Derive::func1()" << endl;
    }

    virtual void fun3()
    {
        cout << "Derive::func3()" << endl;
    }
    void fun4()
    {
        cout << "Derive::func4()" << endl;
    }
private:
    int d;
};
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33

1. 虛表就是存放虛擬函式的表。

2. 主函式中分別定義一個基類物件和一個派生類物件，通過除錯視窗可以看到所謂的虛表，如下圖（整型b和d未初始化）：

這裡寫圖片描述

>也許你會有疑問：除錯視窗中派生類虛表為什麼看不到Derive中的fun3()函式，這是編譯器的問題，我所用的是vs2013，在除錯的時候確實不見fun3()函式，所以有時編譯器的除錯視窗顯示的也不能完全相信，那有什麼辦法證明fun3()函式也在派生類虛表裡呢？通過列印虛表！

程式碼如下：

typedef void (*FUNC)();        //重定義函式指標，指向函式的指標
void PrintVTable(int* vTable)  //列印虛擬函式表
{
    if (vTable == NULL)
    {
        return;
    }
    cout << "虛擬函式表地址:" << vTable << endl;
    int  i = 0;
    for (; vTable[i] != 0; ++i)
    {
        printf(" 第%d個虛擬函式地址 :0X%x,->", i, vTable[i]);
        FUNC f = (FUNC)vTable[i];
        f();         //訪問虛擬函式
    }
    cout << endl;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
void Test1()
{
    Base b;
    Derive d;
    int* tmp = (int*)(*(int*)&b);     //取到虛擬函式的地址
    PrintVTable(tmp);
    int* tmp1 = (int*)(*(int*)&d);
    PrintVTable(tmp1);
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

解析：int* tmp = (int*)(*(int*)&b);

如下圖：

這裡寫圖片描述

列印虛表：

這裡寫圖片描述

>注意：

不知你是否注意到派生類中還有一個函式：void fun4(); 
虛擬函式是為了實現動態多型，是當程式執行到該函式時才會去虛表裡找這個函式；而函式的過載實現的是靜態多型， 是在程式編譯時就能找到該函式地址，而函式：void fun4();不是虛擬函式，自然不會在虛擬函式表裡。

這裡寫圖片描述

class Base1   //基類
{
public:
    virtual void fun1()
    {
        cout << "Base1::fun1" << endl;
    }
    virtual void fun2()
    {
        cout << "Base1::fun2" << endl;
    }
private:
    int b1;
};
class Base2  //基類
{
public:
    virtual void fun1()
    {
        cout << "Base2::fun1" << endl;
    }
    virtual void fun2()
    {
        cout << "Base2::fun2" << endl;
    }
private:
    int b2;
};
class Derive : public Base1, public Base2  //派生類
{
public:
    virtual void fun1()
    {
        cout << "Derive::fun1" << endl;
    }
    virtual void fun3()
    {
        cout << "Derive::fun3" << endl;
    }
private:
    int d1;
};
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42

除錯看結果：

這裡寫圖片描述

同樣以上面單繼承列印虛表函式來列印多繼承虛表：void PrintVTable(int* vTable); //列印虛擬函式表

void Test1()
{
    Derive d1;
    int* VTable = (int*)(*(int*)&d1);
    PrintVTable(VTable);
    VTable = (int*)(*((int*)&d1 + sizeof (Base1)/4));
    PrintVTable(VTable);
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

解析：VTable = (int*)(*((int*)&d1 + sizeof (Base1)/4));

這裡寫圖片描述

列印多繼承虛表如下圖：

這裡寫圖片描述

這裡寫圖片描述

先了解什麼是菱形繼承？

這裡寫圖片描述 
這裡寫圖片描述

下列程式碼是菱形繼承體系：

class Base          //Derive的間接基類
{
public:
    virtual void func1()
    {
        cout << "Base::func1()" << endl;
    }
    virtual void func2()
    {
        cout << "Base::func2()" << endl;
    }
private:
    int b;
};
class Base1 :public Base  //Derive的直接基類
{
public:
    virtual void func1()          //重寫Base的func1()
    {
        cout << "Base1::func1()" << endl;
    }
    virtual void func3()
    {
        cout << "Base1::func3()" << endl;
    }
private:
    int b1;
};
class Base2 :public Base    //Derive的直接基類
{
public:
    virtual void func1()       //重寫Base的func1()
    {
        cout << "Base2::func2()" << endl;
    }
    virtual void func4()
    {
        cout << "Base2::func4()" << endl;
    }
private:
    int b2;
};
class Derive :public Base1, public Base2
{
public:
    virtual void func1()          //重寫Base1的func1()
    {
        cout << "Derive::func1()" << endl;
    }
    virtual void func5()
    {
        cout << "Derive::func5()" << endl;
    }
private:
    int d;
};
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56

菱形繼承其實是一個單繼承與多繼承的結合。

這裡寫圖片描述

下面跟蹤Derive物件d的記憶體佈局：

這裡寫圖片描述

進一步解析如下圖：

這裡寫圖片描述

同樣以上面單繼承列印虛表函式來列印多繼承虛表：void PrintVTable(int* vTable); //列印虛擬函式表

這裡寫圖片描述

這裡寫圖片描述

這裡寫圖片描述

>1. 先來看下面兩個方案：

這裡寫圖片描述

> 主要解析第一種方案：

vs2003下虛繼承的VBPTR及VBTBL： 
在類中增加一個指標(VBPTR)指向一個VBTBL，這個VBTBL的第一項記載的是從VBPTR 與本類的偏移地址，如果本類有虛擬函式，那麼第一項是FF FF FF FC(也就是-4)，如果沒有則是零，第二項起是VBPTR與本類的虛基類的偏移值。

下面這段程式碼與上面菱形繼承（非虛繼承）類似：

class Base
{
public:
    virtual void fun1()
    {
        cout << "Base::fun1()" << endl;
    }
    virtual void fun2()
    {
        cout << "Base::fun2()" << endl;
    }
private:
    int b;
};
class Base1 :virtual public Base  虛繼承
{
public:
    virtual void fun1()          //重寫Base的func1()
    {
        cout << "Base1::fun1()" << endl;
    }
    virtual void fun3()
    {
        cout << "Base1::fun3()" << endl;
    }
private:
    int b1;
};
class Base2 :virtual public Base  //虛繼承
{
public:
    virtual void fun1()       //重寫Base的func1()
    {
        cout << "Base2::fun1()" << endl;
    }
    virtual void fun4()
    {
        cout << "Base2::fun4()" << endl;
    }
private:
    int b2;
};
class Derive :public Base1, public Base2
{
public:
    virtual void fun1()          //重寫Base1的func1()
    {
        cout << "Derive::fun1()" << endl;
    }
    virtual void fun5()
    {
        cout << "Derive::fun5()" << endl;
    }
private:
    int d;
};
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56

1. 詳細地分析一下vs2003下虛繼承的VBPTR及VBTBL：

- 以Base1 b1;為例子，詳細分析記憶體佈局如下（Base2和Base1的記憶體佈局相似）：

sizeof(Base1) = 20;(下圖中黑色區域中所有變數所佔的大小)

這裡寫圖片描述

當在主函式中定義兩個物件Base1 b1和Base2 b2時，還可通過除錯進一步探索其記憶體佈局如下：

這裡寫圖片描述

最後，我們再來探索一下 Derive d 的記憶體佈局，首先我們先通過除錯視窗來跟蹤如下：

這裡寫圖片描述

通過上面除錯視窗可能沒辦法瞭解全部，那麼請看下圖所示：

sizeof(Derive) = 36;(下圖黑色區域所有變數的大小)

這裡寫圖片描述

我們怎麼驗證菱形繼承（虛繼承）的記憶體佈局就是這樣的呢？我們可以通過列印虛表！！

typedef void(*FUNC)();
void PrintVPTR(int* VPTR)                   //列印虛表（虛擬函式）
{
    cout << "虛擬函式表地址：" << VPTR << endl;
    for (int i = 0; VPTR[i] != 0; ++i)
    {
        printf("第%d個虛擬函式地址：0X%x->", i, VPTR[i]);
        FUNC f = (FUNC)VPTR[i];
        f();
    }
    cout << endl;
}
void PrintVBPTR(int* VBPTR)                  //列印偏移地址與值
{
    cout << "虛擬函式表地址：" << VBPTR << endl;
    int i = 0;
    printf("與本類的偏移地址：0X%x\n", VBPTR[i]);
    for (i = 1; VBPTR[i] != 0; i++)
    {
        cout << VBPTR[i] << " " << endl;
    }
    cout << endl;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23

主函式中的呼叫如下：

void Test1()
{
    Base b;
    Base1 b1;
    Base2 b2;
    Derive d;
    cout << "sizeof_Base = " << sizeof(Base) << endl;
    int* BvTable = (int*)(*((int*)&b));
    PrintVPTR(BvTable);
    cout << "-------------------------------" << endl;

    cout << "sizeof_Base1 = " << sizeof(Base1) << endl;
    int* BVPTR1 = (int*)(*((int*)&b1));                             //存放自己的虛擬函式（虛表）
    PrintVPTR(BVPTR1);
    int* VBPTR1 = (int*)(*((int*)&b1 + 1));//訪問偏移地址以及偏移量
    PrintVBPTR(VBPTR1);
    int* VPTR1 = (int*)(*((int*)&b1 + (*(VBPTR1 + 1)) / 4 + 1));    //在Base1中訪問Base虛表
    PrintVPTR(VPTR1);
    cout << "-------------------------------" << endl;

    cout << "sizeof_Base2 = " << sizeof(Base2) << endl;
    int* BVPTR2 = (int*)(*((int*)&b2));                      //存放自己的虛擬函式（虛表）
    PrintVPTR(BVPTR2);
    int* VBPTR2 = (int*)(*((int*)&b2 + 1));//訪問偏移地址以及偏移量
    PrintVBPTR(VBPTR2);
    int* VPTR2 = (int*)(*((int*)&b2 + (*(VBPTR2 + 1)) / 4 + 1));//在Base2中訪問Base虛表
    PrintVPTR(VPTR2);
    cout << "-------------------------------" << endl;

    cout << "sizeof_Derive = " << sizeof(Derive) << endl;
    int* dVPTR1 = (int*)(*((int*)&d));                           //存放自己的虛擬函式（虛表）
    PrintVPTR(dVPTR1);
    int* dVBPTR3 = (int*)(*((int*)&d + 1));//訪問偏移地址以及偏移量
    PrintVBPTR(dVBPTR3);
    int* dVPTR2 = (int*)(*((int*)&d + 3));                       //在Derive中訪問Base2虛表
    PrintVPTR(dVPTR2);
    int* dVBPTR = (int*)(*((int*)&d + 4));//訪問偏移地址以及偏移量
    PrintVBPTR(dVBPTR);
    int* VPTR = (int*)(*((int*)&d + (*(dVBPTR3 + 1)) / 4 + 1));  //在Derive中訪問Base虛表
    PrintVPTR(VPTR);
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41

總結：

  1. 虛基類例項地址 = 派生類虛擬函式指標+派生類虛擬函式指標到虛基類例項地址的偏移量
  2. 可以通過虛擬繼承消除二義性，但是虛擬繼承的開銷是增加虛擬函式指標。

相關推薦

【C++】c++單繼承、多繼承、菱形繼承記憶體佈局（虛擬函式表結構）

單繼承：只有一個基類和一個派生類 class Base { public: virtual void fun1() { cout << "Base::func1()" << endl;

c++單繼承、多繼承、菱形繼承的記憶體佈局（虛擬函式表結構）

單繼承：只有一個基類和一個派生類 class Base { public: virtual void fun1() { cout << "Base::func1()" << endl; } vir

c++單繼承、多繼承、菱形繼承記憶體佈局（虛擬函式表結構）

單繼承：只有一個基類和一個派生類 class Base { public: virtual void fun1() { cout << "Base::func1()" << endl; } vir

c/c++ 繼承與多型 文字查詢的小例子（非智慧指標版本）

問題：在上一篇繼承與多型 文字查詢的小例子（智慧指標版本）在Query類裡使用的是智慧指標，只把智慧指標換成普通的指標，並不新增拷貝構造方法，會發生什麼呢？ 執行時，程式碼崩掉。 分析下面一行程式碼: Query qb = ~Query("Alice"); 1，首先呼叫Query(string)的建構

C++多型呼叫實現原理（虛擬函式表詳解)

1.帶有虛擬函式的基類物件模型 我們先看段程式碼： #include<iostream> using namespace std; class B1 { public: void func1() {} int _b; }; class B2 { pub

C++單繼承、多繼承情況下的虛擬函式表分析

C++的三大特性之一的多型是基於虛擬函式實現的，而大部分編譯器是採用虛擬函式表來實現虛擬函式，虛擬函式表（VTAB）存在於可執行檔案的只讀資料段中，指向VTAB的虛表指標（VPTR）是包含在類的每一個例項當中。當使用引用或指標呼叫虛擬函式時，首先通過VPTR找到VTAB，然後通過偏移量找到虛擬函式地址並呼叫。

虛擬函式、多型、單繼承虛表

虛擬函式 虛擬函式：類的成員函式前加virtual關鍵字，則稱這個成員函式為虛擬函式； 虛擬函式重寫 虛擬函式重寫：當在子類中定義了一個與父類完全相同的虛擬函式時，則稱子類的虛擬函式重寫（覆蓋）了父類的虛擬函式。子類重寫的虛擬函式可以沒有virtual（c++語

lua面向物件實現－類例項化物件、繼承、多型、多繼承、lua單例模式

lua面向物件實現： 一個類就像是一個建立物件的模具。有些面嚮物件語言提供了類的概念，在這些語言中每個物件都是某個特定類的例項。lua則沒有類的概念，每個物件只能自定義行為和形態。不過，要在lua中模擬類也並不困難。 lua中，面向物件是用元表這個機制來實現。

對象、繼承、封裝、多態、抽象類的組合應用

extends trac out ring -h system類 ber 小時 信息 對象、繼承、封裝、多態、抽象類的組合應用 編寫工資系統，實現不同類型員工(多態)的按月發放工資。如果當月出現某個Employee對象的生日，則將該員工的工資增加100元。 （1）定義一個E

慕課網Java入門第二季6.1 達達租車系統，使用到繼承、重寫、多態、toString函數

ati next println 構造方法 static class days 慕課網 mage 為了方便理解，畫了個UML圖，可以參考一下為了方便理解，畫了個UML圖，可以參考一下 定義Car類型：載人+載貨 public class Car { int id;

封裝、多態、繼承

否則 關系 只有一個 產生 如果 繼承 成功 指示 父類 封裝： 1. 減少大量冗余代碼 2. 將很難的實現細節封裝起來，起到保護和方便使用的目的 繼承： 1. 減少冗余代碼 2. 讓類與類產生關系，為多態打下了基礎 　　特性： 　　單根性：一個子類只有一個父類 　　傳

面向對象編程的三大特性：繼承、多態、封裝

部分 lap super 屬性 完整 搜索 查找 AS 父類 九 子類中調用父類的方法 方法一：指名道姓，即父類名.父類方法() View Code 方法二：super() View Code 強調：二者使用哪一種都可以，但最好不要混合使用 了解部分： 即使沒有

【17】有關python面向對象編程的提高【多繼承、多態、類屬性、動態添加與限制添加屬性與方法、@property】

爸爸 mce turn object get 寫法 pri import sel 一、多繼承 案例1：小孩繼承自爸爸，媽媽。在程序入口模塊再創建實例調用執行 #father模塊 class Father(object): def __init__(self,mon

多型？它的實現機制是什麼呢？過載和重寫的區別在那裡？這就是這一次我們要回顧的四個十分重要的概念：繼承、多型、過載和重寫。

什麼是多型？它的實現機制是什麼呢？過載和重寫的區別在那裡？這就是這一次我們要回顧的四個十分重要的概念：繼承、多型、過載和重寫。 繼承(inheritance) 簡單的說，繼承就是在一個現有型別的基礎上，通過增加新的方法或者重定義已有方法（下面會講到，這種方式叫重寫）的方式，產生一個新

JAVA基礎複習（三）繼承、多型、抽象類和介面

1、超類也稱為父類或者基類，次類又稱為子類或者拓展類、派生類。子類從它的父類中繼承可訪問的資料域和方法，還可以新增新資料域和新方法。 2、繼承：子類並不是父類的一個子集，子類比它的父類包含更多的資訊和方法；父類中的私有資料域在該類之外是不可訪問的；不是所有是一種關係都應該用繼承來建模，但是繼承是

對封裝、繼承、多型、抽象的理解

　封裝：是面向物件方法的重要原則，就是把物件的屬性和行為（資料）結合為一個獨立的整體，並儘可能隱藏物件的內部實現細節，就是把不想告訴或者不該告訴別人的東西隱藏起來，把可以告訴別人的公開，別人只能用我提供的功能實現需求，而不知道是如何實現的。增加安全性    &nbs

Java基礎複習第八天：繼承、過載、this與super、多型、static

一 繼承 1.繼承的由來 多個類中有相同成員變數和成員方法,那麼我們會把這些共性抽取到另外一個類中, 這時多個類只需要繼承剛剛抽取出來這個類即可 2.父類 和 子類 一個類A 繼承了 類B,那麼 類B稱為父類/超類/基類(superclass) 類

(D19)Python-封裝、多型、多繼承、重寫

封裝 enclosure 封裝是指隱藏類的實現細節，讓使用者不用關心這些細節 封裝的目的是讓使用者通過儘可能少的方法(或屬性)操作物件 私有屬性和方法: python類中以雙下劃線(’__’)開頭，不以雙下劃線結尾的識別符號為私有成員，

Java面向物件筆記（封裝、繼承、多型、抽象類、介面）

面向物件的思想在現實生活中很常見，例如專案開發，老闆想要實現某個功能，但是他自己不會這些技術，所以他就會讓員工去做這些事情，通過藉助別的擁有你想要實現某些功能的過程就可以理解為面向物件。 面向物件有三大特性：封裝、繼承、多型。 1.封裝：即是把函式或者工具類的實

Java物件和例項的關係、Java資料封裝、Java繼承和多型、Java抽象類和介面、Java靜態欄位和方法、Java包和作用域、Java的classpath和jar、Java核心類

Java物件和例項的關係： 面向物件程式設計（Object-Oriented Programming），是對現實世界建立計算機模型的一種方法。 class是物件的模板，它定義瞭如何建立例項，class的名字就是資料型別。一個class裡可以有多個欄位（field），欄位用