Kalıtım ve Kompozisyon Arasındaki Fark

Kompozisyon ve Kalıtım aynı mıdır? Kompozisyon desenini uygulamak istersem bunu Java'da nasıl yapabilirim?

Kesinlikle farklılar. Kalıtım bir "is-a" ilişkisidir. Kompozisyon bir "has-a" dır .

Kompozisyonu Cgenişletmek yerine sınıfınızın alanı olarak başka bir sınıf örneğine sahip olarak yaparsınız C. Kompozisyonun kalıtımdan çok daha iyi olacağı iyi bir örnek java.util.Stack, şu anda uzanıyor java.util.Vector. Bu şimdi bir gaf olarak kabul edilir. Bir yığın "is-NOT-a" vektörü; öğeleri keyfi olarak takıp çıkarmanıza izin verilmemelidir. Bunun yerine kompozisyon olmalıydı.

Maalesef bu tasarım hatasını düzeltmek için çok geç, çünkü miras hiyerarşisini değiştirmek artık mevcut kodla uyumluluğu bozacak. Vardı Stackyerine kalıtım kullanılan bileşim, her zaman API zarar vermeden başka bir veri yapısını kullanmak için modifiye edilebilir .

Josh Bloch'un Effective Java 2nd Edition kitabını şiddetle tavsiye ederim

• Madde 16: Kompozisyonun miras yerine tercih edilmesi
• Madde 17: Miras için tasarım ve belge ya da başka bir şekilde yasaklamak

İyi nesne yönelimli tasarım, mevcut sınıfları liberal olarak genişletmekle ilgili değildir. İlk içgüdünüz bunun yerine beste yapmak olmalıdır.

Ayrıca bakınız:

• Kompozisyon ve Kalıtım: Sınıfları İlişkilendirmenin İki Temel Yoluna Karşılaştırmalı Bir Bakış

Kompozisyon araçları HAS A
Kalıtım araçlarıIS A

Example: Otomobil bir sahiptir Engine ve Araç bir olduğunu Otomobil

Programlamada bu şu şekilde temsil edilir:

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.
}

Kalıtım nasıl tehlikeli olabilir?

Bir örnek verelim

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

1) Yukarıdaki kodda açıkça görüldüğü gibi, Sınıf Y, sınıf X ile çok güçlü bir bağlantıya sahiptir. X sınıfında herhangi bir değişiklik olursa, Y önemli ölçüde kırılabilir. Diyelim ki gelecekteki X sınıfında aşağıdaki imzayla bir yöntem çalışması uygulanmaktadır

public int work(){
}

Değişim X sınıfında yapılır, ancak Y sınıfını uyumsuz hale getirir. Yani bu tür bir bağımlılık herhangi bir seviyeye kadar çıkabilir ve çok tehlikeli olabilir. Üst sınıfın tüm alt sınıfları içinde kodlama için tam görünürlüğü olmayabilir ve alt sınıf her zaman üst sınıfta neler olduğunu fark etmeye devam edebilir. Bu yüzden bu güçlü ve gereksiz bağlantıdan kaçınmamız gerekiyor.

Kompozisyon bu sorunu nasıl çözüyor?

Aynı örneği revize ederek görelim

public class X{
    public void do(){
    }
}

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

Burada Y sınıfında X sınıfının referansını oluşturuyoruz ve X sınıfının bir örneğini oluşturarak X sınıfının yöntemini çağırıyoruz. Şimdi tüm bu güçlü bağlantı gitti. Üst sınıf ve alt sınıf şimdi birbirinden oldukça bağımsızdır. Sınıflar, kalıtım durumunda tehlikeli olabilecek değişiklikleri özgürce yapabilir.

2) Kompozisyon çağırma esnekliği sağladığı için kompozisyonun ikinci çok iyi avantajı, örneğin:

class X implements R
{}
class Y implements R
{}

public class Test{    
    R r;    
}

Test referansında r referansını kullanarak X sınıfının yanı sıra Y sınıfı yöntemlerini de çağırabilirim. Bu esneklik kalıtımda hiç yoktu

3) Bir başka büyük avantaj: Birim testi

public class X {
    public void do(){
    }
}

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

Yukarıdaki örnekte, x örneğinin durumu bilinmiyorsa, bazı test verileri kullanılarak kolayca taklit edilebilir ve tüm yöntemler kolayca test edilebilir. Bu, örnek durumunu almak ve herhangi bir yöntemi uygulamak için süper sınıfa bağımlı olduğunuz için mirasta hiç mümkün değildi.

4) Mirastan kaçınmamızın bir başka iyi nedeni de Java'nın birden fazla mirası desteklememesidir.

Bunu anlamak için bir örnek verelim:

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

Bunu bildiğim iyi oldu :

1. kompozisyon, çalışma zamanında kolayca elde edilirken, kalıtım özelliklerini derleme zamanında sağlar

2. bileşim HAS-A ilişkisi olarak bilinir ve kalıtım IS-A ilişkisi olarak da bilinir

Bu yüzden yukarıdaki çeşitli nedenlerle kompozisyonu kalıtım yerine her zaman tercih etmeyi alışkanlık haline getirin.

@Michael Rodrigues tarafından verilen cevap doğru değil (özür dilerim; doğrudan yorum yapamıyorum) ve bazı karışıklıklara yol açabilir.

Arayüz uygulaması bir kalıtım biçimidir ... bir arayüz uyguladığınızda, sadece tüm sabitleri devralmakla kalmaz, nesnenizi arayüz tarafından belirtilen türde olmasını taahhüt edersiniz; bu hala bir " is-a " ilişkisidir. Bir araba Doldurulabilir kullanıyorsa , araç " a- Doldurulabilir " dir ve bir Doldurulabilir'i kullanacağınız her yerde kodunuzda kullanılabilir .

Kompozisyon temel olarak kalıtımdan farklıdır. Kompozisyon kullandığınızda, (diğer cevaplar notunda olduğu gibi) miras kullandığınızda yaptığınız " is-a " ilişkisinin aksine iki nesne arasında " has-a " ilişkisi kuruyorsunuz .

Yani, diğer sorulardaki araba örneklerinden, bir arabanın " bir " gaz tankı olduğunu söylemek istersem, kompozisyonu aşağıdaki gibi kullanırdım:

public class Car {

private GasTank myCarsGasTank;

}

Umarım bu yanlış anlaşılmaları giderir.

Kalıtım IS-A ilişkisini ortaya çıkarır . Kompozisyon HAS-A ilişkisini ortaya çıkarır . Strateji örüntüsü, Kompozisyonun belirli bir davranışı tanımlayan algoritma ailelerinin olduğu durumlarda kullanılması gerektiğini açıklar.
Klasik bir örnek, bir uçuş davranışı uygulayan bir ördek sınıfının olması.

public interface Flyable{
 public void fly();
}

public class Duck {
 Flyable fly;

 public Duck(){
  fly = new BackwardFlying();
 }
}

Böylece uçmayı uygulayan birden fazla sınıfımız olabilir:

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");
  }
}

Kalıtım için olsaydı, sinek işlevini tekrar tekrar uygulayan iki farklı kuş sınıfımız olurdu. Yani kalıtım ve kompozisyon tamamen farklıdır.

Kompozisyon göründüğü gibidir - parçaları ekleyerek bir nesne yaratırsınız.

Bu cevabın geri kalanını DÜZENLE yanlışlıkla aşağıdaki öncüle dayanmaktadır.
Bu, Arayüzler ile gerçekleştirilir.
Örneğin, Caryukarıdaki örneği kullanarak ,

Car implements iDrivable, iUsesFuel, iProtectsOccupants
Motorbike implements iDrivable, iUsesFuel, iShortcutThroughTraffic
House implements iProtectsOccupants
Generator implements iUsesFuel

Böylece birkaç standart teorik bileşenle nesnenizi oluşturabilirsiniz. O zaman bir işin Housesakinlerini nasıl koruduğunu ve bir işgalciyi nasıl koruduğunu doldurmak sizin işiniz Car.

Kalıtım bunun tersi gibi. Tam (veya yarı-tamamlanmış) bir nesne ile başlarsınız ve değiştirmek istediğiniz çeşitli bitleri değiştirir veya geçersiz kılarsınız.

Örneğin, MotorVehiclebir Fuelableyöntem ve Driveyöntemle gelebilir . Yakıt yöntemini olduğu gibi bırakabilirsiniz çünkü bir motosikleti ve bir arabayı doldurmak aynıdır, ancak DriveMotosiklet'i çok farklı bir şekilde sürdüğü için yöntemi geçersiz kılabilirsiniz Car.

Kalıtımla, bazı sınıflar zaten tamamen uygulanır ve bazılarında geçersiz kılmaya zorlandığınız yöntemler vardır. Kompozisyon ile size hiçbir şey verilmiyor. (ancak etrafınızdaki bir şey varsa, diğer sınıflardaki yöntemleri çağırarak arayüzleri uygulayabilirsiniz).

Kompozisyon daha esnek olarak görülür, çünkü iUsesFuel gibi bir yönteminiz varsa, başka bir yerde (başka bir sınıf, başka bir proje), bir araba olup olmadığına bakılmaksızın, yakıt alabilen nesnelerle uğraşmaktan endişe duyan bir yönteminiz olabilir, arayüzler, soba, barbekü vb. Örneğin,

iFuelable Interface:
   void AddSomeFuel()
   void UseSomeFuel()
   int  percentageFull()

başka bir yerde bir yöntem olabilir

private void FillHerUp(iFuelable : objectToFill) {

   Do while (objectToFill.percentageFull() <= 100)  {

        objectToFill.AddSomeFuel();
   }

Garip bir örnek, ancak bu yöntemin ne doldurduğunu umursamadığını gösterir, çünkü nesne uygular iUsesFuel, doldurulabilir. Hikayenin sonu.

Bunun yerine Inheritance kullandıysanız, farklı gerekir FillHerUpbaşa yöntemleri MotorVehiclesve Barbecueshangi devralmak bazı oldukça garip "ObjectThatUsesFuel" taban nesne vardı sürece,.

Kompozisyon ve Kalıtım aynı mıdır?

Aynı değiller.

Kompozisyon : Bir grup nesneye, bir nesnenin tek bir örneği gibi davranılmasını sağlar. Bir kompozitin amacı, kısmen bütün hiyerarşileri temsil etmek için nesneleri ağaç yapılarına "oluşturmak" tır.

Kalıtım : Sınıf, alanları veya yöntemleri doğrudan veya dolaylı olarak tüm üst sınıflarından devralır. Alt sınıf, devraldığı yöntemleri geçersiz kılabilir veya devraldığı alanları veya yöntemleri gizleyebilir.

Kompozisyon desenini uygulamak istersem bunu Java'da nasıl yapabilirim?

Wikipedia makalesi, java'da kompozit desen uygulamak için yeterince iyi.

Kilit Katılımcılar:

Bileşen :

1. Kompozit olanlar da dahil olmak üzere tüm bileşenler için soyutlama
2. Kompozisyondaki nesneler için arabirimi bildirir

Yaprak :

1. Kompozisyondaki yaprak nesnelerini temsil eder
2. Tüm Bileşen yöntemlerini uygular

Kompozit :

1. Kompozit Bileşeni (çocuklu bileşen) temsil eder
2. Çocukları manipüle etmek için yöntemler uygular
3. Tüm Bileşen yöntemlerini, genellikle çocuklarına devrederek uygular

Kompozit modeli anlamak için kod örneği :

import java.util.List;
import java.util.ArrayList;

interface Part{
    public double getPrice();
    public String getName();
}
class Engine implements Part{
    String name;
    double price;
    public Engine(String name,double price){
        this.name = name;
        this.price = price;
    }
    public double getPrice(){
        return price;
    }
    public String getName(){
        return name;
    }
}
class Trunk implements Part{
    String name;
    double price;
    public Trunk(String name,double price){
        this.name = name;
        this.price = price;
    }
    public double getPrice(){
        return price;
    }
    public String getName(){
        return name;
    }
}
class Body implements Part{
    String name;
    double price;
    public Body(String name,double price){
        this.name = name;
        this.price = price;
    }
    public double getPrice(){
        return price;
    }
    public String getName(){
        return name;
    }
}
class Car implements Part{
    List<Part> parts;
    String name;

    public Car(String name){
        this.name = name;
        parts = new ArrayList<Part>();
    }
    public void addPart(Part part){
        parts.add(part);
    }
    public String getName(){
        return name;
    }
    public String getPartNames(){
        StringBuilder sb = new StringBuilder();
        for ( Part part: parts){
            sb.append(part.getName()).append(" ");
        }
        return sb.toString();
    }
    public double getPrice(){
        double price = 0;
        for ( Part part: parts){
            price += part.getPrice();
        }
        return price;
    }   
}

public class CompositeDemo{
    public static void main(String args[]){
        Part engine = new Engine("DiselEngine",15000);
        Part trunk = new Trunk("Trunk",10000);
        Part body = new Body("Body",12000);

        Car car = new Car("Innova");
        car.addPart(engine);
        car.addPart(trunk);
        car.addPart(body);

        double price = car.getPrice();

        System.out.println("Car name:"+car.getName());
        System.out.println("Car parts:"+car.getPartNames());
        System.out.println("Car price:"+car.getPrice());
    }

}

çıktı:

Car name:Innova
Car parts:DiselEngine Trunk Body
Car price:37000.0

Açıklama:

1. Bölüm bir yapraktır
2. Araba birçok parça içerir
3. Arabanın farklı parçaları araca eklendi
4. Araba fiyatı = toplamı (Her Parçanın Fiyatı )

Kompozisyon ve Kalıtımın Artıları ve Eksileri için aşağıdaki soruya bakın.

Kompozisyon kalıtım yerine tercih edilmeli mi?

başka bir örnek olarak, bir araba sınıfını düşünün, bu kompozisyonun iyi bir kullanımı olacaktır, bir araba bir motora, bir şanzımana, lastiklere, koltuklara vb. sahip olacaktır.

Kompozisyon, bir şeyin farklı bölümlerden oluştuğu ve bu bölümlerle güçlü bir ilişkiye sahip olduğu yerdir. Eğer ana kısım ölürse, diğerleri de ölürse, kendi yaşamları olamaz. Buna kaba bir örnek insan vücududur. Kalbi çıkarın ve diğer tüm parçalar ölür.

Kalıtım, zaten var olan bir şeyi aldığınız ve kullandığınız yerdir. Güçlü bir ilişki yok. Bir kişi babalarının mülkünü devralabilir ama onsuz yapabilir.

Java bilmiyorum, bu yüzden bir örnek veremiyorum ama kavramların bir açıklamasını verebilirim.

Bir sınıfın başka bir sınıfı genişlettiği iki sınıf arasındaki kalıtım " IS A " ilişkisini kurar .

Diğer uçtaki kompozisyon , sınıfınızdaki başka bir sınıfın bir örneğini içeriyorsa " Has A " ilişkisi kurar . Java'da kompozisyon , teknik olarak çoklu kalıtımı kolaylaştırdığından faydalıdır.

Basit Sözcükte Toplama İlişkisi Olan demektir ..

Kompozisyon özel bir toplama örneğidir . Daha spesifik bir şekilde, kısıtlı bir kümelemeye bileşim denir. Bir nesne diğer nesneyi içerdiğinde, içerilen nesne konteyner nesnesinin varlığı olmadan var olamazsa, o zaman kompozisyon olarak adlandırılır. Örnek: Bir sınıf öğrencileri içerir. Öğrenci sınıfsız var olamaz. Sınıf ve öğrenciler arasında kompozisyon vardır.

Toplama Neden Kullanılmalı?

Kod Yeniden Kullanılabilirliği

Toplama Kullanıldığında

Kodun yeniden kullanılması ayrıca bir İlişkilendirme gemisi olmadığında toplama ile elde edilir.

miras

Miras, Ebeveyn Çocuk İlişkisidir Miras, İlişki Demektir

Java'daki kalıtım, bir nesnenin üst nesnenin tüm özelliklerini ve davranışlarını edindiği bir mekanizmadır.

Java 1 Code Reusability'de kalıtım kullanma. 2 Child Class'a Ekstra Özellik ve Yöntem Geçersiz Kılma ekleyin (böylece çalışma zamanı polimorfizmi elde edilebilir).

Hem Kalıtım hem de Kompozisyon kodun yeniden kullanılabilirliğini sağlasa da, Java'daki Kompozisyon ve Kalıtım arasındaki temel fark, Kompozisyon'un kodu genişletmeden yeniden kullanmasına izin vermesidir, ancak Kalıtım için, kodu veya işlevselliğin yeniden kullanımı için sınıfı genişletmeniz gerekir. Bu olgudan çıkan bir diğer fark, Kompozisyon'u kullanarak, genişletilemeyen son sınıf için bile kodu yeniden kullanabileceğiniz, ancak Kalıtım bu gibi durumlarda kodu yeniden kullanamayacağıdır. Ayrıca Kompozisyon'u kullanarak, sadece üye değişken olarak bildirildikleri için birçok sınıftan kodu yeniden kullanabilirsiniz, ancak Devralma ile kod yalnızca bir sınıftan yeniden kullanabilirsiniz, çünkü Java'da yalnızca bir sınıfı genişletebilirsiniz, çünkü Java'da birden fazla Devralma desteklenmez . C ++ ile bunu yapabilirsiniz çünkü bir sınıf birden fazla sınıfı genişletebilir. BTW, her zamanJava'da Miras Kompozisyonunu tercih ediyorum , sadece ben değil, Joshua Bloch bile kitabında önerdi

Bence bu örnek kalıtım ve kompozisyon arasındaki farkları açık bir şekilde açıklıyor .

Bu örnekte, problem miras ve kompozisyon kullanılarak çözülür. Yazar; içinde miras , üst sınıfta değiştirecektirler miras olduğunu, türetilmiş sınıftaki sorunlara neden olabilir.

Orada da miras veya kompozisyon için bir UML kullandığınızda temsil farkı görebilirsiniz.

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

Kalıtım Vs Kompozisyon.

Kalıtımlar ve kompozisyon, sınıf davranışının yeniden kullanılabilirliği ve genişletilmesi için kullanılır.

IS-A ilişki türü gibi bir aile algoritması programlama modelinde temel olarak kullanılan kalıtımlar, benzer türde bir nesne anlamına gelir. Misal.

1. Duster bir Araba
2. Safari bir Araba

Bunlar Car ailesine aittir.

Kompozisyon HAS-A ilişki tipini temsil eder. Duster gibi beş nesnenin, Safari'nin dört Dişlisi vb. Gibi bir nesnenin yeteneğini gösterir. Örnek , Duster nesnesine bir dişli daha eklememiz gerekiyor, o zaman bir dişli nesnesi daha oluşturmalı ve duster nesnesine yazmalıyız.

Tüm türetilmiş sınıflar bu işlevselliğe ihtiyaç duymadıkça / sürece temel sınıfta değişiklikler yapmamalıyız.Bu senaryo için Composition.Such kullanmalıyız.

A sınıfı B Sınıfı ile türetilmiş

C Sınıfı ile Türetilmiş A Sınıfı

Sınıf A, Sınıf D tarafından türetilmiştir.

A sınıfına herhangi bir işlevsellik eklediğimizde, C ve D Sınıfları bu işlevselliği gerektirmediğinde bile tüm alt sınıflar için kullanılabilir. Bu senaryo için, bu işlevsellik için ayrı bir sınıf oluşturmanız ve gerekli sınıfa ( İşte B sınıfı).

Aşağıda örnek:

          // 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");
                       }
                   }

Kompozisyon, söz konusu sınıfla ilişkisi olan bir sınıfa nesne oluşturmak anlamına gelir. Öğrenci'nin Hesaplarla ilişkisi olduğunu varsayalım;

Kalıtım, genişletilmiş özelliğe sahip önceki sınıftır. Bu, bu yeni sınıfın bazı genişletilmiş özelliklere sahip Eski sınıf olduğu anlamına gelir. Diyelim ki Öğrenci Öğrenci, Tüm Öğrenciler İnsan. Yani öğrenci ve insanla bir ilişki var. Bu Kalıtım.

Hayır, ikisi de farklı. Kompozisyon "HAS-A" ilişkisini, kalıtım ise "IS-A" ilişkisini takip eder. Kompozisyon için en iyi örnek Stratejik modeldi.

Miras bir sınıfın tüm işlevlerini yeniden kullanmak anlamına gelir, Burada benim sınıf süper sınıfın tüm yöntemlerini kullanmak zorunda ve benim sınıf süper sınıf ile eşleşecek ve miras durumunda her iki sınıfta kod çoğaltılacaktır.

Ancak kompozisyonu başka bir sınıfla konuşmak için kullandığımızda tüm bu problemin üstesinden gelebiliriz. kompozisyon, sınıfımıza konuşmak istediğimiz başka bir sınıfın niteliğini ilan ediyor. ve söz konusu niteliği kullanarak bu sınıftan hangi işlevselliği elde edebileceğimizi.