Verschil tussen overerving en compositie

Zijn samenstelling en overerving hetzelfde?
Als ik het compositiepatroon wil implementeren, hoe kan ik dat dan in Java doen?


Antwoord 1, autoriteit 100%

Ze zijn absoluut anders. Overerving is een “is-een”-relatie. Compositie is een “heeft-een”.

Je maakt compositie door een instantie van een andere klasse Cals veld van je klasse te hebben, in plaats van Cuit te breiden. Een goed voorbeeld waar compositie een stuk beter zou zijn geweest dan overerving, is java.util.Stack, dat momenteel java.util.Vectoruitbreidt. Dit wordt nu beschouwd als een blunder. Een stapel “is-NOT-a”vector; u mag niet willekeurig elementen invoegen en verwijderen. Het had in plaats daarvan compositie moeten zijn.

Helaas is het te laat om deze ontwerpfout recht te zetten, aangezien het wijzigen van de overervingshiërarchie nu de compatibiliteit met bestaande code zou verbreken. Als Stacksamenstelling had gebruikt in plaats van overerving, kan deze altijd worden gewijzigd om een andere gegevensstructuur te gebruiken zonder de API te schenden.

Ik raad het boek van Josh Bloch ten zeerste aan Effective Java 2nd Edition

  • Item 16: Geef de voorkeur aan compositie boven overerving
  • Item 17: Ontwerp en document voor erfenis of verbied het anders

Goed objectgeoriënteerd ontwerpen gaat niet over het royaal uitbreiden van bestaande klassen. Je eerste instinct zou moeten zijn om in plaats daarvan te componeren.


Zie ook:


Antwoord 2, autoriteit 65%

Samenstelling betekent HAS A
Overerving betekent IS A

Example: auto heeft eenmotor en auto is eenauto

In programmeren wordt dit weergegeven als:

class Engine {} // The Engine class.
class Automobile {} // Automobile class which is parent to Car class.
class Car extends Automobile { // Car is an Automobile, so Car class extends Automobile class.
  private Engine engine; // Car has an Engine so, Car class has an instance of Engine class as its member.
}

Antwoord 3, autoriteit 15%

Hoe kan overerving gevaarlijk zijn?

Laten we een voorbeeld nemen

public class X{    
   public void do(){    
   }    
}    
Public Class Y extends X{
   public void work(){    
       do();    
   }
}

1) Zoals duidelijk is in bovenstaande code, heeft klasse Y een zeer sterke koppeling met klasse X. Als er iets verandert in superklasse X, kan Y dramatisch breken. Stel dat klasse X in de toekomst een methode implementeert met onderstaande handtekening

public int work(){
}

Wijziging wordt gedaan in klasse X, maar zal klasse Y niet compileren. DUS dit soort afhankelijkheid kan tot elk niveau oplopen en het kan erg gevaarlijk zijn. Elke keer dat de superklasse niet volledig zicht heeft op de code binnen al zijn subklassen, kan de subklasse de hele tijd blijven opmerken wat er in de superklasse gebeurt. We moeten deze sterke en onnodige koppeling dus vermijden.

Hoe lost compositie dit probleem op?

Laten we eens kijken door hetzelfde voorbeeld te herzien

public class X{
    public void do(){
    }
}
Public Class Y{
    X x = new X();    
    public void work(){    
        x.do();
    }
}

Hier maken we een referentie van de X-klasse in de Y-klasse en roepen we de methode van de X-klasse op door een instantie van de X-klasse te maken.
Nu is al die sterke koppeling weg. Superklasse en subklasse zijn nu in hoge mate onafhankelijk van elkaar. Klassen kunnen vrijelijk wijzigingen aanbrengen die gevaarlijk waren in de overervingssituatie.

2) Tweede zeer goede voordeel van compositie omdat het flexibiliteit biedt bij het aanroepen van methoden, bijvoorbeeld:

class X implements R
{}
class Y implements R
{}
public class Test{    
    R r;    
}

In Test-klasse met r-referentie kan ik methoden van zowel de X-klasse als de Y-klasse aanroepen. Deze flexibiliteit was er nooit bij overerving

3) Nog een groot voordeel: testen van eenheden

public class X {
    public void do(){
    }
}
Public Class Y {
    X x = new X();    
    public void work(){    
        x.do();    
    }    
}

In het bovenstaande voorbeeld, als de staat van de x-instantie niet bekend is, kan deze eenvoudig worden nagebootst door enkele testgegevens te gebruiken en kunnen alle methoden eenvoudig worden getest. Dit was helemaal niet mogelijk bij overerving, omdat je sterk afhankelijk was van de superklasse om de staat van de instantie te krijgen en elke methode uit te voeren.

4) Een andere goede reden waarom we overerving moeten vermijden, is dat Java geen meervoudige overerving ondersteunt.

Laten we een voorbeeld nemen om dit te begrijpen:

Public class Transaction {
    Banking b;
    public static void main(String a[])    
    {    
        b = new Deposit();    
        if(b.deposit()){    
            b = new Credit();
            c.credit();    
        }
    }
}

Goed om te weten:

  1. Samenstelling wordt gemakkelijk bereikt bij runtime terwijl erfenis zijn functies op compileertijd

  2. biedt

  3. Samenstelling is ook bekend als heeft – een relatie en erfenis is ook bekend als is – een relatie

Dus maak het een gewoonte om altijd de voorkeur te geven aan samenstelling over erfenis voor verschillende bovenstaande redenen.


4, Autoriteit 5%

Overervingbrengt IS-Arelatie naar voren. Compositiebrengt HAS-A-relatienaar voren.
Strategiepatroon legt uit dat Composition moet worden gebruikt in gevallen waarin er families van algoritmen zijn die een bepaald gedrag definiëren.
Klassiek voorbeeld is van een eendenklasse die een vlieggedrag implementeert.

public interface Flyable{
 public void fly();
}
public class Duck {
 Flyable fly;
 public Duck(){
  fly = new BackwardFlying();
 }
}

We kunnen dus meerdere klassen hebben die vliegen implementeren
bv:

public class BackwardFlying implements Flyable{
  public void fly(){
    Systemout.println("Flies backward ");
  }
}
public class FastFlying implements Flyable{
  public void fly(){
    Systemout.println("Flies 100 miles/sec");
  }
}

Als het overerving was geweest, zouden we twee verschillende klassen vogels hebben die de vliegfunctie keer op keer implementeren. Dus overerving en samenstelling zijn totaal verschillend.


5

Als een ander voorbeeld, overweeg een autoklasse, dit zou een goed gebruik van compositie zijn, een auto zou “een motor hebben, een transmissie, banden, stoelen, enz. Het zou een van die klassen niet verlengen.


6

Samenstelling is waar iets bestaat uit verschillende delen en het heeft een sterke relatie met die delen. Als het grootste deel sterft, dan doen de anderen, ze kunnen geen eigen leven hebben. Een ruw voorbeeld is het menselijk lichaam. Haal het hart eruit en alle andere delen sterven weg.

Erfenis is waar u gewoon iets neemt dat al bestaat en gebruik het. Er is geen sterke relatie. Een persoon kan zijn vaders landgoed erven, maar hij kan het zonder het doen.

Ik ken Java niet, dus ik kan geen voorbeeld geven, maar ik kan een verklaring van de concepten geven.


7

in eenvoudige woordaggregatiemiddelen heeft een relatie ..

Samenstelling is een speciaal geval van aggregatie . Op een meer specifieke manier wordt een beperkte aggregatie samenstelling genoemd. Wanneer een object het andere object bevat, als het ingesloten object niet kan bestaan ​​zonder het bestaan ​​van containerobject, wordt het compositie genoemd.
Voorbeeld: een klasse bevat studenten. Een student kan niet bestaan ​​zonder een klasse. Er bestaat compositie tussen klasse en studenten.

Waarom aggregatie

gebruiken

Code herbruikbaarheid

bij gebruik van aggregatie

Code hergebruik is ook het best bereikt door aggregatie wanneer er geen is een relatieschip

erfenis

Erfenis is een overerving van de ouder kindrelatie is een relatie

Overerving in Java is een mechanisme waarbij één object alle eigenschappen en gedragingen van het bovenliggende object verwerft.

Overerving gebruiken in Java
1 Herbruikbaarheid van codes.
2 Voeg een extra functie toe in de onderliggende klasse en ook methodeoverschrijving (zodat runtime-polymorfisme kan worden bereikt).


Antwoord 8

Overervingtussen twee klassen, waarbij de ene klasse een andere klasse uitbreidt, brengt een “IS A“-relatie tot stand.

Compositieaan de andere kant bevat een instantie van een andere klasse in uw klasse die een “Has A“-relatie tot stand brengt. Compositiein java is handig omdat het technisch meervoudige overerving mogelijk maakt.


Antwoord 9

Hoewel zowel Inheritance als Composition code herbruikbaar maken, is het belangrijkste verschil tussen Composition en Inheritance in Java dat Composition hergebruik van code toestaat zonder deze uit te breiden, maar voor Inheritance moet je de klasse uitbreiden voor hergebruik van code of functionaliteit. Een ander verschil dat uit dit feit voortkomt, is dat je door Composition te gebruiken code kunt hergebruiken voor zelfs de laatste klasse die niet uitbreidbaar is, maar Inheritance kan in dergelijke gevallen geen code hergebruiken. Door Composition te gebruiken, kunt u ook code van veel klassen hergebruiken, omdat ze alleen als lidvariabele zijn gedeclareerd, maar met Inheritance kunt u code van slechts één klasse hergebruiken, omdat u in Java slechts één klasse kunt uitbreiden, omdat meerdere overerving niet wordt ondersteund in Java . U kunt dit echter in C++ doen, omdat één klasse meer dan één klasse kan uitbreiden. Trouwens, je moet altijd compositie verkiezen boven overerving in Java, niet alleen ik, maar zelfs Joshua Blochheeft in zijn boek gesuggereerd


Antwoord 10

Ik denk dat dit voorbeeld de verschillen tussen overervingen samenstellingduidelijk uitlegt.

In dit voorbeeld wordt het probleem opgelost met behulp van overerving en samenstelling. De auteur besteedt aandacht aan het feit dat; in overervingkan een verandering in superklasse problemen veroorzaken in afgeleide klassen, die deze overerven.

Daar kun je ook het verschil in weergave zien wanneer je een UML gebruikt voor overerving of samenstelling.

http://www.javaworld.com/article/2076814/core-java/inheritance-versus-composition–which-one-should-you-choose-.html


Antwoord 11

Erfenissen versus compositie.

Erfenissen en samenstelling worden beide gebruikt voor herbruikbaarheid en uitbreiding van klassengedrag.

Overervingen worden voornamelijk gebruikt in een programmeermodel voor familiealgoritmen, zoals het IS-A-relatietype betekent een soortgelijk soort object. Voorbeeld.

  1. Duster is een auto
  2. Safari is een auto

Deze behoren tot de Car-familie.

Compositie vertegenwoordigt HAS-A-relatie Type. Het toont het vermogen van een object zoals Duster heeft vijf versnellingen , Safari heeft vier versnellingen enz. Wanneer we het vermogen van een bestaande klasse moeten uitbreiden, gebruik dan compositie.Voorbeeld we moeten nog een versnelling toevoegen aan het Duster-object, dan moeten we nog een versnellingsobject maken en dit samenstellen tot het Duster-object.

We zouden de wijzigingen in de basisklasse pas moeten maken/tenzij alle afgeleide klassen die functionaliteit nodig hadden. Voor dit scenario moeten we Composition.Such als

gebruiken

klasse A afgeleid van klasse B

Klasse A afgeleid van klasse C

Klasse A afgeleid van klasse D.

Wanneer we een functionaliteit in klasse A toe voegen, is het beschikbaar voor alle subklassen, zelfs wanneer Klasse C en D die functionaliteit niet nodig hebben. Voor dit scenario moeten we een afzonderlijke klasse maken voor die functionaliteit en het opstellen van de Vereiste klas (hier is klasse B).

Hieronder is het voorbeeld:

         // This is a base class
                 public abstract class Car
                    {
                       //Define prototype
                       public abstract void color();
                       public void Gear() {
                           Console.WriteLine("Car has a four Gear");
                       }
                    }
           // Here is the use of inheritence
           // This Desire class have four gears.
          //  But we need to add one more gear that is Neutral gear.
          public class Desire : Car
                   {
                       Neutral obj = null;
                       public Desire()
                       {
     // Here we are incorporating neutral gear(It is the use of composition). 
     // Now this class would have five gear. 
                           obj = new Neutral();
                           obj.NeutralGear();
                       }
                       public override void color()
                       {
                           Console.WriteLine("This is a white color car");
                       }
                   }
             // This Safari class have four gears and it is not required the neutral
             //  gear and hence we don't need to compose here.
                   public class Safari :Car{
                       public Safari()
                       { }
                       public override void color()
                       {
                           Console.WriteLine("This is a red color car");
                       }
                   }
   // This class represents the neutral gear and it would be used as a composition.
   public class Neutral {
                      public void NeutralGear() {
                           Console.WriteLine("This is a Neutral Gear");
                       }
                   }

12

Samenstelling betekent een object maken met een klasse met een relatie met die specifieke klasse.
Stel dat de student een relatie heeft met rekeningen;

Een erfenis is, dit is de vorige klasse met de uitgebreide functie. Dat betekent dat deze nieuwe klas de oude klasse is met een uitgebreide functie.
Stel dat de student student is, maar alle studenten zijn menselijk. Er is dus een relatie met student en mens. Dit is erfenis.


13

Nee, beide zijn anders. Samenstelling volgt “Has-a” -relatie en erfenis volgen “is-A” -relatie. Het beste voorbeeld voor compositie was strategisch patroon.


14

Inherence betekent het hergebruiken van de volledige functionaliteit van een klasse, hier moet mijn klas al de methoden van de Super-klasse gebruiken en mijn klasse zal met de superklasse en de code in het geval van inhervence worden gedupliceerd .

Maar we kunnen overwinnen van al dit probleem wanneer we samenstelling gebruiken om met een andere klas te praten. Samenstelling verklaart een attribuut van een andere klas in mijn klas waaraan we willen praten. En welke functionaliteit die we van die klasse willen, kunnen we krijgen door dat kenmerk te gebruiken.

Other episodes