La capacità di a classe viene chiamato derivare proprietà e caratteristiche da un'altra classe Eredità . L'ereditarietà è una delle caratteristiche più importanti della programmazione orientata agli oggetti.
L'ereditarietà è una funzionalità o un processo in cui vengono create nuove classi dalle classi esistenti. La nuova classe creata è chiamata classe derivata o classe figlia e la classe esistente è conosciuta come classe base o classe genitore. Si dice ora che la classe derivata sia ereditata dalla classe base.
Quando diciamo che la classe derivata eredita la classe base, significa che la classe derivata eredita tutte le proprietà della classe base, senza modificare le proprietà della classe base e può aggiungere nuove funzionalità alle proprie. Queste nuove funzionalità nella classe derivata non influenzeranno la classe base. La classe derivata è la classe specializzata per la classe base.
- Sottoclasse: La classe che eredita le proprietà da un'altra classe è chiamata Sottoclasse o Classe Derivata.
- Superclasse: La classe le cui proprietà sono ereditate da una sottoclasse è chiamata Classe Base o Superclasse.
L’articolo è suddiviso nei seguenti sottoargomenti:
- Perché e quando utilizzare l'ereditarietà?
- Modalità di ereditarietà
- Tipi di eredità
Perché e quando utilizzare l'ereditarietà?
Consideriamo un gruppo di veicoli. È necessario creare classi per autobus, auto e camion. I metodi FuelAmount(), Capability() e ApplyBrakes() saranno gli stessi per tutte e tre le classi. Se creiamo queste classi evitando l'ereditarietà, allora dobbiamo scrivere tutte queste funzioni in ciascuna delle tre classi come mostrato nella figura seguente:
lente Java dell'array
Puoi vedere chiaramente che il processo sopra riportato comporta la duplicazione dello stesso codice 3 volte. Ciò aumenta le possibilità di errore e di ridondanza dei dati. Per evitare questo tipo di situazione, viene utilizzata l'ereditarietà. Se creiamo una classe Vehicle e scriviamo queste tre funzioni al suo interno ed ereditiamo il resto delle classi dalla classe Vehicle, possiamo semplicemente evitare la duplicazione dei dati e aumentare la riutilizzabilità. Guarda il diagramma seguente in cui le tre classi vengono ereditate dalla classe del veicolo:
Usando l'ereditarietà, dobbiamo scrivere le funzioni solo una volta invece che tre volte poiché abbiamo ereditato il resto delle tre classi dalla classe base (Veicolo).
Implementazione dell'ereditarietà in C++ : Per creare una sottoclasse ereditata dalla classe base dobbiamo seguire la sintassi seguente.
Classi derivate: Una classe derivata è definita come la classe derivata dalla classe base.
Sintassi :
class : { //body }>Dove
class: parola chiave per creare una nuova classe
derivato_class_name — nome della nuova classe, che erediterà la classe base
specificatore di accesso: privato, pubblico o protetto. Se nessuno dei due è specificato, PRIVATE viene utilizzato come predefinito
nome-classe-base — nome della classe base
Nota : Una classe derivata non eredita accesso ai membri con dati privati. Tuttavia, eredita un oggetto genitore completo, che contiene tutti i membri privati dichiarati da quella classe.
Esempio:
1. classe ABC: privato XYZ //derivazione privata
{ }
2. classe ABC: pubblica XYZ //derivazione pubblica
{ }
3. classe ABC: XYZ protetta //derivazione protetta
{ }
4. classe ABC: XYZ //derivazione privata per impostazione predefinita
{ }
Nota:
o Quando una classe base viene ereditata privatamente dalla classe derivata, i membri pubblici della classe base diventano i membri privati della classe derivata e pertanto è possibile accedere ai membri pubblici della classe base solo tramite le funzioni membro della classe derivata. Sono inaccessibili agli oggetti della classe derivata.
o D'altra parte, quando la classe base viene ereditata pubblicamente dalla classe derivata, i membri pubblici della classe base diventano anche membri pubblici della classe derivata. Pertanto, i membri pubblici della classe base sono accessibili sia dagli oggetti della classe derivata che dalle funzioni membro della classe derivata.
// Example: define member function without argument within // the class #include using namespace std; class Person { int id; char name[100]; public: void set_p() { cout << 'Enter the Id:'; cin>> identificativo; cout<< 'Enter the Name:'; cin>> nome; } void display_p() { cout<< endl <<'Id: '<< id << '
Name: ' << name <> corso; cout<< 'Enter the Course Fee:'; cin>> tariffa; } void display_s() { display_p(); cout<<'Course: '<< course << '
Fee: ' << fee << endl; } }; int main() { Student s; s.set_s(); s.display_s(); return 0; }> Produzione:
Enter the Id: 101 Enter the Name: Dev Enter the Course Name: GCS Enter the Course Fee:70000 Id: 101 Name: Dev Course: GCS Fee: 70000>C++
// Example: define member function without argument outside the class #include using namespace std; class Person { int id; char name[100]; public: void set_p(); void display_p(); }; void Person::set_p() { cout<<'Enter the Id:'; cin>>id; cout<<'Enter the Name:'; cin>>nome; } void Persona::display_p() { cout<>corso; cout<<'Enter the Course Fee:'; cin>>tariffa; } void Studente::display_s() { display_p(); cout<<'
Course: '< Produzione:
Enter the Id: 101 Enter the Name: Dev Enter the Course Name: GCS Enter the Course Fee: 70000 Id: 101 Name: Dev Course: GCS Fee: 70000>C++
// Example: define member function with argument outside the class #include #include using namespace std; class Person { int id; char name[100]; public: void set_p(int,char[]); void display_p(); }; void Person::set_p(int id,char n[]) { this->id=id; strcpy(questo->nome,n); } void Persona::display_p() { cout< CPP
// C++ program to demonstrate implementation // of Inheritance #include using namespace std; // Base class class Parent { public: int id_p; }; // Sub class inheriting from Base Class(Parent) class Child : public Parent { public: int id_c; }; // main function int main() { Child obj1; // An object of class child has all data members // and member functions of class parent obj1.id_c = 7; obj1.id_p = 91; cout << 'Child id is: ' << obj1.id_c << '
'; cout << 'Parent id is: ' << obj1.id_p << '
'; return 0; }> Produzione
Child id is: 7 Parent id is: 91>
Nel programma sopra, la classe 'Child' viene ereditata pubblicamente dalla classe 'Parent', quindi anche i dati pubblici membri della classe 'Parent' verranno ereditati dalla classe 'Child'.
Modalità di ereditarietà: Esistono 3 modalità di ereditarietà.
- Modalità pubblica : Se deriviamo una sottoclasse da una classe base pubblica. Quindi il membro pubblico della classe base diventerà pubblico nella classe derivata e i membri protetti della classe base diventeranno protetti nella classe derivata.
- Modalità protetta : Se deriviamo una sottoclasse da una classe base protetta. Quindi sia i membri pubblici che i membri protetti della classe base diventeranno protetti nella classe derivata.
- Modalità privata : Se deriviamo una sottoclasse da una classe base privata. Quindi sia i membri pubblici che i membri protetti della classe base diventeranno Private nella classe derivata.
Nota: Non è possibile accedere direttamente ai membri privati nella classe base nella classe derivata, mentre è possibile accedere direttamente ai membri protetti. Ad esempio, le classi B, C e D contengono tutte le variabili x, y e z nell'esempio seguente. È solo una questione di accesso.
CPP // C++ Implementation to show that a derived class // doesn’t inherit access to private data members. // However, it does inherit a full parent object. class A { public: int x; protected: int y; private: int z; }; class B : public A { // x is public // y is protected // z is not accessible from B }; class C : protected A { // x is protected // y is protected // z is not accessible from C }; class D : private A // 'private' is default for classes { // x is private // y is private // z is not accessible from D };>
La tabella seguente riassume le tre modalità precedenti e mostra lo specificatore di accesso dei membri della classe base nella sottoclasse quando derivata in modalità pubblica, protetta e privata:
scarica youtube con vlc
Tipi di eredità: -
- Eredità unica
- Eredità multilivello
- Eredità multipla
- Eredità gerarchica
- Eredità ibrida
Tipi di ereditarietà in C++
1. Eredità unica : Nell'ereditarietà singola, una classe può ereditare da una sola classe. cioè una sottoclasse viene ereditata solo da una classe base.
Sintassi :
class subclass_name : access_mode base_class { // body of subclass }; OR class A { ... .. ... }; class B: public A { ... .. ... };>CPP // C++ program to explain // Single inheritance #include using namespace std; // base class class Vehicle { public: Vehicle() { cout << 'This is a Vehicle
'; } }; // sub class derived from a single base classes class Car : public Vehicle { }; // main function int main() { // Creating object of sub class will // invoke the constructor of base classes Car obj; return 0; }> Produzione
This is a Vehicle>
C++
// Example: #include using namespace std; class A { protected: int a; public: void set_A() { cout<<'Enter the Value of A='; cin>>a; } void disp_A() { cout<Output:- Immettere il valore di A= 3 3 Immettere il valore di B= 5 5 Prodotto di 3 * 5 = 15
C++ // Example: #include using namespace std; class A { protected: int a; public: void set_A(int x) { a=x; } void disp_A() { cout<Product of 4 * 5 = 20>
2. Eredità multipla: L'ereditarietà multipla è una funzionalità del C++ in cui una classe può ereditare da più di una classe. cioè uno sottoclasse viene ereditato da più di uno classe base .
Sintassi :
class subclass_name : access_mode base_class1, access_mode base_class2, .... { // body of subclass }; class B { ... .. ... }; class C { ... .. ... }; class A: public B, public C { ... ... ... };>Qui, il numero di classi base sarà separato da una virgola (',') e dovrà essere specificata la modalità di accesso per ogni classe base.
CPP // C++ program to explain // multiple inheritance #include using namespace std; // first base class class Vehicle { public: Vehicle() { cout << 'This is a Vehicle
'; } }; // second base class class FourWheeler { public: FourWheeler() { cout << 'This is a 4 wheeler Vehicle
'; } }; // sub class derived from two base classes class Car : public Vehicle, public FourWheeler { }; // main function int main() { // Creating object of sub class will // invoke the constructor of base classes. Car obj; return 0; }>
Produzione This is a Vehicle This is a 4 wheeler Vehicle>
C++ // Example: #include using namespace std; class A { protected: int a; public: void set_A() { cout<<'Enter the Value of A='; cin>>a; } void disp_A() { cout<Per saperne di più si rimanda all'articolo Eredità multiple .
3. Eredità multilivello : In questo tipo di ereditarietà, una classe derivata viene creata da un'altra classe derivata.
bash per il ciclo
Sintassi:-
class C { ... .. ... }; class B:public C { ... .. ... }; class A: public B { ... ... ... };>CPP // C++ program to implement // Multilevel Inheritance #include using namespace std; // base class class Vehicle { public: Vehicle() { cout << 'This is a Vehicle
'; } }; // first sub_class derived from class vehicle class fourWheeler : public Vehicle { public: fourWheeler() { cout << 'Objects with 4 wheels are vehicles
'; } }; // sub class derived from the derived base class fourWheeler class Car : public fourWheeler { public: Car() { cout << 'Car has 4 Wheels
'; } }; // main function int main() { // Creating object of sub class will // invoke the constructor of base classes. Car obj; return 0; }>
Produzione This is a Vehicle Objects with 4 wheels are vehicles Car has 4 Wheels>
4. Eredità gerarchica : In questo tipo di ereditarietà, più di una sottoclasse viene ereditata da una singola classe base. cioè più di una classe derivata viene creata da una singola classe base.
Sintassi:-
class A { // body of the class A. } class B : public A { // body of class B. } class C : public A { // body of class C. } class D : public A { // body of class D. }>CPP // C++ program to implement // Hierarchical Inheritance #include using namespace std; // base class class Vehicle { public: Vehicle() { cout << 'This is a Vehicle
'; } }; // first sub class class Car : public Vehicle { }; // second sub class class Bus : public Vehicle { }; // main function int main() { // Creating object of sub class will // invoke the constructor of base class. Car obj1; Bus obj2; return 0; }>
Produzione This is a Vehicle This is a Vehicle>
5. Eredità ibrida (virtuale). : L'ereditarietà ibrida viene implementata combinando più di un tipo di ereditarietà. Ad esempio: combinazione di ereditarietà gerarchica ed ereditarietà multipla.
L'immagine sotto mostra la combinazione di eredità gerarchiche e multiple:
CPP // C++ program for Hybrid Inheritance #include using namespace std; // base class class Vehicle { public: Vehicle() { cout << 'This is a Vehicle
'; } }; // base class class Fare { public: Fare() { cout << 'Fare of Vehicle
'; } }; // first sub class class Car : public Vehicle { }; // second sub class class Bus : public Vehicle, public Fare { }; // main function int main() { // Creating object of sub class will // invoke the constructor of base class. Bus obj2; return 0; }>
Produzione This is a Vehicle Fare of Vehicle>
C++ // Example: #include using namespace std; class A { protected: int a; public: void get_a() { cout << 'Enter the value of 'a' : '; cin>>a; } }; classe B: pubblica A { protetta: int b; pubblico: void get_b() { cout<< 'Enter the value of 'b' : '; cin>>b; } }; classe C {protetto: int c; pubblico: void get_c() { cout<< 'Enter the value of c is : '; cin>>c; } }; classe D: pubblica B, pubblica C { protetta: int d; pubblico: void mul() { get_a(); get_b(); get_c(); cout<< 'Multiplication of a,b,c is : ' <
6. Un caso speciale di ereditarietà ibrida: ereditarietà multipath :
Una classe derivata con due classi base e queste due classi base hanno una classe base comune è chiamata ereditarietà multipath. In questo tipo di eredità possono sorgere ambiguità.
Esempio:
CPP // C++ program demonstrating ambiguity in Multipath // Inheritance #include using namespace std; class ClassA { public: int a; }; class ClassB : public ClassA { public: int b; }; class ClassC : public ClassA { public: int c; }; class ClassD : public ClassB, public ClassC { public: int d; }; int main() { ClassD obj; // obj.a = 10; // Statement 1, Error // obj.a = 100; // Statement 2, Error obj.ClassB::a = 10; // Statement 3 obj.ClassC::a = 100; // Statement 4 obj.b = 20; obj.c = 30; obj.d = 40; cout << ' a from ClassB : ' << obj.ClassB::a; cout << '
a from ClassC : ' << obj.ClassC::a; cout << '
b : ' << obj.b; cout << '
c : ' << obj.c; cout << '
d : ' << obj.d << '
'; }>
Produzione a from ClassB : 10 a from ClassC : 100 b : 20 c : 30 d : 40>
Nell'esempio sopra, sia ClassB che ClassC ereditano ClassA, entrambi hanno una singola copia di ClassA. Tuttavia la Classe D eredita sia la Classe B che la Classe C, pertanto la Classe D ha due copie della Classe A, una dalla Classe B e un'altra dalla Classe C.
Se dobbiamo accedere al membro dati di ClassA attraverso l'oggetto di Class-D, dobbiamo specificare il percorso da cui si accederà, sia che provenga da ClassB o ClassC, il compilatore bcoz non può distinguere tra due copie di ClassA in Classe D.
stringa in Java
Esistono 2 modi per evitare questa ambiguità:
1) Evitare ambiguità utilizzando l'operatore di risoluzione dell'ambito: Utilizzando l'operatore di risoluzione dell'ambito possiamo specificare manualmente il percorso da cui si accederà al membro dati a, come mostrato nelle istruzioni 3 e 4, nell'esempio precedente.
CPP obj.ClassB::a = 10; // Statement 3 obj.ClassC::a = 100; // Statement 4>
Nota: Tuttavia, ci sono due copie della Classe A nella Classe D.
2) Evitare l'ambiguità utilizzando la classe base virtuale:
CPP #include class ClassA { public: int a; }; class ClassB : virtual public ClassA { public: int b; }; class ClassC : virtual public ClassA { public: int c; }; class ClassD : public ClassB, public ClassC { public: int d; }; int main() { ClassD obj; obj.a = 10; // Statement 3 obj.a = 100; // Statement 4 obj.b = 20; obj.c = 30; obj.d = 40; cout << '
a : ' << obj.a; cout << '
b : ' << obj.b; cout << '
c : ' << obj.c; cout << '
d : ' << obj.d << '
'; }> Produzione:
a : 100 b : 20 c : 30 d : 40>
Secondo l'esempio sopra, Classe-D ha solo una copia di ClasseA, pertanto, l'istruzione 4 sovrascriverà il valore di a, fornito nell'istruzione 3.
