Perbedaan antara Warisan dan Komposisi

Apakah Komposisi dan Warisan sama? Jika saya ingin menerapkan pola komposisi, bagaimana saya bisa melakukannya di Jawa?

Mereka benar-benar berbeda. Warisan adalah "is-a" . Komposisi adalah "memiliki-a" .

Anda melakukan komposisi dengan memiliki instance kelas lain Csebagai bidang kelas Anda, alih-alih memperluas C. Contoh yang bagus di mana komposisi akan jauh lebih baik daripada warisan java.util.Stack, yang saat ini meluasjava.util.Vector . Ini sekarang dianggap sebagai kesalahan besar. Setumpuk vektor "is-NOT-a" ; Anda seharusnya tidak diizinkan untuk menyisipkan dan menghapus elemen secara sewenang-wenang. Seharusnya komposisi bukan.

Sayangnya sudah terlambat untuk memperbaiki kesalahan desain ini, karena mengubah hierarki warisan sekarang akan merusak kompatibilitas dengan kode yang ada. PernahStack menggunakan komposisi alih-alih pewarisan, selalu dapat dimodifikasi untuk menggunakan struktur data lain tanpa melanggar API .

Saya sangat merekomendasikan buku Josh Bloch Effective Java 2nd Edition

• Butir 16: Komposisi nikmat daripada warisan
• Butir 17: Desain dan dokumen untuk warisan atau melarangnya

Desain berorientasi objek yang baik bukan tentang memperluas kelas yang ada secara bebas. Naluri pertamamu adalah menulis.

Lihat juga:

• Komposisi versus Warisan: Pandangan Komparatif pada Dua Cara Mendasar untuk Mengaitkan Kelas

Komposisi berarti HAS A
Warisan berartiIS A

Example: Mobil memiliki Mesin dan Mobil adalah Otomotif

Dalam pemrograman ini direpresentasikan sebagai:

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

Bagaimana warisan bisa berbahaya?

Mari kita ambil contoh

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

1) Seperti yang jelas dalam kode di atas, Kelas Y memiliki kopling yang sangat kuat dengan kelas X. Jika ada perubahan dalam superclass X, Y dapat pecah secara dramatis. Misalkan Di kelas X mengimplementasikan metode kerja dengan tanda tangan di bawah ini

public int work(){
}

Perubahan dilakukan di kelas X tetapi itu akan membuat kelas Y tidak dapat dikompilasi. JADI ketergantungan seperti ini bisa naik ke tingkat apa pun dan itu bisa sangat berbahaya. Setiap kali superclass mungkin tidak memiliki visibilitas penuh ke kode di dalam semua subkelasnya dan subkelas mungkin terus memperhatikan apa yang terjadi di superclass sepanjang waktu. Jadi kita harus menghindari sambungan yang kuat dan tidak perlu ini.

Bagaimana komposisi memecahkan masalah ini?

Mari kita lihat dengan merevisi contoh yang sama

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

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

Di sini kita membuat referensi kelas X di kelas Y dan menerapkan metode kelas X dengan membuat turunan dari kelas X. Sekarang semua kopling kuat itu hilang. Superclass dan subclass sangat independen satu sama lain sekarang. Kelas dapat dengan bebas membuat perubahan yang berbahaya dalam situasi warisan.

2) Keunggulan komposisi kedua yang sangat baik karena memberikan fleksibilitas pemanggilan metode, misalnya:

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

public class Test{    
    R r;    
}

Di kelas Uji menggunakan r referensi saya bisa memanggil metode kelas X serta kelas Y. Fleksibilitas ini tidak pernah ada dalam warisan

3) Keuntungan besar lainnya: Unit testing

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

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

Dalam contoh di atas, jika keadaan x instance tidak diketahui, ia dapat dengan mudah diejek dengan menggunakan beberapa data uji dan semua metode dapat dengan mudah diuji. Ini tidak mungkin sama sekali dalam warisan karena Anda sangat bergantung pada superclass untuk mendapatkan status instance dan menjalankan metode apa pun.

4) Alasan bagus lainnya mengapa kita harus menghindari pewarisan adalah bahwa Java tidak mendukung pewarisan berganda.

Mari kita ambil contoh untuk memahami ini:

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

Senang mendengarnya :

1. komposisi mudah dicapai saat runtime sementara warisan menyediakan fitur-fiturnya pada waktu kompilasi

2. komposisi juga dikenal sebagai hubungan HAS-A dan pewarisan juga dikenal sebagai hubungan IS-A

Jadi biasakan selalu lebih suka komposisi daripada warisan karena berbagai alasan di atas.

Jawaban yang diberikan oleh @Michael Rodrigues tidak benar (saya minta maaf; Saya tidak dapat berkomentar secara langsung), dan dapat menyebabkan beberapa kebingungan.

Implementasi antarmuka adalah bentuk warisan ... ketika Anda mengimplementasikan antarmuka, Anda tidak hanya mewarisi semua konstanta, Anda juga membuat objek Anda menjadi tipe yang ditentukan oleh antarmuka; ini masih merupakan hubungan " is-a ". Jika sebuah mobil mengimplementasikan Fillable , mobil " is-a " Fillable , dan dapat digunakan dalam kode Anda di mana pun Anda akan menggunakan Fillable .

Komposisi pada dasarnya berbeda dari warisan. Saat Anda menggunakan komposisi, Anda (seperti jawaban jawaban lainnya) membuat hubungan " memiliki-a " antara dua objek, yang bertentangan dengan hubungan " is-a " yang Anda buat saat menggunakan warisan .

Jadi, dari contoh mobil di pertanyaan lain, jika saya ingin mengatakan bahwa mobil " memiliki " tangki bensin, saya akan menggunakan komposisi, sebagai berikut:

public class Car {

private GasTank myCarsGasTank;

}

Semoga itu menghilangkan kesalahpahaman.

Warisan memunculkan relasi IS-A . Komposisi memunculkan hubungan HAS-A . Pola strategi menjelaskan bahwa Komposisi harus digunakan dalam kasus di mana ada keluarga algoritma yang mendefinisikan perilaku tertentu.
Contoh klasik adalah kelas bebek yang menerapkan perilaku terbang.

public interface Flyable{
 public void fly();
}

public class Duck {
 Flyable fly;

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

Dengan demikian kita dapat memiliki beberapa kelas yang menerapkan terbang misalnya:

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

Seandainya itu untuk warisan, kita akan memiliki dua kelas burung yang berbeda yang menerapkan fungsi terbang berulang-ulang. Jadi warisan dan komposisi sama sekali berbeda.

Komposisi seperti kedengarannya - Anda membuat objek dengan mencolokkan bagian-bagian.

Sunting Sisa dari jawaban ini secara keliru berdasarkan pada premis berikut.
Ini dilakukan dengan Antarmuka.
Misalnya, menggunakan Carcontoh di atas,

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

Jadi dengan beberapa komponen teoritis standar Anda dapat membangun objek Anda. Maka tugas Anda untuk mengisi bagaimana seorang Housemelindungi penghuninya, dan bagaimana seorang Carmelindungi penghuninya.

Warisan seperti sebaliknya. Anda mulai dengan objek yang lengkap (atau semi-lengkap) dan Anda mengganti atau mengganti berbagai bit yang ingin Anda ubah.

Misalnya, MotorVehiclemungkin datang dengan Fuelablemetode dan Drivemetode. Anda dapat meninggalkan metode Bahan Bakar seperti itu karena itu sama untuk mengisi sepeda motor dan mobil, tetapi Anda dapat mengganti Drivemetode karena Motorbike drive sangat berbeda keCar .

Dengan pewarisan, beberapa kelas sudah sepenuhnya diimplementasikan, dan yang lain memiliki metode yang terpaksa Anda timpa. Dengan Komposisi tidak ada yang diberikan kepada Anda. (tetapi Anda dapat mengimplementasikan antarmuka dengan memanggil metode di kelas lain jika Anda memiliki sesuatu yang bertebaran).

Komposisi dipandang lebih fleksibel, karena jika Anda memiliki metode seperti iUsesFuel, Anda dapat memiliki metode di tempat lain (kelas lain, proyek lain) yang hanya khawatir tentang berurusan dengan objek yang dapat diisi bahan bakar, terlepas dari apakah itu mobil, kapal, kompor, barbecue, dll. Antarmuka mengamanatkan bahwa kelas yang mengatakan mereka mengimplementasikan antarmuka itu sebenarnya memiliki metode yang terkait dengan antarmuka itu. Sebagai contoh,

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

maka Anda dapat memiliki metode di tempat lain

private void FillHerUp(iFuelable : objectToFill) {

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

        objectToFill.AddSomeFuel();
   }

Contoh aneh, tetapi itu menunjukkan bahwa metode ini tidak peduli apa yang mengisi, karena objek mengimplementasikan iUsesFuel, itu dapat diisi. Akhir dari cerita.

Jika Anda menggunakan Inheritance sebagai gantinya, Anda akan memerlukan FillHerUpmetode yang berbeda untuk menangani MotorVehiclesdan Barbecues, kecuali jika Anda memiliki beberapa objek dasar "ObjectThatUsesFuel" yang agak aneh untuk mewarisi.

Apakah Komposisi dan Warisan sama?

Mereka tidak sama.

Komposisi : Ini memungkinkan sekelompok objek harus diperlakukan dengan cara yang sama dengan satu instance objek. Maksud dari suatu komposit adalah untuk "menyusun" objek ke dalam struktur pohon untuk mewakili hierarki bagian-keseluruhan

Warisan : Kelas mewarisi bidang dan metode dari semua kacamata supernya, baik langsung maupun tidak langsung. Subclass dapat menimpa metode yang diwarisi, atau dapat menyembunyikan bidang atau metode yang diwarisi.

Jika saya ingin menerapkan pola komposisi, bagaimana saya bisa melakukannya di Jawa?

Artikel Wikipedia cukup bagus untuk menerapkan pola komposit di java.

Peserta Utama:

Komponen :

1. Apakah abstraksi untuk semua komponen, termasuk yang komposit
2. Deklarasikan antarmuka untuk objek dalam komposisi

Daun :

1. Merupakan objek daun dalam komposisi
2. Menerapkan semua metode Komponen

Komposit :

1. Merupakan Komponen komposit (komponen memiliki anak)
2. Menerapkan metode untuk memanipulasi anak-anak
3. Menerapkan semua metode Komponen, umumnya dengan mendelegasikannya kepada anak-anaknya

Contoh kode untuk memahami pola Komposit :

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

}

keluaran:

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

Penjelasan:

1. Bagian adalah daun
2. Mobil mengandung banyak Bagian
3. Berbagai bagian mobil telah ditambahkan ke Mobil
4. Harga Mobil = jumlah (Harga setiap Bagian )

Lihat pertanyaan di bawah ini untuk Pro dan Kontra Komposisi dan Warisan.

Lebih suka komposisi daripada warisan?

sebagai contoh lain, pertimbangkan kelas mobil, ini akan menjadi penggunaan komposisi yang baik, mobil akan "memiliki" mesin, transmisi, ban, kursi, dll. Itu tidak akan memperpanjang kelas-kelas itu.

Komposisi adalah di mana sesuatu terdiri dari bagian-bagian yang berbeda dan memiliki hubungan yang kuat dengan bagian-bagian itu. Jika bagian utama mati begitu juga yang lain, mereka tidak dapat memiliki kehidupan mereka sendiri. Contoh kasar adalah tubuh manusia. Keluarkan hati dan semua bagian lainnya mati.

Warisan adalah tempat Anda mengambil sesuatu yang sudah ada dan menggunakannya. Tidak ada hubungan yang kuat. Seseorang dapat mewarisi tanah leluhurnya tetapi dia dapat melakukannya tanpa itu.

Saya tidak tahu Java jadi saya tidak bisa memberikan contoh tetapi saya bisa memberikan penjelasan konsep.

Warisan antara dua kelas, di mana satu kelas memperluas kelas lain membangun hubungan " IS A ".

Komposisi di ujung yang lain berisi instance kelas lain di kelas Anda menetapkan hubungan " Memiliki A ". Komposisi dalam java berguna karena secara teknis memfasilitasi multiple inheritance.

Secara Sederhana Agregasi Kata Berarti Memiliki Hubungan ..

Komposisi adalah kasus agregasi khusus . Dengan cara yang lebih spesifik, agregasi terbatas disebut komposisi. Ketika suatu objek berisi objek lain, jika objek yang terkandung tidak dapat eksis tanpa adanya objek kontainer, maka itu disebut komposisi. Contoh: Kelas berisi siswa. Seorang siswa tidak dapat ada tanpa kelas. Ada komposisi antara kelas dan siswa.

Mengapa Menggunakan Agregasi

Kode Reusability

Saat Menggunakan Agregasi

Penggunaan kembali kode juga paling baik dicapai dengan agregasi ketika tidak ada kapal Relation

Warisan

Inheritance adalah Hubungan Orangtua Anak. Inheritance Means Is A RelationShip

Warisan dalam java adalah mekanisme di mana satu objek memperoleh semua properti dan perilaku objek induk.

Menggunakan pewarisan di Java 1 Code Reusability. 2 Tambahkan Fitur Ekstra di Kelas Anak dan juga Metode Overriding (sehingga polimorfisme runtime dapat dicapai).

Meskipun kedua Pewarisan dan Komposisi menyediakan penggunaan kembali kode, perbedaan utama antara Komposisi dan Pewarisan di Jawa adalah bahwa Komposisi memungkinkan penggunaan kembali kode tanpa memperluasnya, tetapi untuk Warisan Anda harus memperluas kelas untuk setiap penggunaan kembali kode atau fungsi. Perbedaan lain yang berasal dari fakta ini adalah bahwa dengan menggunakan Komposisi Anda dapat menggunakan kembali kode bahkan untuk kelas akhir yang tidak dapat diperluas tetapi Warisan tidak dapat menggunakan kembali kode dalam kasus tersebut. Juga dengan menggunakan Komposisi Anda dapat menggunakan kembali kode dari banyak kelas karena mereka dinyatakan hanya sebagai variabel anggota, tetapi dengan Inheritance Anda dapat menggunakan kembali bentuk kode hanya satu kelas karena di Jawa Anda hanya dapat memperluas satu kelas, karena beberapa Warisan tidak didukung di Jawa . Anda dapat melakukan ini di C ++ karena ada satu kelas dapat memperpanjang lebih dari satu kelas. BTW, Anda harus selalulebih suka Komposisi daripada Warisan di Jawa , itu bukan hanya saya tetapi bahkan Joshua Bloch telah menyarankan dalam bukunya

Saya pikir contoh ini menjelaskan dengan jelas perbedaan antara pewarisan dan komposisi .

Dalam contoh ini, masalahnya diselesaikan menggunakan pewarisan dan komposisi. Penulis memperhatikan fakta bahwa; dalam pewarisan , perubahan dalam superclass dapat menyebabkan masalah di kelas turunan, yang mewarisinya.

Di sana Anda juga dapat melihat perbedaan dalam representasi ketika Anda menggunakan UML untuk pewarisan atau komposisi.

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

Komposisi Pewarisan Vs.

Warisan dan komposisi keduanya digunakan untuk kegunaan ulang dan perluasan perilaku kelas.

Warisan terutama digunakan dalam model pemrograman algoritma keluarga seperti jenis hubungan IS-A berarti jenis objek yang sama. Contoh.

1. Duster adalah sebuah Mobil
2. Safari adalah sebuah Mobil

Ini milik keluarga Car.

Komposisi merepresentasikan tipe hubungan HAS-A. Ini menunjukkan kemampuan suatu objek seperti Duster memiliki Lima Gigi, Safari memiliki empat Gigi dll. Setiap kali kita perlu memperluas kemampuan kelas yang ada kemudian menggunakan komposisi. Contoh kita perlu menambahkan satu lagi gear pada objek Duster maka kita harus membuat satu lagi objek gear dan menyusunnya ke objek duster.

Kita tidak boleh membuat perubahan di kelas dasar sampai / kecuali semua kelas turunan membutuhkan fungsionalitas tersebut. Untuk skenario ini kita harus menggunakan Komposisi. Seperti

kelas A Berasal dari Kelas B

Kelas A Berasal dari Kelas C

Kelas A Berasal dari Kelas D.

Ketika kita menambahkan fungsionalitas apa pun di kelas A maka itu tersedia untuk semua sub kelas bahkan ketika Kelas C dan D tidak memerlukan fungsionalitas tersebut. Untuk skenario ini kita perlu membuat kelas terpisah untuk fungsionalitas tersebut dan menyusunnya ke kelas yang diperlukan ( di sini adalah kelas B).

Di bawah ini adalah contohnya:

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

Komposisi berarti membuat objek ke kelas yang memiliki hubungan dengan kelas tertentu. Misalkan Siswa memiliki hubungan dengan Akun;

Warisan adalah, ini adalah kelas sebelumnya dengan fitur yang diperluas. Itu berarti kelas baru ini adalah kelas lama dengan beberapa fitur tambahan. Misalkan Siswa adalah Siswa tetapi Semua Siswa adalah Manusia. Jadi ada hubungan dengan siswa dan manusia. Ini Warisan.

Tidak, keduanya berbeda. Komposisi mengikuti hubungan "HAS-A" dan pewarisan mengikuti hubungan "IS-A". Contoh terbaik untuk komposisi adalah pola Strategis.

Inheritence berarti menggunakan kembali fungsionalitas lengkap dari sebuah kelas, Di sini kelas saya harus menggunakan semua metode dari kelas super dan kelas saya akan digabungkan dengan kelas super dan kode akan diduplikasi di kedua kelas dalam hal pewarisan.

Tetapi kita dapat mengatasi semua masalah ini ketika kita menggunakan komposisi untuk berbicara dengan kelas lain. Komposisi mendeklarasikan atribut kelas lain ke kelas saya yang ingin kita bicarakan. dan fungsionalitas apa yang kita inginkan dari kelas itu yang bisa kita dapatkan dengan menggunakan atribut itu.