国产 无码 综合区,色欲AV无码国产永久播放,无码天堂亚洲国产AV,国产日韩欧美女同一区二区

C++ | 繼承(基類,父類,超類),(派生類,子類)

這篇具有很好參考價值的文章主要介紹了C++ | 繼承(基類,父類,超類),(派生類,子類)。希望對大家有所幫助。如果存在錯誤或未考慮完全的地方,請大家不吝賜教,您也可以點擊"舉報違法"按鈕提交疑問。

文章參考:https://blog.csdn.net/war1111886/article/details/8609957

一 .繼承中的訪問權(quán)限關(guān)系
1.基類,父類,超類是指被繼承的類,派生類,子類是指繼承于基類的類.?

2.在C++中使用: 冒號表示繼承,如class A : public B;表示派生類A從基類B繼承而來

3.派生類包含基類的所有成員,而且還包括自已特有的成員,派生類和派生類對象訪問基類中的成員就像訪問自已的成員一樣,可以直接使用,不需加任何操作符,但派生類仍然無法訪問基類中的私有成員.

4.在C++中派生類可以同時從多個基類繼承,Java 不充許這種多重繼承,當繼承多個基類時,使用逗號將基類隔開.

5.基類訪問控制符

? ? ?class A : public B ? ? ? ?基類以公有方式被繼承,

? ? ?class A:private B ? ? ? ?基類以私有方式被繼承,

? ? ?class A:protected B ? ?基類以受保護方式被繼承,如果沒有訪問控制符則默認為私有繼承。

6. protected 受保護的訪問權(quán)限:使用protected 保護權(quán)限表明這個成員是私有的,但在派生類中可以訪問基類中的受保護成員。派生類的對象就不能訪問受保護的成員了。

7. 如果基類以public公有方式被繼承,則基類的所有公有成員都會成為派生類的公有成員.受保護的基類成員成為派生類的受保護成員
? ? ? 如果基類以private私有被繼承,則基類的所有公有成員都會成為派生類的私有成員.基類的受保護成員成為派生類的私有成員.?

? ? ? 如果基類以protected 受保護方式被繼承,那么基類的所有公有和受保護成員都會變成派生類的受保護成員.

? ? ?不管基類以何種方式被繼承,基類的私有成員,仍然保有其私有性,被派生的子類不能訪問基類的私有成員.

例:繼承中的訪問權(quán)限關(guān)系
?

class A {
        int a;
    protected:
        int b;
    public:
        int c;
 
        A() { a = b = c = 1; }
    };
 
     //類B以公有方式從基類A繼承
    class B : public A {
    public:
        int d;
 
        B() {//a=2;  //錯誤,不能訪問基類中的私有成員
            b = 2;   //正確,可以在類中訪問基類中的受保護成員,但類的對象不能訪問,基類中的受保護成員b在類B中仍然是受保護成員
            c = d = 2;
            }
    }; //基類中的公有成員c在類B中仍然是公有成員
 
    //類C以受保護和私有方式從基類A繼承。
    class C : protected A {
    public:
        int e;
 
        C() {//a=3;  //錯誤,不能訪問基類中的私有成員
            b = c = e = 3;
        }
    };//這里基類受保護成員b和公有成員c都成為類C中的受保護成員。
 
    class D : private A {
        public:
        D()
        { b = c = 4; }
    };//基類中的公有和受保護成員都成為了類D中的私有成員。
 
  //驗證受保護和私有方式繼承的訪問權(quán)限。
    class C1 : public C {
    public:
        C1() { b = c = e = 4; }
    };//正確;類A中的成員b和c在類C中是以受保護方式被繼承的,b和c都成為了類C中的受保護成員。
 
    class D1 : public D {
    public:
        D1() {//b=5; //錯誤,在A中受保護的成員b在類D中是以私有方式繼承的,這樣b就成為了類D中的私有成員,所以無法訪問。
              //c=5; //錯誤,在A中公有的成員c在類D中是以私有方式繼承的,這樣c就成為了類D中的私有成員,所以無法訪問。
             }
    };
 
        int main()
        {
            A m1;
            B m2;
            C m3;
            D m4;
            //cout<<m1.b<<m2.b<<m3.b<<m4.b<<endl;   //錯誤;不能用類的對象訪問受保護的成員,只有在類中才能訪問。
            cout << m1.c <<endl;
            cout << m2.c <<endl;
            //cout<<m3.c<<endl;    //錯誤,類C是以受保護的方式從A繼承的,基類中的變量c在類C中就是受保護的,所以類的對象不能訪問
            //cout<<m4.c<<endl;    //錯誤,類C是以私有的方式從A繼承的,基類中的變量c在類C中就是私有的,所以類的對象不能訪
        }

二.覆蓋和隱藏基類成員變量或成員函數(shù)
1. 基類的成員變量或函數(shù)被覆蓋:

如果派生類覆蓋了基類中的成員函數(shù)或成員變量,則當派生類的對象調(diào)用該函數(shù)或變量時是調(diào)用的派生類中的版本,當用基類對象調(diào)用該函數(shù)或變量時是調(diào)用的基類中的版本。

2. 隱藏基類成員函數(shù)的情況:

如果在派生類中定義了一個與基類同名的函數(shù),不管這個函數(shù)的參數(shù)列表是不是與基類中的函數(shù)相同,則這個同名的函數(shù)就會把基類中的所有這個同名的函數(shù)的所有重載版本都隱藏了,這時并不是在派生類中重載基類的同名成員函數(shù),而是隱藏,比如類A中有函數(shù) f (int i , int j)和 f (int i)兩個版本,當在從A派生出的類B中定義了基類的 f() 函數(shù)版本時,這時基類中的 f (int i)和f (int i , int j)就被隱藏了,也就是說由類B創(chuàng)建的對象比如為m,不能直接訪問類A中的f(int i)版本,即使用語句m.f(2)時會發(fā)生錯誤。

3. 怎樣使用派生類的對象訪問基類中被派生類覆蓋或隱藏了的函數(shù)或變量:

? ? ? 3.1. 方法1 ? 使用作用域運算符:: ,在使用對象調(diào)用基類中的函數(shù)或變量時使用作用域運算符即語句m.A::f(2),這時就能訪問基類中的函數(shù)或變量版本。注意,訪問基類中被派生類覆蓋了的成員變量只能用這種方法
? ? ? 3.2.方法2 ? 使用using:: , 該方法只適用于被隱藏或覆蓋的基類函數(shù),在派生類的類定義中使用語句using 把基類的字包含進來,比如using A::f;就是將基類中的函數(shù)f()的所有重載版本包含進來,重載版本被包含到子類之后,這些重載的函數(shù)版本就相當于是子類的一部分,這時就可以用派生類的對象直接調(diào)用被派生類隱藏了的基類版本,比如m.f(2),但是使用這種語句還是沒法調(diào)用基類在派生類中被覆蓋了的基類的函數(shù),比如m.f()調(diào)用的是派生類中定義的函數(shù)f,要調(diào)用被覆蓋的基類中的版本要使用語句m.A::f()才行。

4. 在派生類的函數(shù)中調(diào)用基類中的成員變量和函數(shù)的方法:

就是在函數(shù)中使用的被派生類覆蓋的基類成員變量或函數(shù)前用作域解析符加上基類的類名,即A::f()就是在派生類的函數(shù)中調(diào)用基類中被派生類覆蓋了的函數(shù)f()的方法。

5. 派生類以私有方式被繼承時改變基類中的公有成員為公有的方法:

? ? ? 5.1.使用:: 作用域運算符,不提倡用這種方法,在派生類的public 后面用作用域運算符把基類的公有成員包含進來,這樣基類的成員就會成為派生類中的公有成員了,注意如果是函數(shù)的話后面不能加括號,如A::f;如果f是函數(shù)的話不能有括號。
? ? ? 5.2.使用using語句,現(xiàn)在一般用這種方法,也是在派生類的public使用using把基類成員包函進來,如using A::f。

例:隱藏或覆蓋基類中的成員,使用::作用域運算符訪問
————————————————
版權(quán)聲明:本文為CSDN博主「Sherlock_Homles」的原創(chuàng)文章,遵循CC 4.0 BY-SA版權(quán)協(xié)議,轉(zhuǎn)載請附上原文出處鏈接及本聲明。
原文鏈接:https://blog.csdn.net/Sherlock_Homles/article/details/82927515

class A {
    int a;
protected:
    int b;
public:
    int c, d;
 
    void f(int i) {
        cout << "class A" << "\n";
    }
 
    A() { a = b = c = d = 1; }
};
 
class B : public A {
public:
    int d;
     //覆蓋基類中的成員變量d。
    B() {
        b = c = d = 2;            //這里是給子類B中的成員變量d賦值,而不是基類中的d
        A::d = 3;
    } //給基類中被覆蓋的成員d賦值,注意在類中訪問的被覆蓋成員的方式。
    void f() {
        cout << "class B" << "\n";  //在子類中重定義基類中的同名函數(shù),雖然參數(shù)列表不一樣,但同樣會隱藏基類中的同名函數(shù)
        A::f(1);    //在函數(shù)中調(diào)用基類中被隱藏了的同名函數(shù)的方法,使用作用域解析運算符。
      //f(1);       //錯誤,因為基類中的函數(shù)被子類中的同名函數(shù)隱藏了,在這里子類不知道有一個帶參數(shù)的函數(shù)f。
    }
};
        int main() {
            B m;
            cout << m.d << "\n";      //輸出子類中的成員變量d的值,注意派生類中覆蓋了基類成員d.
            cout << m.A::d << "\n";   //輸出基類中的成員變量d的值,注意這是使用對象訪問被覆蓋的基類成員的方式
            m.f();                    //調(diào)用子類中的不帶參數(shù)的函數(shù)f。
         // m.f(2);                   //錯誤,因為基類中的帶一個參數(shù)的函數(shù)f被子類中的同名函數(shù)隱藏掉了,不能這樣訪問,須用作用域解析運算符來訪問。
            m.A::f(1);
        } //使用子類對象訪問基類中被隱藏的函數(shù)的方法。

例:使用using 語句以便訪問基類中被隱藏的函數(shù)

class A {
    int a;
protected:
    int b;
public:
    int c, d;
 
    void f() { cout << "Amoren" << "\n"; }
 
    void f(int i) { cout << "class A" << "\n"; }
 
    A() { a = b = c = d = 1; }
};
 
class B : public A {
public:
    int d;
     //覆蓋基類中的成員變量d。
    B() {
        b = c = d = 2;  //這里是給類B中的成員變量d賦值,而不是基類中的d
        A::d = 3;
    } //給基類中被覆蓋的成員d賦值,注意在類中訪問的被覆蓋成員的方式。
    using A::f;        //使用語句using把類A中的函數(shù)f包含進來,以便以后可以直接訪問基類被隱藏了的函數(shù),注意函數(shù)f沒有括號
 
    void f() {
        cout << "class B" << "\n";  //在子類中覆蓋基類中的同名函數(shù),注意這里是覆蓋,同時會隱藏基類中的其他同名重載函數(shù)
        f(1);       //正確,因為使用了using語句,所以可以在類中直接使用基類中f函數(shù)的重載版本。
        A::f(2);    //正確,雖然使用了using語句,但同樣可以按這種方法訪問基類中的函數(shù)。
        A ma;
        ma.f();     //正確,在子類中創(chuàng)建的基類對象,可以直接用對象名調(diào)用基類中被子類覆蓋或隱藏了的函數(shù),因為這時不會出現(xiàn)二義性。
        ma.f(1);    //正確,在子類中創(chuàng)建的基類對象,可以直接用對象名調(diào)用基類中被子類覆蓋或隱藏了的函數(shù),因為這時不會出現(xiàn)二義性。
    }
    
    void g() {
        cout << "this g" << "\n"; 
        f();        //正確,但該語句訪問的是子類中的不帶參數(shù)函數(shù)f,雖然在類中使用了using語句,但直接調(diào)用被子類覆蓋了的基類函數(shù)時不能使用這種方法
        A::f();     //正確,調(diào)用被子類覆蓋了的基類中的函數(shù)f,注意,雖然使用了using但要訪問被子類覆蓋了的函數(shù),只能這樣訪問。
    }
};
int main() {
    B m;
    m.f();       //調(diào)用子類中的不帶參數(shù)的函數(shù),這里不會調(diào)用基類中的不帶參數(shù)的被覆蓋的函數(shù)f。
    m.A::f();    //調(diào)用基類中被子類覆蓋了的函數(shù)f,雖然子類使用了using語句,但要訪問基類中被覆蓋的方法只能像這樣使用。
    m.f(1);      //調(diào)用基類重載的f函數(shù),注意這里可以不用::運算符,因為在子類中使用了using,只要子類沒有覆蓋基類中的方法,都可以這樣直接調(diào)用。
    m.A::f(2);   //當然,使用了using后,也可以使用這種方法
} 

例:派生類以私有方式被繼承時改變基類中的公有成員為公有的方法

class A {
public:
    int a, b;
    void f() { cout << "f" << "\n"; }
    void g() { cout << "g" << "\n"; }
};
 
class B : private A {
public:
    A::f;         //使用::運算符使基類中的成員成為公有的。注意函數(shù)名后不能有括號。(C++11標準不允許,使用using A::f)
    A::a;         //(C++11標準不允許,使用using A::a)
    using A::g;   //使用using語句使基類中的成員函數(shù)g成為類B中的公有成員,注意函數(shù)名后不能有括號。
};
int main() {
    B m;
  //m.b=1;        //錯誤,因為類B是以私有方式繼承的,類A中的成員在類B中是私有的,這里不能訪問私有成員。
    m.f();
    m.g();
    m.a = 1;
}

三.繼承時的構(gòu)造函數(shù)和析構(gòu)函數(shù)問題
1. 在繼承中,基類的構(gòu)造函數(shù)構(gòu)建對象的基類部分,派生類的構(gòu)造函數(shù)構(gòu)建對象的派生類部分。

2. 當創(chuàng)建派生類對象時先用派生類的構(gòu)造函數(shù)調(diào)用基類的構(gòu)造函數(shù)構(gòu)建基類,然后再執(zhí)行派生類構(gòu)造函數(shù)構(gòu)造派生類。
即先構(gòu)造基類再構(gòu)造派生類的順序。執(zhí)行析構(gòu)函數(shù)的順序與此相反。

3. 調(diào)用基類帶參數(shù)的構(gòu)造函數(shù)的方法:

在派生類的構(gòu)造函數(shù)中使用初始化列表的形式就可以調(diào)用基類帶參數(shù)的構(gòu)造函數(shù)初始化基類成員,如B():A(int i){},類B是類A的派生類。

4. 派生類的構(gòu)造函數(shù)調(diào)用基類的構(gòu)造函數(shù)的方法為:

4.1 如果派生類沒有顯示用初始化列表調(diào)用基類的構(gòu)造函數(shù)時,這時就會用派生類的構(gòu)造函數(shù)調(diào)用基類的默認構(gòu)造
函數(shù),構(gòu)造完基類后,才會執(zhí)行派生類的構(gòu)造函數(shù)函數(shù)體,以保證先執(zhí)行基類構(gòu)造函數(shù)再執(zhí)行派生類構(gòu)造函數(shù)
的順序,如果基類沒有默認構(gòu)造函數(shù)就會出錯。
4.2 如果派生類用 顯示的初始化列表調(diào)用基類的構(gòu)造函數(shù)時,這時就會檢測派生類的初始化列表,當檢測到顯示調(diào)
用基類的構(gòu)造函數(shù)時,就調(diào)用基類的構(gòu)造函數(shù)構(gòu)造基類,然后再構(gòu)造派生類,以保證先執(zhí)行基類構(gòu)造函數(shù)再執(zhí)
行派生類構(gòu)造函數(shù)的順序,如果基類沒有定義派生類構(gòu)造函數(shù)初始化列表調(diào)用的構(gòu)造函數(shù)版本就會出錯。

5. 如果在基類中沒有定義默認構(gòu)造函數(shù),但定義了其他構(gòu)造函數(shù)版本,這時派生類中定義了幾個構(gòu)造函數(shù)的不同版本,
這時只要派生類有一個構(gòu)造函數(shù)沒有顯示調(diào)用基類中定義的構(gòu)造函數(shù)版本就會發(fā)生錯誤,因為編譯器會首先檢查派
生類構(gòu)造函數(shù)調(diào)用基類構(gòu)造函數(shù)的匹配情況,如果發(fā)現(xiàn)不匹配就會出錯,即使沒有創(chuàng)建任何類的對象都會出錯,而
不管這個派生類的對象有沒有調(diào)用派生類的這個構(gòu)造函數(shù)。比如:基類有一個構(gòu)造函數(shù)版本A(int i)而沒有定義默認
構(gòu)造函數(shù),派生類B,有這幾個版本的構(gòu)造函數(shù)B():A(4){},B(int i):A(5){},再有語句B(int i, int j){}沒有顯示調(diào)用
基類定義的構(gòu)造函數(shù)而是調(diào)用基類的默認構(gòu)造函數(shù),如果創(chuàng)建了B m和語句B m(1)時都會提示沒有可用的基類默認
構(gòu)造函數(shù)可用的錯誤,雖然這時類B的對象m沒有調(diào)用派生類B的帶有兩個形參的構(gòu)造函數(shù),但同樣會出錯。

6. 同樣的道理,如果基類中定義了默認構(gòu)造函數(shù),卻沒有其他版本的構(gòu)造函數(shù),而這時派生類卻顯示調(diào)用了基類構(gòu)造
函數(shù)的其他版本,這時就會出錯,不管你有沒有創(chuàng)建類的對象,因為編譯器會先在創(chuàng)建對象前就檢查構(gòu)造函數(shù)的匹
配問題。

7. 派生類只能初始化他的直接基類。比如類C是類B的子類,而類B又是類A的子類,這時class C:public B{public:
B():A(){} };將會出錯,該語句試圖顯示調(diào)用類B的基類類A的構(gòu)造函數(shù),這時會出現(xiàn)類A不是類C的基類的錯誤。

8. 繼承中的復(fù)制構(gòu)造函數(shù)和構(gòu)造函數(shù)一樣,基類的復(fù)制構(gòu)造函數(shù)復(fù)制基類部分,派生類的復(fù)制構(gòu)造函數(shù)復(fù)制派生類部
分。

9.派生類復(fù)制構(gòu)造函數(shù)調(diào)用基類復(fù)制構(gòu)造函數(shù)的方法為:A(const A& m):B(m){}其中B是基類,A是派生類。

10.如果在派生類中定義了復(fù)制構(gòu)造函數(shù)而沒有用初始化列表顯示調(diào)用基類的復(fù)制構(gòu)造函數(shù),這時不管基類是否定義了
復(fù)制構(gòu)造函數(shù),這時出現(xiàn)派生類對象的復(fù)制初始化情況時就將調(diào)用基類中的默認構(gòu)造函數(shù)初始化基類的成員變量,
注意是默認構(gòu)造函數(shù)不是默認復(fù)制構(gòu)造函數(shù),如果基類沒有默認構(gòu)造函數(shù)就會出錯。也就是說派生類的復(fù)制構(gòu)造函
數(shù)的默認隱藏形式是B(const B& j):A(){}這里B是A的派生類,也就是說如果不顯示用初始化列表形式調(diào)用基類的
復(fù)制構(gòu)告函數(shù)時,默認情況下是用初始化列表的形式調(diào)用的是基類的默認構(gòu)造函數(shù)。

11.當在派生類中定義了復(fù)制構(gòu)造函數(shù)且顯示調(diào)用了基類的復(fù)制構(gòu)造函數(shù),而基類卻沒有定義基類的復(fù)制構(gòu)造函數(shù)時,
這時出現(xiàn)派生類對象的復(fù)制初始化情況就將調(diào)用基類中的默認復(fù)制構(gòu)造函數(shù)初始化基類部分,調(diào)用派生類的復(fù)制構(gòu)
造函數(shù)初始化派生類部分,因為復(fù)制構(gòu)造函數(shù)只有一種形式,即A(const A& m){},比如當出現(xiàn)調(diào)用時A(const A&
m):B(m){}如果這時基類B沒有定義復(fù)制構(gòu)造函數(shù),則該語句將會調(diào)用派生類A的默認復(fù)制構(gòu)造函數(shù)。

12.如果基類定義了復(fù)制構(gòu)造函數(shù),而派生類沒有定義時,則會調(diào)用基類的復(fù)制構(gòu)造函數(shù)初始化基類部分,調(diào)用派生類
的默認復(fù)制構(gòu)造函數(shù)初始化派生類部分。
?文章來源地址http://www.zghlxwxcb.cn/news/detail-615894.html

到了這里,關(guān)于C++ | 繼承(基類,父類,超類),(派生類,子類)的文章就介紹完了。如果您還想了解更多內(nèi)容,請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章,希望大家以后多多支持TOY模板網(wǎng)!

本文來自互聯(lián)網(wǎng)用戶投稿,該文觀點僅代表作者本人,不代表本站立場。本站僅提供信息存儲空間服務(wù),不擁有所有權(quán),不承擔相關(guān)法律責任。如若轉(zhuǎn)載,請注明出處: 如若內(nèi)容造成侵權(quán)/違法違規(guī)/事實不符,請點擊違法舉報進行投訴反饋,一經(jīng)查實,立即刪除!

領(lǐng)支付寶紅包贊助服務(wù)器費用

相關(guān)文章

  • 【C++】 為什么多繼承子類重寫的父類的虛函數(shù)地址不同?『 多態(tài)調(diào)用匯編剖析』

    【C++】 為什么多繼承子類重寫的父類的虛函數(shù)地址不同?『 多態(tài)調(diào)用匯編剖析』

    ?? 樊梓慕: 個人主頁 ??? 個人專欄: 《C語言》 《數(shù)據(jù)結(jié)構(gòu)》 《藍橋杯試題》 《LeetCode刷題筆記》 《實訓項目》 《C++》 《Linux》《算法》 ?? 每一個不曾起舞的日子,都是對生命的辜負 本篇文章主要是為了解答有關(guān)多態(tài)的那篇文章那塊的一個奇怪現(xiàn)象,大家還記得這張

    2024年02月19日
    瀏覽(26)
  • 【C++】面向?qū)ο缶幊蹋ǘ┟嫦驅(qū)ο蟮木幊趟季S:virtual虛擬調(diào)用、繼承、protected成員、派生類與基類

    默認情形下,成員函數(shù)的解析都是編譯時靜態(tài)進行。如果要讓成員函數(shù)的解析在程序運行時動態(tài)進行,需要在成員函數(shù)的聲明前加上virtual: 虛函數(shù)的作用: 用基類的指針指向不同的派生類的對象時,基類指針調(diào)用其虛成員函數(shù),會調(diào)用 真正指向?qū)ο蟮某蓡T函數(shù) ,而

    2024年02月07日
    瀏覽(25)
  • C# 父類實現(xiàn)的 IEquatable<T> 接口,重寫的相等性判斷函數(shù)都能被子類繼承

    C# 父類實現(xiàn)的 IEquatable<T> 接口,重寫的相等性判斷函數(shù)都能被子類繼承

    在父類重寫的 Equals 方法,繼承的 IEquatable 接口,重寫的 == ,!= 運算符,重寫的 GetHashCode 方法在子類中仍然是表現(xiàn)為被重寫的狀態(tài)。 現(xiàn)在讓子類也實現(xiàn) IEquatable 接口 此時代碼提示如下 子類實現(xiàn)接口后,調(diào)用的默認就是子類實現(xiàn)的 Equals 方法。也可以用強制轉(zhuǎn)換調(diào)用父類的

    2024年02月16日
    瀏覽(25)
  • Java 強制類型轉(zhuǎn)換原理(父類轉(zhuǎn)子類、子類轉(zhuǎn)父類)

    在Java中,對象的強制轉(zhuǎn)換(也稱為類型轉(zhuǎn)換)是將一個對象的引用轉(zhuǎn)換為另一個類的引用,前提是這兩個類之間存在繼承或?qū)崿F(xiàn)關(guān)系。強制轉(zhuǎn)換可能會導致運行時異常,因為在轉(zhuǎn)換的過程中,如果對象的實際類型與轉(zhuǎn)換的目標類型不兼容,就會拋出ClassCastException異常。 分析

    2024年02月07日
    瀏覽(20)
  • C++的基類和派生類構(gòu)造函數(shù)

    C++的基類和派生類構(gòu)造函數(shù)

    基類的成員函數(shù)可以被繼承,可以通過派生類的對象訪問,但這僅僅指的是普通的成員函數(shù),類的構(gòu)造函數(shù)不能被繼承。構(gòu)造函數(shù)不能被繼承是有道理的,因為即使繼承了,它的名字和派生類的名字也不一樣,不能成為派生類的構(gòu)造函數(shù),當然更不能成為普通的成員函數(shù)。

    2024年02月10日
    瀏覽(21)
  • c++和QT子類調(diào)用父類方法

    c++調(diào)用方式 : 父類名::方法名 QT調(diào)用方式 : __super::方法

    2024年02月13日
    瀏覽(16)
  • Java feign接口調(diào)用后返回子類,序列化子類反序列化只得到父類

    需要修改序列化方法 我存的時候放的子類,接收到卻是只有父類的數(shù)據(jù) feign默認使用jackson進行序列化,需要在父類上加上注解 @JsonTypeInfo(use = JsonTypeInfo.Id.CLASS) 在父類頭上增加注解: https://blog.csdn.net/qq_39493105/article/details/126061848

    2024年02月14日
    瀏覽(16)
  • Java父類強制轉(zhuǎn)換為子類的三種情況(推薦)

    Father f = new Father(); Son s = (Son)f;//出錯 ClassCastException Father f = new Son(); Son s = (Son)f;//可以 f只能用父類的方法 s可以用子類的所有方法 Son s = new Son(); Father f = (Father)s;//可以 f只能用父類的方法

    2024年02月08日
    瀏覽(24)
  • c++繼承和派生(1)

    c++繼承和派生(1)

    目錄 1.含義:從不同層面看的,同一種意思 2. 繼承的使用場景? 1.? 共同之處? 2.? 迭代更新? 3.? 代碼重構(gòu)? 3. 繼承的基本語法? 4. 繼承了什么? 1. 查看占用內(nèi)存大小 2.? 使用vs自帶的功能查看類的內(nèi)存分布 布局:? 3. 結(jié)果? 5. protected? -- 子類的特權(quán) 1)??三個訪問權(quán)限? 2)

    2024年01月17日
    瀏覽(15)

覺得文章有用就打賞一下文章作者

支付寶掃一掃打賞

博客贊助

微信掃一掃打賞

請作者喝杯咖啡吧~博客贊助

支付寶掃一掃領(lǐng)取紅包,優(yōu)惠每天領(lǐng)

二維碼1

領(lǐng)取紅包

二維碼2

領(lǐng)紅包