Java Çoklu Devralma

Java'nın çoklu kalıtım sorunlarının nasıl çözüleceğini tam olarak anlamaya çalışmak için açıklığa kavuşturmam gereken klasik bir sorum var.

Ben sınıf var Diyelim AnimalBu alt sınıflar vardır Birdve Horseben bir sınıf yapmak gerekir Pegasusuzanan Birdve Horseyana Pegasusbir kuş ve bir at hem de.

Bence bu klasik elmas problemi. Bunu çözmek için klasik bir yol anlayabiliyorum kadarıyla yapmaktır Animal, Birdve Horsesınıflar arayüzleri ve uygulamak Pegasusonlardan.

Kuşlar ve atlar için hala nesne oluşturabildiğim sorunu çözmenin başka bir yolu olup olmadığını merak ediyordum. Hayvan yaratmanın bir yolu olsaydı, bu harika olurdu ama gerekli de değildi.

public interface EquidaeAtlar ve public interface Avialaekuşlar gibi hayvan sınıfları (biyolojik anlamdaki sınıf) için arayüzler oluşturabilirsiniz (biyolog değilim, bu yüzden terimler yanlış olabilir).

Sonra yine de bir

public class Bird implements Avialae {
}

ve

public class Horse implements Equidae {}

ve ayrıca

public class Pegasus implements Avialae, Equidae {}

Yorumlardan ekleme:

Yinelenen kodu azaltmak için, uygulamak istediğiniz hayvanların ortak kodlarının çoğunu içeren soyut bir sınıf oluşturabilirsiniz.

public abstract class AbstractHorse implements Equidae {}

public class Horse extends AbstractHorse {}

public class Pegasus extends AbstractHorse implements Avialae {}

Güncelleme

Bir ayrıntı daha eklemek istiyorum. Brian'ın belirttiği gibi , bu OP'nin zaten bildiği bir şey.

Ancak, şunu vurgulamak isterim ki, "çoklu kalıtım" sorununu arabirimlerle atlamayı öneriyorum ve zaten somut bir türü (Bird gibi) temsil eden arabirimleri (daha fazla davranış) ( ördek-tipleme, bu da iyidir, ama sadece: kuşların biyolojik sınıfı, Avialae). Ayrıca IBird, bir arayüze neden ihtiyacınız olduğu hakkında hiçbir şey söylemeyen büyük bir 'I' ile başlayan arayüz adlarını kullanmanızı önermiyorum . Sorunun farkı budur: arayüzler kullanarak kalıtım hiyerarşisini oluşturun, yararlı olduğunda soyut sınıflar kullanın, gerektiğinde somut sınıflar uygulayın ve uygunsa temsilci kullanın.

Nesneleri bir araya getirmenin iki temel yaklaşımı vardır:

• Birincisi Kalıtım . Daha önce belirlediğiniz gibi, miras sınırlamaları burada ihtiyacınız olanı yapamayacağınız anlamına gelir.
• İkincisi Kompozisyon . Kalıtım başarısız olduğu için kompozisyon kullanmanız gerekir.

Bunun çalışma şekli bir Animal objeniz olması. Bu nesnenin içine istediğiniz özellikleri ve davranışları veren başka nesneler eklersiniz.

Örneğin:

• Kuş uzanır Hayvan uygular IFlier
• At uzatır Hayvan uygular IHerbivore, IQuadruped
• Pegasus , Hayvan uygulamalarını genişletir IHerbivore, IQuadruped, IFlier

Şimdi IFliersadece şöyle görünüyor:

 interface IFlier {
     Flier getFlier();
 }

Yani Birdşöyle görünüyor:

 class Bird extends Animal implements IFlier {
      Flier flier = new Flier();
      public Flier getFlier() { return flier; }
 }

Artık Kalıtımın tüm avantajlarına sahipsiniz. Kodu yeniden kullanabilirsiniz. IFliers koleksiyonuna sahip olabilir ve polimorfizmin diğer tüm avantajlarını kullanabilirsiniz.

Ancak Kompozisyonun tüm esnekliğine de sahipsiniz. AnimalHer bit için istediğiniz kadar farklı arabirim ve kompozit destek sınıfı uygulayabilirsiniz - her bitin nasıl kurulacağı üzerinde ihtiyacınız olan kontrol.

Strateji Deseni kompozisyona alternatif yaklaşım

Ne yaptığınıza ve nasıl yaptığınıza bağlı olarak alternatif bir yaklaşım, Animaltemel sınıfın farklı davranışların listesini tutmak için dahili bir koleksiyon içermesini sağlamaktır. Bu durumda, Strateji Modeline daha yakın bir şey kullanırsınız. Bu, kodun basitleştirilmesi açısından avantajlar sağlar (örneğin Horse, hakkında hiçbir şey bilmesine gerek yoktur Quadrupedveya Herbivore), ancak arayüz yaklaşımını da yapmazsanız, polimorfizmin avantajlarının çoğunu kaybedersiniz.

Aptalca bir fikrim var:

public class Pegasus {
    private Horse horseFeatures; 
    private Bird birdFeatures; 

   public Pegasus(Horse horse, Bird bird) {
     this.horseFeatures = horse;
     this.birdFeatures = bird;
   }

  public void jump() {
    horseFeatures.jump();
  }

  public void fly() {
    birdFeatures.fly();
  }
}

Ördek yazma konseptini önerebilir miyim ?

Büyük olasılıkla Pegasus'un bir Kuş ve At arayüzünü genişletmesini sağlama eğilimindesiniz, ancak ördek yazarak aslında davranışı miras almanız gerektiğini gösterir . Yorumlarda belirtildiği gibi, bir pegasus bir kuş değildir, ancak uçabilir. Bu yüzden Pegasus'unuz bir- Flyablearayüzü miras almalı ve bir Gallopable-yüzdüzey diyelim.

Bu tür bir kavram Strateji Modelinde kullanılır . Verilen örnek aslında bir ördek devralır nasıl gösterir FlyBehaviourve QuackBehaviourhala, ördekler olabilir mesela RubberDuck, uçamaz hangi. Ayrıca Duckbir Birdsınıfı genişletebilirlerdi, ama sonra biraz esneklikten vazgeçeceklerdi, çünkü her Duckbiri, hatta fakirleri bile uçurabilirdi RubberDuck.

Teknik olarak konuşursak, bir seferde yalnızca bir sınıfı genişletebilir ve birden fazla arabirim uygulayabilirsiniz, ancak yazılım mühendisliğine el koyarken, genellikle cevap verilemeyen soruna özel bir çözüm öneriyorum. Bu arada, somut sınıfları genişletmek değil / sadece istenmeyen miras davranışlarını önlemek için soyut sınıfları genişletmek iyi bir OO uygulamasıdır - "hayvan" diye bir şey yoktur ve bir hayvan nesnesinin kullanımı yoktur, sadece somut hayvanlar vardır.

Şubat 2014'ten itibaren hala geliştirme aşamasında olan Java 8'de, bir çeşit C ++ benzeri çoklu miras elde etmek için varsayılan yöntemleri kullanabilirsiniz . Ayrıca, çalışmaya başlamak için resmi belgelere göre daha kolay olması gereken birkaç örneği gösteren bu eğiticiye de göz atabilirsiniz .

Atın yarım kapı ile ahırda tutulması güvenlidir, çünkü at yarım kapıdan geçemez. Bu nedenle, at tipi herhangi bir ürünü kabul eden ve yarım kapı ile ahır içine koyan bir at konut hizmeti kuruyorum.

Öyleyse bir at bile uçabilen hayvan gibi bir at mı?

Çoklu kalıtım hakkında çok şey düşünürdüm, ancak 15 yıldan fazla bir süredir programladığım için artık çoklu kalıtım uygulamayı umursamıyorum.

Çoğu zaman, birden fazla mirasa işaret eden bir tasarımla başa çıkmaya çalıştığımda, daha sonra sorun alanını anladığımı serbest bıraktığım serbest bırakmaya geldim.

VEYA

Ördek gibi görünüyor ve ördek gibi quacks ama piller gerekiyorsa, muhtemelen yanlış soyutlama var .

Birden fazla miras olmadığı için Java'nın Çoklu kalıtım sorunu yoktur. Bu, gerçek çoklu miras problemini (elmas problemi) çözmek için tasarım gereğidir.

Sorunu azaltmak için farklı stratejiler vardır. En çabuk ulaşılabilen, Pavel'in önerdiği Kompozit nesnedir (esas olarak C ++ bunu nasıl ele alır). C3'ün doğrusallaştırılması (veya benzeri) yoluyla çoklu kalıtımın Java'nın geleceği için kartlarda olup olmadığını bilmiyorum, ama şüpheliyim.

Sorunuz akademikse, doğru çözüm Kuş ve At'ın daha somut olması ve bir Pegasus'un sadece bir Kuş ve Atın birleşik olduğunu varsaymak yanlıştır. Bir Pegasus'un Kuşlar ve Atlar ile ortak bazı içsel özelliklere sahip olduğunu söylemek daha doğru olur (yani belki ortak ataları vardır). Bu Moritz'in cevabının işaret ettiği gibi yeterince modellenebilir.

Bence bu sizin ihtiyaçlarınıza ve hayvan sınıflarınızın kodunuzda nasıl kullanılacağına bağlı.

Pegasus sınıfınızdaki At ve Kuş uygulamalarınızın yöntemlerinden ve özelliklerinden yararlanmak istiyorsanız, Pegasus'u bir Kuş ve Atın bir bileşimi olarak uygulayabilirsiniz :

public class Animals {

    public interface Animal{
        public int getNumberOfLegs();
        public boolean canFly();
        public boolean canBeRidden();
    }

    public interface Bird extends Animal{
        public void doSomeBirdThing();
    }
    public interface Horse extends Animal{
        public void doSomeHorseThing();
    }
    public interface Pegasus extends Bird,Horse{

    }

    public abstract class AnimalImpl implements Animal{
        private final int numberOfLegs;

        public AnimalImpl(int numberOfLegs) {
            super();
            this.numberOfLegs = numberOfLegs;
        }

        @Override
        public int getNumberOfLegs() {
            return numberOfLegs;
        }
    }

    public class BirdImpl extends AnimalImpl implements Bird{

        public BirdImpl() {
            super(2);
        }

        @Override
        public boolean canFly() {
            return true;
        }

        @Override
        public boolean canBeRidden() {
            return false;
        }

        @Override
        public void doSomeBirdThing() {
            System.out.println("doing some bird thing...");
        }

    }

    public class HorseImpl extends AnimalImpl implements Horse{

        public HorseImpl() {
            super(4);
        }

        @Override
        public boolean canFly() {
            return false;
        }

        @Override
        public boolean canBeRidden() {
            return true;
        }

        @Override
        public void doSomeHorseThing() {
            System.out.println("doing some horse thing...");
        }

    }

    public class PegasusImpl implements Pegasus{

        private final Horse horse = new HorseImpl();
        private final Bird bird = new BirdImpl();


        @Override
        public void doSomeBirdThing() {
            bird.doSomeBirdThing();
        }

        @Override
        public int getNumberOfLegs() {
            return horse.getNumberOfLegs();
        }

        @Override
        public void doSomeHorseThing() {
            horse.doSomeHorseThing();
        }


        @Override
        public boolean canFly() {
            return true;
        }

        @Override
        public boolean canBeRidden() {
            return true;
        }
    }
}

Başka bir olasılık, hayvanlarınızı tanımlamak için kalıtım yerine bir Varlık-Bileşen-Sistem yaklaşımı kullanmaktır. Tabii ki bu, hayvanların bireysel Java sınıflarına sahip olmayacağınız anlamına gelir, bunun yerine sadece bileşenleri tarafından tanımlanır.

Bir Varlık-Bileşen-Sistem yaklaşımı için bazı sözde kod şöyle görünebilir:

public void createHorse(Entity entity){
    entity.setComponent(NUMER_OF_LEGS, 4);
    entity.setComponent(CAN_FLY, false);
    entity.setComponent(CAN_BE_RIDDEN, true);
    entity.setComponent(SOME_HORSE_FUNCTIONALITY, new HorseFunction());
}

public void createBird(Entity entity){
    entity.setComponent(NUMER_OF_LEGS, 2);
    entity.setComponent(CAN_FLY, true);
    entity.setComponent(CAN_BE_RIDDEN, false);
    entity.setComponent(SOME_BIRD_FUNCTIONALITY, new BirdFunction());
}

public void createPegasus(Entity entity){
    createHorse(entity);
    createBird(entity);
    entity.setComponent(CAN_BE_RIDDEN, true);
}

bir arabirim hiyerarşisine sahip olabilir ve ardından sınıflarınızı seçilen arabirimlerden genişletebilirsiniz:

public interface IAnimal {
}

public interface IBird implements IAnimal {
}

public  interface IHorse implements IAnimal {
}

public interface IPegasus implements IBird,IHorse{
}

ve ardından belirli bir arayüzü genişleterek sınıflarınızı gerektiği gibi tanımlayın:

public class Bird implements IBird {
}

public class Horse implements IHorse{
}

public class Pegasus implements IPegasus {
}

Ehm, sınıfınız sadece 1 tane için alt sınıf olabilir, ancak yine de istediğiniz kadar çok arabirim uygulayabilirsiniz.

Bir Pegasus aslında uçabilen (bu özel atın "becerisi" olan) bir attır (atın özel bir halidir). Öte yandan, Pegasus'un yürüyebilen ve 4 ayaklı bir kuş olduğunu söyleyebilirsiniz - hepsi kod yazmanızın ne kadar kolay olduğuna bağlıdır.

Sizin durumunuzda olduğu gibi şunları söyleyebilirsiniz:

abstract class Animal {
   private Integer hp = 0; 
   public void eat() { 
      hp++; 
   }
}
interface AirCompatible { 
   public void fly(); 
}
class Bird extends Animal implements AirCompatible { 
   @Override
   public void fly() {  
       //Do something useful
   }
} 
class Horse extends Animal {
   @Override
   public void eat() { 
      hp+=2; 
   }

}
class Pegasus extends Horse implements AirCompatible {
   //now every time when your Pegasus eats, will receive +2 hp  
   @Override
   public void fly() {  
       //Do something useful
   }
}

Arabirimler çoklu kalıtım simüle etmez. Java içerik oluşturucuları birden fazla kalıtımın yanlış olduğunu düşündüğünden Java'da böyle bir şey yoktur.

İki sınıfın işlevselliğini bir arada kullanmak istiyorsanız, nesne kompozisyonunu kullanın. yani

public class Main {
    private Component1 component1 = new Component1();    
    private Component2 component2 = new Component2();
}

Belirli yöntemleri ortaya çıkarmak istiyorsanız, bunları tanımlayın ve çağrıyı ilgili denetleyiciye devretmelerine izin verin.

Burada arayüzler kullanışlı olabilir - eğer Component1arayüz Interface1ve Component2aletler uygularsa Interface2,

class Main implements Interface1, Interface2

Böylece nesneleri bağlamın izin verdiği yerlerde birbirinin yerine kullanabilirsiniz.

Benim açımdan, elmas sorununa giremezsiniz.

Zaten farkında olacağınız gibi, Java'daki sınıfların çoklu mirası mümkün değildir, ancak arayüzlerle mümkündür. Kompozisyon tasarım desenini kullanmayı da düşünebilirsiniz.

Birkaç yıl önce kompozisyon hakkında çok kapsamlı bir makale yazdım ...

/codereview/14542/multiple-inheritance-and-composition-with-java-and-c-updated

1. Define arayüzleri yetenekleri tanımlamak için. Birden çok özellik için birden çok arabirim tanımlayabilirsiniz. Bu yetenekler belirli Hayvan veya Kuş tarafından uygulanabilir .
2. Statik olmayan ve genel olmayan verileri / yöntemleri paylaşarak sınıflar arasında ilişki kurmak için kalıtım kullanın .
3. Dinamik olarak yetenekler eklemek için Decorator_pattern kullanın . Bu, kalıtım sınıfları ve kombinasyonlarının sayısını azaltmanıza izin verecektir.

Daha iyi anlamak için aşağıdaki örneğe bir göz atın

Dekoratör Kalıbı Ne Zaman Kullanılmalı?

Karmaşıklığı azaltmak ve dili basitleştirmek için java'da çoklu kalıtım desteklenmez.

A, B ve C'nin üç sınıf olduğu bir senaryo düşünün. C sınıfı A ve B sınıflarını devralır. A ve B sınıfları aynı yönteme sahipse ve bunu alt sınıf nesnesinden çağırırsanız, A veya B sınıfının yöntemini çağırma belirsizliği olacaktır.

Derleme zamanı hataları çalışma zamanı hatalarından daha iyi olduğundan, 2 sınıfı devralıyorsanız java derleme zamanı hatası oluşturur. Aynı yöntem veya farklı bir yöntem olsun, şimdi derleme zamanı hatası olacaktır.

class A {  
    void msg() {
        System.out.println("From A");
    }  
}

class B {  
    void msg() {
        System.out.println("From B");
    }  
}

class C extends A,B { // suppose if this was possible
    public static void main(String[] args) {  
        C obj = new C();  
        obj.msg(); // which msg() method would be invoked?  
    }
} 

Java → arabiriminde çoklu kalıtım sorununu çözmek için kullanılır

J2EE (core JAVA) Bay KVR Notları Sayfa 51

Gün - 27

1. Arayüzler temel olarak kullanıcı tanımlı veri tiplerini geliştirmek için kullanılır.
2. Arayüzler ile ilgili olarak, birden fazla miras kavramına ulaşabiliriz.
3. Arayüzler ile polimorfizm, dinamik bağlama kavramını başarabiliriz ve böylece JAVA programının performansını bellek alanı ve yürütme zamanı dönüşlerinde iyileştirebiliriz.

Bir arayüz, tamamen tanımlanmamış yöntemlerin toplanmasını içeren bir yapıdır veya bir arayüz, tamamen soyut yöntemlerin bir koleksiyonudur.

[...]

Gün - 28:

Arayüz (ler) in özelliklerini sınıfa tekrar kullanmak için Sözdizimi-1:

[abstract] class <clsname> implements <intf 1>,<intf 2>.........<intf n>
{
    variable declaration;
    method definition or declaration;
};

Yukarıdaki sözdiziminde clsname, özellikleri 'n' arabirim sayısından devralan sınıfın adını temsil eder. 'Implements', arayüzlerin özelliklerini türetilmiş bir sınıfa devralmak için kullanılan bir anahtar kelimedir.

[...]

Sözdizimi-2 'n' sayısını başka bir arabirime devralma:

interface <intf 0 name> extends <intf 1>,<intf 2>.........<intf n>
{     
    variable declaration cum initialization;
    method declaration;
};

[...]

Kullanımı-3:

[abstract] class <derived class name> extends <base class name> implements <intf 1>,<intf 2>.........<intf n>
{
  variable declaration;
  method definition or declaration;
};