Uygulama vs uzar: Ne zaman kullanılır? Fark ne?


Yanıtlar:


736

extendsiçin uzanan bir sınıf.

implementsiçindir uygulayan bir arabirim

Bir arabirim ve normal bir sınıf arasındaki fark, bir arabirimde bildirilen yöntemlerden hiçbirini uygulayamamanızdır. Yalnızca arabirimi "uygulayan" sınıf yöntemleri uygulayabilir. Bir arabirimin C ++ eşdeğeri soyut bir sınıf olacaktır (TAMAMEN aynı değil, hemen hemen).

Ayrıca java, sınıflar için çoklu kalıtım özelliğini desteklemez . Bu, çoklu arayüzler kullanılarak çözülür.

 public interface ExampleInterface {
    public void doAction();
    public String doThis(int number);
 }

 public class sub implements ExampleInterface {
     public void doAction() {
       //specify what must happen
     }

     public String doThis(int number) {
       //specfiy what must happen
     }
 }

şimdi bir sınıfı genişletiyor

 public class SuperClass {
    public int getNb() {
         //specify what must happen
        return 1;
     }

     public int getNb2() {
         //specify what must happen
        return 2;
     }
 }

 public class SubClass extends SuperClass {
      //you can override the implementation
      @Override
      public int getNb2() {
        return 3;
     }
 }

bu durumda

  Subclass s = new SubClass();
  s.getNb(); //returns 1
  s.getNb2(); //returns 3

  SuperClass sup = new SuperClass();
  sup.getNb(); //returns 1
  sup.getNb2(); //returns 2

Nesne yönelimli programlamada dinamik bağlanma, polimorfizm ve genel kalıtım hakkında biraz daha araştırma yapmanızı öneririm


46
Bir arabirim yöntem bildirimlerinden çok daha fazlasını içerebilir: Sabit alanlar, ek açıklamalar, arabirimler ve hatta sınıflar.
Philipp Reichart

yakutta modüller ve karışımlar gibi bir şey mi?
user2492854

@ user2492854 biraz, ancak bir arayüzde uygulanan herhangi bir yöntem olmayacak. Kelimenin tam anlamıyla bir arayüzün açıklaması değil, bir uygulama değil.
Rob Grant

34
Java 8'deki yeni bir özellik, defaultarabirimlerdeki yöntemler için davranışın uygulanmasına izin vererek, bu yöntemlerin özel uygulamasını isteğe bağlı hale getirir. Bu nedenle, "yalnızca yöntemleri belirtebilirsiniz, ancak bunları uygulayamazsınız" ifadesi yalnızca Java 7 ve altı için tam olarak doğrudur .
Kasım'da ADTC

5
"uzatmak bir sınıfı genişletmek içindir", biraz kafa karıştırıcı. Bir arabirimi sinüs haline getirir ve bir arabirimi de genişletir . Örneğin:public interface ListIterator<E> extends Iterator<E>
weiheng

78

Profilinizde bazı C ++ sorularınız olduğunu fark ettim. C ++ 'dan çoklu kalıtım kavramını anlarsanız (karakteristikleri birden fazla sınıftan devralan sınıflara atıfta bulunursanız ), Java buna izin vermez, ancak interfaceC ++' da saf sanal sınıf gibi bir anahtar kelimeye sahiptir. Birçok kişi tarafından belirtildiği gibi, extendbir sınıf (ve yalnızca bir taneden uzayabilirsiniz) ve implementbir arabirim - ancak sınıfınız istediğiniz kadar arabirim uygulayabilir.

Yani, bu anahtar kelimeler ve bunların kullanımını düzenleyen kurallar, Java'da çoklu kalıtım olanaklarını tanımlar (yalnızca bir süper sınıfınız olabilir, ancak birden çok arabirim uygulayabilirsiniz).


51

Genel olarak uygular bir uygulama için kullanılan arabirim ve uzandığı için kullanılan uzatma temel sınıf davranışı veya soyut sınıfı.

uzanmaktadır : bir türevi sınıfı, bir temel sınıf uzanabilir. Kurulu bir ilişkinin davranışını yeniden tanımlayabilirsiniz. Türetilmiş sınıf " bir " temel sınıf türüdür

uygular : Bir sözleşme uyguluyorsunuz. Arayüzü uygulayan sınıfın "yeteneği " vardır .

Java 8 sürümü ile arabirim, arabirimde uygulama sağlayan arabirimde varsayılan yöntemlere sahip olabilir .

Her birinin ne zaman kullanılacağı hakkında bu soruya bakın:

Arayüz ve Soyut Sınıf (genel OO)

Şeyleri anlamak için örnek.

public class ExtendsAndImplementsDemo{
    public static void main(String args[]){

        Dog dog = new Dog("Tiger",16);
        Cat cat = new Cat("July",20);

        System.out.println("Dog:"+dog);
        System.out.println("Cat:"+cat);

        dog.remember();
        dog.protectOwner();
        Learn dl = dog;
        dl.learn();

        cat.remember();
        cat.protectOwner();

        Climb c = cat;
        c.climb();

        Man man = new Man("Ravindra",40);
        System.out.println(man);

        Climb cm = man;
        cm.climb();
        Think t = man;
        t.think();
        Learn l = man;
        l.learn();
        Apply a = man;
        a.apply();

    }
}

abstract class Animal{
    String name;
    int lifeExpentency;
    public Animal(String name,int lifeExpentency ){
        this.name = name;
        this.lifeExpentency=lifeExpentency;
    }
    public void remember(){
        System.out.println("Define your own remember");
    }
    public void protectOwner(){
        System.out.println("Define your own protectOwner");
    }

    public String toString(){
        return this.getClass().getSimpleName()+":"+name+":"+lifeExpentency;
    }
}
class Dog extends Animal implements Learn{

    public Dog(String name,int age){
        super(name,age);
    }
    public void remember(){
        System.out.println(this.getClass().getSimpleName()+" can remember for 5 minutes");
    }
    public void protectOwner(){
        System.out.println(this.getClass().getSimpleName()+ " will protect owner");
    }
    public void learn(){
        System.out.println(this.getClass().getSimpleName()+ " can learn:");
    }
}
class Cat extends Animal implements Climb {
    public Cat(String name,int age){
        super(name,age);
    }
    public void remember(){
        System.out.println(this.getClass().getSimpleName() + " can remember for 16 hours");
    }
    public void protectOwner(){
        System.out.println(this.getClass().getSimpleName()+ " won't protect owner");
    }
    public void climb(){
        System.out.println(this.getClass().getSimpleName()+ " can climb");
    }
}
interface Climb{
    public void climb();
}
interface Think {
    public void think();
}

interface Learn {
    public void learn();
}
interface Apply{
    public void apply();
}

class Man implements Think,Learn,Apply,Climb{
    String name;
    int age;

    public Man(String name,int age){
        this.name = name;
        this.age = age;
    }
    public void think(){
        System.out.println("I can think:"+this.getClass().getSimpleName());
    }
    public void learn(){
        System.out.println("I can learn:"+this.getClass().getSimpleName());
    }
    public void apply(){
        System.out.println("I can apply:"+this.getClass().getSimpleName());
    }
    public void climb(){
        System.out.println("I can climb:"+this.getClass().getSimpleName());
    }
    public String toString(){
        return "Man :"+name+":Age:"+age;
    }
}

çıktı:

Dog:Dog:Tiger:16
Cat:Cat:July:20
Dog can remember for 5 minutes
Dog will protect owner
Dog can learn:
Cat can remember for 16 hours
Cat won't protect owner
Cat can climb
Man :Ravindra:Age:40
I can climb:Man
I can think:Man
I can learn:Man
I can apply:Man

Anlaşılması gereken önemli noktalar:

  1. Köpek ve Kedi hayvanlar ve onlar genişletilmiş remember() ve protectOwnerpaylaşarak () name,lifeExpentencydenAnimal
  2. Kedi tırmanabilir () ama Köpek değil. Köpek düşünebilir () ama Kedi düşünmüyor . Bu özel yetenekler, bu özelliğe eklenir Catve Doguygulanır.
  3. İnsan bir hayvan değil, Think,Learn,Apply,Climb

Bu örnekleri inceleyerek şunu anlayabilirsiniz:

İlişkisiz sınıflar arabirim aracılığıyla yeteneklere sahip olabilir, ancak ilgili sınıflar temel sınıfların genişletilmesi yoluyla davranışı geçersiz kılar.


1
Çok iyi açıkladı. Sadece tıkladı. Çok teşekkürler!
Emir Memic

Gerçekten öyle mi? Ben her zaman "sahip" bir şeye sahip olmak, sahip olmak anlamına gelir düşündüm. Kedinin "tırmanma kabiliyeti" olduğunu söyleyebilirsin, ama senin örneğini tekrar sarsayım. Cat "bir" Tırmanıcı ", bir adam" bir "" düşünür, öğrenen, dağcı "dır. Adam" bir "düşünür olduğu için, bir düşünürün yapabileceklerini yapabilir. Bazı protokollerle çalışırken daha da açıktır. bir evi var, bir kapısı var, ama pushingHandle uygulamıyor. Aynı zamanda "bir" MaterialObject, yani yerçekimine itaat etmek için bir arayüz uyguluyor; "GravityObeyingSkill" veya benzeri bir şey yok.
MatthewRock

İnsan bir düşünürse, uygular ile değil, uzayanlarla ilişki kuracağım. Düşünürün bazı durumları ve başka rolleri / özellikleri olabilir, ancak düşünme yeteneğini yalnızca arayüzle uygulayacağım. IS A, kalıtım için kullanılan standart terimdir.
Ravindra babu

@Ravindrababu Böyle açık bir açıklama için çok teşekkürler.
kanudo

1
büyük açıkladı!
Dary

43

extendstemel sınıftan miras aldığınızda (yani işlevlerini genişlettiğinizde) içindir.

implementsbir arayüz uygularken içindir .

İşte başlamak için iyi bir yer: Arayüzler ve Kalıtım .


24
Ve uzatır da bir arayüzü uzattığınızda :-) içindir.
Mark Peters

34

A classyalnızca "uygulayabilir" interface. Bir sınıf sadece "uzanır" a class. Benzer şekilde, bir interfacediğeri uzayabilir interface.

A classsadece birbirini uzatabilir class. A classbirkaç interfaces uygulayabilir .

Bunun yerine abstract classes ve interfaces'nin ne zaman kullanılacağını bilmekle daha fazla ilgileniyorsanız, şu konuya bakın: Interface vs Abstract Class (general OO)


2
Bir arayüzü de genişletebilirsiniz.
Mark Peters

2
A classsadece birini uygulayabilir interface. A classdiğer birkaç sınıfı genişletebilir. Bunu geri aldığını düşünüyorum.
pb2q

Sadece pb2q ile yorumu netleştirmek için, cevap zaten düzenlendi / düzeltildi. "Bir sınıf yalnızca bir sınıfı genişletebilir. Bir sınıf birden fazla arabirim uygulayabilir" doğru ifadedir.
wisbucky

29

Arayüz, bir nesnenin yapabileceği eylemlerin bir açıklamasıdır ... örneğin bir ışık anahtarını çevirdiğinizde, ışık yanar, nasıl olduğunu umursamazsınız, sadece yapar. Nesneye Yönelik Programlamada, Arayüz, bir nesnenin "X" olması için sahip olması gereken tüm işlevlerin açıklamasıdır. Yine, örnek olarak, "ACTS LIKE" ışığının olduğu her şeyin bir turn_on () yöntemi ve bir turn_off () yöntemi olmalıdır. Arabirimlerin amacı, bilgisayarın bu özellikleri zorlamasına izin vermek ve TYPE T nesnesinin (arabirim ne olursa olsun) X, Y, Z vb. İşlevlere sahip olması gerektiğini bilmektir.

Arabirim, bilgisayarın bir nesne (sınıf) üzerindeki belirli özellikleri zorlamasına izin veren bir programlama yapısı / sözdizimidir. Örneğin, bir araba sınıfımız ve bir scooter sınıfımız ve bir kamyon sınıfımız olduğunu varsayalım. Bu üç sınıfın her birinde bir start_engine () eylemi olmalıdır. Her araç için "motorun çalıştırılması" her bir sınıfa bırakılır, ancak bir start_engine eylemi olması gerektiği arayüzün etki alanıdır .


4
Büyük açıklama; daha fazla tanınmayı hak ediyor.
Arvindh Mani

22

Aşağıda verilen şekilde gösterildiği gibi, bir sınıf başka bir sınıfı genişletir, bir arayüz başka bir arayüzü genişletir, ancak bir sınıf bir arayüz uygular. resim açıklamasını buraya girin

Daha fazla ayrıntı için


16

Uzatmalar : Bu, bir üst sınıfın özniteliklerini temel sınıfa almak için kullanılır ve alt sınıfta geçersiz kılınabilecek önceden tanımlanmış yöntemler içerebilir.

Gerçekler : Bu, alt sınıfta tanımlayarak bir arabirimi (yalnızca işlev imzaları olan ancak tanımları olmayan üst sınıf) uygulamak için kullanılır.

Özel bir koşul vardır: "Yeni bir Arayüzün mevcut bir arayüzün alt öğesi olmasını istersem ne olur?". Yukarıdaki durumda, alt arabirim üst arabirimi genişletir .


15
  • A, B'yi genişletir:

    A ve B her iki sınıf veya her iki arabirimdir

  • A, B'yi uygular

    A bir sınıf ve B bir arayüz

  • A'nın bir arayüz ve B'nin bir sınıf olduğu diğer durum Java'da yasal değildir.


12

Arabirimler için uygular ve bir sınıfı genişletmek için uzanır.

Daha kolay bir şekilde daha açık hale getirmek için, bir arayüz kulağa benziyor - bir arayüz - bir fikir - uygulamanız, takip etmeniz ve düşünmeniz gereken bir model.

Extend sınıflar için kullanılır, burada, daha fazla işlevsellik ekleyerek zaten var olan bir şeyi genişletiyorsunuz.

Birkaç not daha:

bir arayüz başka bir arayüzü genişletebilir.

Ayrıca, bir arabirimi uygulama veya belirli bir senaryo için bir sınıfı genişletme arasında seçim yapmanız gerektiğinde, bir arabirim uygulamaya gidin. Çünkü bir sınıf birden fazla arabirim uygulayabilir, ancak yalnızca bir sınıfı genişletebilir.


8

Her iki anahtar kelime de Java dilinde kendi sınıfınızı oluştururken kullanılır.

Fark: implementssınıfınızda bir Java Arabirimi öğelerini kullandığınız anlamına gelir. extends, genişlettiğiniz temel sınıfın bir alt sınıfını oluşturduğunuz anlamına gelir. Çocuk sınıfınızda yalnızca bir sınıfı genişletebilirsiniz, ancak istediğiniz kadar çok arabirim uygulayabilirsiniz.

Daha fazla bilgi için arayüz üzerindeki oracle dokümantasyon sayfasına bakınız.

Bu, bir arayüzün ne olduğunu ve bunları kullanma konusundaki kuralları açıklığa kavuşturmaya yardımcı olabilir.


7

Bir alt sınıf bir sınıfı genişlettiğinde, alt sınıfın üst türde tanımlanan kodu devralmasına (yeniden kullanmasına) ve geçersiz kılmasına izin verir. Sınıf bir arabirim uyguladığında, sınıftan oluşturulan bir nesnenin arabirimin bir değerini bekleyen herhangi bir bağlamda kullanılmasına izin verir.

Buradaki gerçek yakalama, bir şeyi uygularken, bu yöntemleri olduğu gibi kullandığımız anlamına gelir. Değerlerinde ve dönüş türlerinde değişiklik için bir kapsam yoktur.

Ama bir şeyi genişlettiğimizde, bu sizin sınıfınızın bir uzantısı haline gelir. Değiştirebilir, kullanabilir, tekrar kullanabilirsiniz ve üst sınıfta olduğu gibi aynı değerleri döndürmesi gerekmez.


19 Eylül'de 3 yıldan fazla bir süre sonra benim tarafımdan yazılan bu cevabı okuyorum. Şimdi çok daha iyi bir cevap yazabilirim. İlginç şey.
Nikhil Arora

7

Biz kullanmak alt sınıf uzanır SuperClass alt sınıf zaten deklare edilmediği bazı işlevleri (metodları veya örnek değişkenleri) kullanmak istediği yalnızca üst sınıf , yoksa biraz işlevselliğini değiştirmek istiyorsanız SuperClass (Yöntem geçersiz kılma). Ama diyelim ki, örneğin bir Animal sınıfı ( SuperClass ) ve Dog sınıfı ( SubClass ) var ve Animal sınıfında tanımladığım birkaç yöntem var. doEat (); , doSleep (); ... ve daha fazlası.

Şimdi, Köpek sınıfım basitçe Hayvan sınıfını genişletebilir, eğer köpeğimin Hayvan sınıfında beyan edilen yöntemlerden herhangi birini kullanmasını istiyorsam, sadece bir Köpek nesnesi oluşturarak bu yöntemleri çağırabilirim. Bu şekilde yiyip uyuyabilecek bir köpeğimin olduğunu ve köpeğin yapmasını istediğim her şeyi yapabileceğimi garanti edebilirim.

Şimdi, hayal edin, bir gün bir kedi sevgilisi çalışma alanımıza giriyor ve Hayvan sınıfını genişletmeye çalışıyor (kediler de yer ve uyuyor). Bir Cat nesnesi yapar ve yöntemleri çağırmaya başlar.

Ama diyelim ki birisi Animal sınıfının bir nesnesini yapmaya çalışıyor. Bir kedinin nasıl uyuduğunu söyleyebilir, bir köpeğin nasıl yediğini söyleyebilir, bir filin nasıl içtiğini söyleyebilirsiniz. Ancak, Animal sınıfının bir nesnesini yapmak hiç mantıklı değil. Çünkü bu bir şablon ve genel bir yemek istemiyoruz.

Bunun yerine, kimsenin örnekleyemeyeceği ancak diğer sınıflar için şablon olarak kullanılabileceği soyut bir sınıf yapmayı tercih edeceğim.

Sonuç olarak, Interface yöntem uygulaması olmayan, sadece tanımları (şablonlar) içeren soyut bir sınıftan (saf bir soyut sınıf) başka bir şey değildir. Yani arayüzü kim uygularsa sadece doEat () şablonlarına sahip olduklarını bilir ; ve doSleep (); ancak kendi doEat () yöntemlerini tanımlamaları gerekir ; ve doSleep (); ihtiyaca göre yöntemler.

Yalnızca SuperClass'ın bir kısmını yeniden kullanmak istediğinizde genişletirsiniz (ancak unutmayın, SuperClass'ınızın yöntemlerini ihtiyacınıza göre geçersiz kılabilirsiniz) ve şablonları istediğinizde ve bunları kendi başınıza tanımlamak istediğinizde uygularsınız (ihtiyaca göre).

Sizinle bir parça kod paylaşacağım: Farklı giriş kümeleriyle deneyip sonuçlara bakıyorsunuz.

class AnimalClass {

public void doEat() {

    System.out.println("Animal Eating...");
}

public void sleep() {

    System.out.println("Animal Sleeping...");
}

}

public class Dog extends AnimalClass implements AnimalInterface, Herbi{

public static void main(String[] args) {

    AnimalInterface a = new Dog();
    Dog obj = new Dog();
    obj.doEat();
    a.eating();

    obj.eating();
    obj.herbiEating();
}

public void doEat() {
    System.out.println("Dog eating...");
}

@Override
public void eating() {

    System.out.println("Eating through an interface...");
    // TODO Auto-generated method stub

}

@Override
public void herbiEating() {

    System.out.println("Herbi eating through an interface...");
    // TODO Auto-generated method stub

}


}

Tanımlı Arayüzler :

public interface AnimalInterface {

public void eating();

}


interface Herbi {

public void herbiEating();

}

7

En basit terimlerle uzanan bir gelen devralır için kullanılır sınıfın ve uygular bir uygulamak için kullanılan arayüz Sınıfındaki

uzanır :

public class Bicycle {
    //properties and methods
}
public class MountainBike extends Bicycle {
    //new properties and methods
}

uygular :

public interface Relatable {
    //stuff you want to put
}
public class RectanglePlus implements Relatable {
    //your class code
}

hala karışıklık varsa bunu okuyun: https://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html https://docs.oracle.com/javase/tutorial/java/IandI/usinginterface.html


5

Sınıflar ve arayüzler hem sözleşmelerdir . Bir uygulamanın diğer bölümlerinin dayandığı yöntemler ve özellikler sağlarlar.

Bu sözleşmenin uygulama ayrıntılarıyla ilgilenmediğinizde bir arayüz tanımlarsınız . Dikkat edilmesi gereken tek şey, sözleşmenin (arayüz) mevcut olmasıdır.

Bu durumda , sözleşmenin nasıl yapıldığına dair ayrıntıları dikkate almak için arabirimi uygulayan sınıfa bırakırsınız . Yalnızca sınıflar arabirimler uygulayabilir.

uzatmak , mevcut bir sözleşmenin ayrıntılarını değiştirmek istediğinizde kullanılır. Bu şekilde bir sözleşmeyi yerine getirmenin bir yolunu farklı bir yolla değiştirirsiniz. Sınıflar diğer sınıfları genişletebilir ve arabirimler diğer arabirimleri genişletebilir.


3

Extendsalt sınıfınızda / arabiriminizde üst sınıf / arabirim implementsözniteliklerini istediğinizde ve sınıfınızda bir arabirimin özniteliklerini istediğinizde kullanılır.

Misal:

  1. Sınıfı genişletir

    sınıf Veli {

    }

    sınıf Çocuk Veli uzatır {

    }

  2. Arayüzü kullanarak genişletir

    arayüz Ebeveyn {

    }

    arayüz Çocuk Ebeveyn {

    }

  3. uygular

arayüz A {

}

B sınıfı A {

}

Uzatmalar ve aletler kombinasyonu

interface A{

}

class B

{

}

class C implements A,extends B{

}

2

uzanır

  • sınıf yalnızca bir sınıfı genişletir
  • arayüz bir veya daha fazla arayüzü genişletir

uygular

  • class bir veya daha fazla arabirim uygular
  • arayüzler 'can' herhangi bir şey uygular

soyut sınıflar da, sınıflar gibi hareket eder;


0

Bu iki anahtar kelime doğrudan Kalıtım ile iliştirilir, bu temel bir OOP konseptidir. Elimizden kullanımı başka bir sınıfa bazı sınıfını miras zaman uzanır ama bizim sınıfa bazı arayüzleri miras giderken biz kullanımının biz kullanmalıdır uzanır edemez uygular ve kullanım yapabilirsiniz uzanan başka bir arayüzden miras arayüze anahtar kelime.

Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.