Bir arayüz ile soyut sınıf arasındaki fark tam olarak nedir?

Arayüzler

Bir arabirim bir sözleşmedir : Arabirimi yazan kişi " hey, bu şekilde görünen şeyleri kabul ediyorum " der ve arabirimi kullanan kişi " Tamam, yazdığım sınıf bu şekilde görünüyor " der .

Bir arayüz boş bir kabuktur . Sadece yöntemlerin imzaları vardır, bu da yöntemlerin bir gövdesi olmadığını ima eder. Arayüz hiçbir şey yapamaz. Sadece bir model.

Örneğin (sözde kod):

// I say all motor vehicles should look like this:
interface MotorVehicle
{
    void run();

    int getFuel();
}

// My team mate complies and writes vehicle looking that way
class Car implements MotorVehicle
{

    int fuel;

    void run()
    {
        print("Wrroooooooom");
    }


    int getFuel()
    {
        return this.fuel;
    }
}

Bir arayüz uygulamak çok az CPU tüketir, çünkü bu bir sınıf değil, sadece bir grup isimdir ve bu nedenle yapılacak pahalı bir arama yoktur. Gömülü cihazlarda olduğu gibi önemli olduğunda harika.

Soyut sınıflar

Soyut sınıflar, arayüzlerden farklı olarak sınıflardır. Kullanımı daha pahalıdır, çünkü onlardan miras aldığınızda yapılacak bir arama vardır.

Soyut sınıflar arayüzlere çok benziyor, ancak daha fazlası var: Onlar için bir davranış tanımlayabilirsiniz. Daha çok bir kişi, " bu sınıflar böyle görünmeli ve ortak noktaları var, bu yüzden boşlukları doldurun! "

Örneğin:

// I say all motor vehicles should look like this:
abstract class MotorVehicle
{

    int fuel;

    // They ALL have fuel, so lets implement this for everybody.
    int getFuel()
    {
         return this.fuel;
    }

    // That can be very different, force them to provide their
    // own implementation.
    abstract void run();
}

// My teammate complies and writes vehicle looking that way
class Car extends MotorVehicle
{
    void run()
    {
        print("Wrroooooooom");
    }
}

uygulama

Soyut sınıflar ve arayüzler farklı kavramlar olsa da, uygulamalar bu ifadeyi bazen yanlış yapar. Bazen, düşündüğünüz şey bile olmayabilirler.

Java'da bu kural güçlü bir şekilde uygulanırken, PHP'de arabirimler bildirilen hiçbir yöntem olmadan soyut sınıflardır.

Python'da soyut sınıflar, ABC modülünden alabileceğiniz bir programlama hilesi ve aslında metasınıfları ve dolayısıyla sınıfları kullanıyor. Ve arayüzler bu dilde ördek yazmayla daha ilgilidir ve tanımlayıcıları (__method__ yöntemleri) çağıran kurallar ve özel yöntemler arasında bir karışımdır.

Programlamada her zamanki gibi, başka bir dilde teori, pratik ve pratik var :-)

Soyut bir sınıf ile arayüz arasındaki temel teknik farklar şunlardır:

• Soyut sınıflar sabitler, üyeler, yöntem saplamaları (gövdesiz yöntemler) ve tanımlı yöntemler içerebilirken, arayüzler sadece sabitler ve yöntemler saplamaları içerebilir .

• Bir soyut sınıfın yöntemleri ve üyeleri herhangi bir görünürlükle tanımlanabilirken , bir arabirimin tüm yöntemleri ( publicvarsayılan olarak herkese açık olarak tanımlanır) olarak tanımlanmalıdır.

• Soyut bir sınıfı devralırken, somut bir çocuk sınıfı soyut yöntemleri tanımlamalıdır , oysa soyut bir sınıf başka bir soyut sınıfı genişletebilir ve ana sınıftan soyut yöntemlerin tanımlanması gerekmez.

• Benzer şekilde, başka bir arabirimi genişleten bir arabirim, üst arabirimden yöntemlerin uygulanmasından sorumlu değildir . Bunun nedeni, arabirimlerin herhangi bir uygulamayı tanımlayamamasıdır.

• Bir alt sınıf yalnızca tek bir sınıfı (soyut veya somut) genişletebilirken, bir arabirim genişletilebilir veya bir sınıf birden çok başka arabirim uygulayabilir .

• Bir alt sınıf, aynı veya daha az kısıtlayıcı görünürlüğe sahip soyut yöntemleri tanımlayabilirken, arabirimi uygulayan bir sınıfın, aynı görünürlüğü (genel) olan yöntemleri tanımlaması gerekir.

Bir Arayüz yalnızca işlevsellik tanımını / imzasını içerir ve ortak imzaların yanı sıra bazı ortak işlevlerimiz varsa, soyut bir sınıf kullanmamız gerekir. Soyut bir sınıf kullanarak, aynı anda hem davranış hem de işlevsellik sağlayabiliriz. Soyut sınıfı devralan başka bir geliştirici, yalnızca boşlukları doldurmaları gerektiği için bu işlevselliği kolayca kullanabilir.

Den alınan:

http://www.dotnetbull.com/2011/11/difference-between-abstract-class-and.html

http://www.dotnetbull.com/2011/11/what-is-abstract-class-in-c-net.html http://www.dotnetbull.com/2011/11/what-is-interface-in c-net.html

Bir açıklama burada bulunabilir: http://www.developer.com/lang/php/article.php/3604111/PHP-5-OOP-Interfaces-Abstract-Classes-and-the-Adapter-Pattern.htm

Soyut bir sınıf, programcı tarafından sadece kısmen uygulanan bir sınıftır. Bir veya daha fazla soyut yöntem içerebilir. Soyut bir yöntem, programcıya yöntemin bir alt sınıfta uygulanması gerektiğini söyleyen bir işlev tanımıdır.

Bir arayüz soyut bir sınıfa benzer; aslında arayüzler sınıflar ve soyut sınıflarla aynı isim alanını işgal eder. Bu nedenle, sınıfla aynı ada sahip bir arabirim tanımlayamazsınız. Arayüz tamamen soyut bir sınıftır; yöntemlerinden hiçbiri uygulanmadı ve ondan bir sınıf alt sınıflaması yerine, bu arayüzü uyguladığı söyleniyor.

Her neyse, arayüzlerin bu açıklamasını biraz kafa karıştırıcı buluyorum. Daha yaygın bir tanım şudur: Arayüz, uygulayıcı sınıfların yerine getirmesi gereken bir sözleşmeyi tanımlar. Bir arayüz tanımı, herhangi bir uygulama kodu olmaksızın, genel üyelerin imzalarından oluşur.

Birçok cevapta söylenmiş olan farklılıkları vurgulamak istemiyorum (soyut sınıflardaki korumalı, özel yöntemler için arayüz ve destek için değişkenler için genel statik son değiştiriciler hakkında)

Basit bir ifadeyle şunu söylemek isterim:

arayüz: İlişkisiz birden çok nesne tarafından bir sözleşme uygulamak

soyut sınıf: Aynı veya farklı davranışı birden çok ilişkili nesne arasında uygulamak için

Oracle belgelerinden

Aşağıdaki durumlarda soyut sınıfları kullanmayı düşünün :

1. Kodu yakından ilişkili birkaç sınıf arasında paylaşmak istiyorsunuz.
2. Soyut sınıfınızı genişleten sınıfların birçok ortak yöntemi veya alanı olmasını veya genel (erişim korumalı ve özel gibi) dışında erişim değiştiricileri gerektirmesini beklersiniz.
3. Statik olmayan veya son olmayan alanları bildirmek istiyorsunuz.

Aşağıdaki durumlarda arayüzleri kullanmayı düşünün :

1. İlişkisiz sınıfların arayüzünüzü uygulamasını beklersiniz. Örneğin, ilgisiz birçok nesne Serializablearabirim uygulayabilir .
2. Belirli bir veri türünün davranışını belirtmek istiyorsunuz, ancak davranışını kimin uyguladığından endişe etmiyorsunuz.
3. Birden fazla tür mirasından yararlanmak istiyorsunuz.

soyut sınıf, somut sınıflarla "bir" ilişkisini kurar. arabirim sınıflar için "vardır" yeteneği sağlar.

JavaProgramlama dili olarak arıyorsanız , birkaç güncelleme daha:

Java 8 arasındaki boşluğu azalttı interfaceve abstractbir sağlayarak bir ölçüde sınıfları defaultyöntem özelliği. Arabirimin bir yöntemi olmayan uygulaması artık geçerli değil.

Daha fazla ayrıntı için bu belgeler sayfasına bakın.

Daha iyi anlamak için kod örnekleri için bu SE sorusuna bir göz atın.

Bir Interface ve Abstract sınıfı arasındaki farkı nasıl açıklamalıydım?

Bazı önemli farklılıklar:

Bir tablo şeklinde:

Joe tarafından javapapers'tan belirtildiği gibi :

1.Ana fark, bir Java arayüzünün yöntemlerinin dolaylı olarak soyut olması ve uygulamaları olamaz. Java soyut sınıfında, varsayılan davranışı uygulayan örnek yöntemler bulunabilir.

2.Java arayüzünde bildirilen değişkenler varsayılan olarak son şeklindedir. Soyut bir sınıf, son olmayan değişkenler içerebilir.

3.Java arayüzünün üyeleri varsayılan olarak herkese açıktır. Bir Java soyut sınıfı, özel, korumalı vb. Sınıf üyelerinin olağan lezzetlerine sahip olabilir.

4.Java arayüzü “implements” anahtar sözcüğü kullanılarak uygulanmalıdır; Bir Java soyut sınıfı, "extends" anahtar kelimesi kullanılarak genişletilmelidir.

5.bir arabirim sadece başka bir Java arabirimini genişletebilir, soyut bir sınıf başka bir Java sınıfını genişletebilir ve birden fazla Java arabirimi uygulayabilir.

Bir Java sınıfı birden fazla arabirim uygulayabilir, ancak yalnızca bir soyut sınıfı genişletebilir.

7.Arayüz kesinlikle soyuttur ve somutlaştırılamaz; Bir Java soyut sınıfı da somutlaştırılamaz, ancak bir main () varsa çağrılabilir.

Java soyut sınıflarıyla karşılaştırıldığında, java arayüzleri ekstra dolaylama gerektirdiğinden yavaştır.

Ana nokta şudur:

• Soyut nesne yönelimlidir . Bir 'nesnenin' sahip olması gereken temel verileri ve / veya yapabilmesi gereken fonksiyonları sunar. Nesnenin temel özellikleri ile ilgilidir: sahip olduğu ve ne yapabileceği. Dolayısıyla aynı soyut sınıftan miras alan nesneler temel özellikleri (genelleme) paylaşır.
• Arayüz işlevselliğe yöneliktir . Bir nesnenin sahip olması gereken işlevleri tanımlar. Hangi nesne olduğuna bakılmaksızın, arayüzde tanımlanan bu işlevleri yapabildiği sürece sorun yoktur. Diğer her şeyi yok sayar. Bir nesne / sınıf birkaç (grup) işlevsellik içerebilir; dolayısıyla bir sınıfın birden fazla arabirim uygulaması mümkündür.

Bir kalıtım hiyerarşisinde polimorfik davranış sağlamak istediğinizde, soyut sınıfları kullanın.

Tamamen ilgisiz sınıflar için polimorfik davranışlar istediğinizde bir arayüz kullanın.

300 katlı bir bina inşa ediyorum

Binanın plan arayüzü

• Örneğin, Sunucu Uygulaması (I)

200 kata kadar inşa edilmiş bina - kısmen tamamlanmış --- soyut

• Kısmi uygulama, örneğin, genel ve HTTP sunucu uygulaması

Bina inşaatı tamamlandı - beton

• Tam uygulama, örneğin kendi sunucu uygulaması

Arayüz

• Uygulama hakkında hiçbir şey bilmiyoruz, sadece gereksinimler. Bir arayüze gidebiliriz.
• Her yöntem varsayılan olarak genel ve özettir
• % 100 saf bir soyut sınıftır
• Herkese açık beyan edersek, özel ve korunan beyan edemeyiz
• Özet beyan edersek nihai, statik, senkronize, katı ve yerel olarak beyan edemeyiz
• Her arayüz genel, statik ve nihai
• Serileştirme ve geçici uygulama uygulanamaz, çünkü arayüzde bir örnek oluşturamıyoruz
• Uçucu değildir, çünkü nihai
• Her değişken statiktir
• Arayüz içindeki bir değişkeni bildirdiğimizde, bildirirken değişkenleri başlatmamız gerekir
• Örnek ve statik bloğa izin verilmiyor

Öz

• Kısmi uygulama
• Soyut bir yöntemi var. Ek olarak, beton kullanır
• Soyut sınıf yöntem değiştiricileri için kısıtlama yoktur
• Soyut sınıf değişken değiştiricileri için kısıtlama yoktur
• Özet hariç diğer değiştiricileri açıklayamayız
• Değişkenleri başlatmak için herhangi bir kısıtlama yoktur

DurgaJobs Web Sitesinden Alınmıştır

Bu soru üzerinde tekrar çalışalım:

Bilmeniz gereken ilk şey, 1/1 ve 1 * 1'in aynı sonuç verdiği, ancak çarpma ve bölmenin aynı olduğu anlamına gelmez. Açıkçası, bazı iyi ilişkileri var, ama ikinizin de farklı olduğuna dikkat edin.

Ana farklılıkları göstereceğim ve geri kalanı zaten açıklandı:

Soyut sınıflar, bir sınıf hiyerarşisini modellemek için kullanışlıdır. Herhangi bir gereksinime ilk bakışta, tam olarak neyin inşa edileceği konusunda kısmen açıkız , ancak neyin inşa edileceğini biliyoruz . Ve böylece soyut sınıflarınız temel sınıflarınızdır.

Arayüzler, diğer hiyerarşinin veya sınıfların ne yapabileceğimi bilmesini sağlamak için kullanışlıdır. Ve bir şey yapabileceğimi söylediğinde, bu kapasiteye sahip olmalısın. Arayüzler, bir sınıfın aynı işlevleri yerine getirmesini zorunlu olarak işaretleyecektir.

Aslında oldukça basit.

Bir arayüzü sadece soyut yöntemlere izin verilen ve başka hiçbir şeye sahip olmayan bir sınıf olarak düşünebilirsiniz.

Bu yüzden bir arabirim sadece "bildirebilir" ve sınıfın sahip olmasını istediğiniz davranışı tanımlayamaz.

Soyut bir sınıf, sınıfın sahip olmasını istediğiniz davranışı tanımlamanın yanı sıra (soyut yöntemleri kullanarak) hem bildirmenizi (soyut yöntemler kullanarak) yapmanızı sağlar.

Düzenli bir sınıf, yalnızca sınıfın sahip olmasını istediğiniz davranışı / eylemleri tanımlamanıza, tanımlamanıza olanak tanır.

Son bir şey,

Java'da birden çok arabirim uygulayabilirsiniz, ancak yalnızca bir tane genişletebilirsiniz (Soyut Sınıf veya Sınıf) ...

Bu, tanımlanmış davranışın mirasının her sınıfa yalnızca bir tanesine izin verecek şekilde kısıtlandığı anlamına gelir ... yani, A, B & C Sınıflarından kapsüllenmiş davranışı olan bir sınıf istiyorsanız, aşağıdakileri yapmanız gerekir: A sınıfı B'yi genişletir, C Sınıfı A'yı genişletir. birden fazla miras için yol hakkında biraz yuvarlak ...

Diğer taraftan arayüzler basitçe şunları yapabilir: C arayüzü A, B'yi uygular

Yani aslında Java, sadece "beyan edilen davranış" yani arayüzlerde birden fazla kalıtım ve tanımlanmış davranış ile sadece tek kalıtım destekler .. tarif ettiğim şekilde yuvarlak yapmak sürece ...

Umarım bu mantıklıdır.

Arayüz ile soyut sınıf karşılaştırması yanlıştır. Bunun yerine iki karşılaştırma daha olmalı: 1) arabirime karşı sınıfa ve 2) özetle son sınıfa .

Arayüz ve Sınıf

Arayüz iki nesne arasındaki bir sözleşmedir. Örneğin, ben bir Postacıyım ve sen teslim edeceksin. Teslimat adresinizi bilmenizi bekliyorum. Birisi bana bir Paket verdiğinde, teslimat adresini bilmek zorundadır:

interface Package {
  String address();
}

Sınıf , sözleşmeye uyan bir grup nesnedir. Örneğin, "Kutu" grubundan bir kutuyum ve Postacı'nın gerektirdiği sözleşmeye uyuyorum. Aynı zamanda diğer sözleşmelere de uyuyorum:

class Box implements Package, Property {
  @Override
  String address() {
    return "5th Street, New York, NY";
  }
  @Override
  Human owner() {
    // this method is part of another contract
  }
}

Soyut ve Final

Soyut sınıf eksik nesneler grubudur. Kullanılamazlar, çünkü bazı parçaları kaçırırlar. Örneğin, soyut bir GPS tanıma kutusuyum - haritadaki konumumu nasıl kontrol edeceğimi biliyorum:

abstract class GpsBox implements Package {
  @Override
  public abstract String address();
  protected Coordinates whereAmI() {
    // connect to GPS and return my current position
  }
}

Bu sınıf, başka bir sınıf tarafından miras alınırsa / genişletilirse, çok yararlı olabilir. Ama kendi başına - işe yaramaz, çünkü nesneleri olamaz. Soyut sınıflar, son sınıfların unsurları olabilir.

Son sınıf , kullanılabilen ancak değiştirilemeyen bir grup tam nesnedir. Nasıl çalışacaklarını ve ne yapacaklarını tam olarak biliyorlar. Örneğin, her zaman yapımı sırasında belirtilen adrese giden bir Kutu'yum:

final class DirectBox implements Package {
  private final String to;
  public DirectBox(String addr) {
    this.to = addr;
  }
  @Override
  public String address() {
    return this.to;
  }
}

Java veya C ++ gibi çoğu dilde, ne soyut ne de final olmak üzere sadece bir sınıfa sahip olmak mümkündür . Böyle bir sınıf miras alınabilir ve somutlaştırılabilir. Ancak bunun kesinlikle nesne yönelimli paradigmaya uygun olduğunu düşünmüyorum.

Yine, arayüzleri soyut sınıflarla karşılaştırmak doğru değildir.

Kısacası farklar şunlardır:

Arayüz ve Soyut Sınıf Arasındaki Sözdizimsel Farklılıklar :

1. Soyut bir sınıfın yöntemleri ve üyeleri herhangi bir görünürlüğe sahip olabilir. Bir arabirimin tüm yöntemleri herkese açık olmalıdır . // Artık Java 9'dan geçerli değil
2. Bir Soyut Sınıfın somut bir çocuk sınıfı, tüm soyut yöntemleri tanımlamalıdır. Bir Abstract alt sınıfının soyut yöntemleri olabilir. Başka bir arabirimi genişleten bir arabirimin, üst arabirimden devralınan yöntemler için varsayılan uygulama sağlaması gerekmez.
3. Bir alt sınıf yalnızca bir sınıfı genişletebilir. Bir arayüz birden fazla arayüzü genişletebilir. Bir sınıf birden fazla arabirim uygulayabilir.
4. Bir alt sınıf, aynı veya daha az kısıtlayıcı görünürlüğe sahip soyut yöntemleri tanımlayabilirken, bir arabirimi uygulayan sınıfın tüm arabirim yöntemlerini genel olarak tanımlaması gerekir.
5. Özet Sınıflar yapıcılara sahip olabilirler fakat arayüzlere sahip olamazlar .
6. Java 9'daki arabirimlerin özel statik yöntemleri vardır.

Şimdi Arayüzlerde:

public static- desteklenir
public abstract- desteklenir
public default- desteklenir
private static- desteklenir
private abstract- derleme hatası
private default- derleme hatası
private- desteklenir

Tek fark, birinin birden fazla mirasa katılabilmesi ve diğerinin yapamamasıdır.

Arayüz tanımı zamanla değişti. Bir arabirimin yalnızca yöntem bildirimleri olduğunu ve yalnızca sözleşmeler olduğunu düşünüyor musunuz? Statik son değişkenler ve Java 8'den sonraki varsayılan tanımlar ne olacak?

Çoklu kalıtımla ilgili elmas sorunu nedeniyle Java'ya arabirimler tanıtıldı ve aslında yapmak istedikleri şey bu.

Arayüzler, çoklu kalıtım probleminden kurtulmak için oluşturulan ve soyut metotlara, varsayılan tanımlara ve statik nihai değişkenlere sahip olabilen yapılardır.

Bkz Java onlar sadece sözleşmeler olması amaçlanmıştır arayüzleri statik nihai değişkenleri izin vermez Neden? .

Arayüz: Döndür (Sola Dön, Sağa Dön.)

Soyut Sınıf: Tekerlek.

Sınıf: Direksiyon, Tekerlekten türetilir, Arayüz Dönüşünü ortaya çıkarır

Biri, çok çeşitli şeylerde sunulabilecek davranışı kategorize etmek için, diğeri de şeylerin ontolojisini modellemek içindir.

Birden fazla sınıf tarafından kullanılabilecek bazı yaygın yöntemleriniz varsa soyut sınıflar için gidin. Başka sınıflar belirli bir plan takip etmek istiyorsanız arayüzler için gidin.

Aşağıdaki örnekler bunu göstermektedir.

Java'da soyut sınıf:

abstract class animals
{
    // They all love to eat. So let's implement them for everybody
    void eat()
    {
        System.out.println("Eating...");
    }
    // The make different sounds. They will provide their own implementation.
    abstract void sound();
}

class dog extends animals
{
    void sound()
    {
        System.out.println("Woof Woof");
    }
}

class cat extends animals
{
    void sound()
    {
        System.out.println("Meoww");
    }
}

Java'da bir arayüz uygulaması aşağıdadır:

interface Shape
{
    void display();
    double area();
}

class Rectangle implements Shape 
{
    int length, width;
    Rectangle(int length, int width)
    {
        this.length = length;
        this.width = width;
    }
    @Override
    public void display() 
    {
        System.out.println("****\n* *\n* *\n****"); 
    }
    @Override
    public double area() 
    {
        return (double)(length*width);
    }
} 

class Circle implements Shape 
{
    double pi = 3.14;
    int radius;
    Circle(int radius)
    {
        this.radius = radius;
    }
    @Override
    public void display() 
    {
        System.out.println("O"); // :P
    }
    @Override
    public double area() 
    { 
        return (double)((pi*radius*radius)/2);
    }
}

Özetle Bazı Önemli Anahtar Noktalar:

1. Java arayüzünde bildirilen değişkenler varsayılan olarak son şeklindedir. Soyut sınıfların final olmayan değişkenleri olabilir.

2. Java arabiriminde bildirilen değişkenler varsayılan olarak statiktir. Soyut sınıflar statik olmayan değişkenlere sahip olabilir.

3. Java arabiriminin üyeleri varsayılan olarak herkese açıktır. Bir Java soyut sınıfı, özel, korumalı vb. Sınıf üyelerinin olağan lezzetlerine sahip olabilir.

Birçok genç geliştirici, arayüzleri, soyut ve somut sınıfları aynı şeyin küçük varyasyonları olarak düşünme hatasını yapar ve bunlardan birini sadece teknik gerekçelerle seçer: Birden fazla mirasa ihtiyacım var mı? Ortak yöntemler koymak için bir yere ihtiyacım var mı? Sadece somut bir sınıftan başka bir şeyle uğraşmam gerekir mi? Bu yanlış ve bu sorularda gizli ana sorun: "Ben" . Kendiniz için kod yazdığınızda, kendi başınıza, kodunuz üzerinde veya kodunuzla çalışan diğer mevcut veya gelecekteki geliştiricileri nadiren düşünürsünüz.

Arayüzler ve soyut sınıflar, görünüşe göre teknik açıdan benzer olsalar da, tamamen farklı anlamlara ve amaçlara sahiptirler.

özet

1. Bir arayüz , bazı uygulamaların sizin için yerine getireceği bir sözleşmeyi tanımlar .

2. Soyut bir sınıf varsayılan bir davranış sağlar o senin uygulama yeniden kullanabilirsiniz.

Alternatif özet

1. Arayüz genel API'leri tanımlamak içindir
2. Soyut bir sınıf, dahili kullanım ve SPI'ları tanımlamak içindir

Uygulama ayrıntılarını gizlemenin önemi hakkında

Somut bir sınıf asıl işi çok özel bir şekilde yapar. Örneğin, bir kullanıcı ArrayList, nesnelerin listesini hızlı rasgele erişim, yineleme ve yerinde değişiklikler sunan, ancak eklemelerde, silmelerde ve hatta bazen eklemelerde korkunç bir şekilde saklamak için bitişik bir bellek alanı kullanır; bu arada, a LinkedList, hızlı yineleme, yerinde değişiklikler ve ekleme / silme / ekleme sunan, ancak rastgele erişimde korkunç olan bir nesne listesini saklamak için çift bağlantılı düğümler kullanır. Bu iki tür liste farklı kullanım durumları için optimize edilmiştir ve bunları nasıl kullanacağınız çok önemlidir. Performansı, yoğun bir şekilde etkileşimde bulunduğunuz bir listeden çıkarmaya çalıştığınızda ve liste türünü seçmek size kalmıştır, hangisini somutlaştırdığınızı dikkatlice seçmelisiniz.

Öte yandan, bir listenin üst düzey kullanıcıları, listenin gerçekte nasıl uygulandığını gerçekten umursamazlar ve bu ayrıntılardan yalıtılmalıdırlar. Java'nın Listarayüzü açığa vurmadığını, ancak şu anda Listaslında olan somut bir sınıfı olduğunu hayal edelim LinkedList. Tüm Java geliştiricileri kodlarını uygulama ayrıntılarına uyacak şekilde uyarlamışlardı: rastgele erişimden kaçının, erişimi hızlandırmak için bir önbellek ekleyin veya yalnızca ArrayListkendileriyle yeniden uygulayın, ancak Listyalnızca gerçekte çalışan diğer tüm kodlarla uyumsuz olurdu . Bu korkunç olurdu ... Ama şimdi Java ustalarının aslında bağlantılı bir listenin çoğu gerçek kullanım durumu için korkunç olduğunu fark ettiklerini ve sadece bir dizi listesine geçmeye karar verdiklerini hayal edinListkullanılabilir sınıf. Bu, dünyadaki her Java programının performansını etkiler ve insanlar bu programdan memnun olmazlar. Ve asıl suçlu, uygulama detaylarının mevcut olması ve geliştiricilerin bu detayların güvenebilecekleri kalıcı bir sözleşme olduğunu varsaymalarıydı. Bu nedenle uygulama ayrıntılarını gizlemek ve yalnızca soyut bir sözleşme tanımlamak önemlidir. Bu bir arayüzün amacıdır: bir programın ne tür bir girişi kabul ettiğini ve ne tür bir çıktı beklendiğini tanımlayın, programcıları gelecekteki herhangi bir güncellemeyle değişebilecek iç detaylara uyacak şekilde kodlarını değiştirmeye teşvik edecek tüm cesaretleri ortaya çıkarmadan .

Soyut bir sınıf, arayüzler ve somut sınıflar arasında ortadadır. Uygulamaların ortak veya sıkıcı kodları paylaşmasına yardımcı olması gerekiyor. Örneğin, yinelemede olduğu gibi tekrarlanan ve karşılaştırıldığı gibi, tekrar boyutuna göre boyut 0 AbstractCollectioniçin temel uygulamalar sağlar . Bu, uygulamaların aralarında ayrım yapan önemli parçalara odaklanmasını sağlar: Verilerin gerçekte nasıl depolanacağı ve alınacağı.isEmptycontainsaddAlladd

API'lar ve SPI'lar

Arabirimler, kodun farklı bölümleri arasındaki düşük bütünlüklü ağ geçitleridir . Bir şey dahili olarak değiştiğinde her kütüphane kullanıcısını bozmadan kütüphanelerin var olmasına ve gelişmesine izin verir. Buna Uygulama Programlama Sınıfları değil, Uygulama Programlama Arayüzü denir . Daha küçük ölçekte, farklı modülleri iyi belgelenmiş arabirimlerle ayırarak birden fazla geliştiricinin büyük ölçekli projelerde başarılı bir şekilde işbirliği yapmasına izin verir.

Soyut sınıflar, bir arabirim uygulanırken, bazı düzeyde uygulama ayrıntılarını varsayarak , yüksek uyum sağlayan yardımcılardır . Alternatif olarak, soyut sınıflar SPI'leri, Servis Sağlayıcı Arayüzlerini tanımlamak için kullanılır.

Bir API ve bir SPI arasındaki fark anlaşılır, ancak önemlidir: bir API için odak noktası onu kimin kullandığına ve bir SPI için odak noktası onu kimin uyguladığına odaklanır .

Bir API'ya yöntem eklemek kolaydır, API'nin mevcut tüm kullanıcıları derlemeye devam eder. Her hizmet sağlayıcısının (somut uygulama) yeni yöntemleri uygulaması gerekeceğinden, bir SPI'ya yöntem eklemek zordur. Bir SPI tanımlamak için arabirimler kullanılıyorsa, SPI sözleşmesi her değiştiğinde bir sağlayıcı yeni bir sürüm yayınlamak zorundadır. Bunun yerine soyut sınıflar kullanılırsa, yeni yöntemler ya mevcut soyut yöntemler açısından tanımlanabilir ya da throw not implemented exceptionen azından bir hizmet uygulamasının eski bir sürümünün hala derlenip çalışmasına izin verecek boş saplamalar olarak tanımlanabilir .

Java 8 ve varsayılan yöntemler hakkında bir not

Java 8, arabirimler ve soyut sınıflar arasındaki çizgiyi daha da bulanıklaştıran arabirimler için varsayılan yöntemler sunmasına rağmen, bu, uygulamaların kodu yeniden kullanabilmesi için değil, hem API hem de SPI olarak hizmet veren arabirimleri değiştirmeyi kolaylaştırmak için (veya soyut sınıflar yerine SPI'leri tanımlamak için yanlış kullanılır).

Hangisini kullanmalıyım?

1. Is şey gerekiyordu alenen kullanılan kodun diğer bölümlerinde, veya başka harici koduna göre? Uygulama ayrıntılarını, şeyin genel davranışı olan genel soyut sözleşmeden gizlemek için bir arayüz ekleyin.
2. Bir şey ortak bir çok kod ile birden fazla uygulama olması gereken bir şey mi? Hem bir arayüz hem de soyut, eksik bir uygulama yapın.
3. Hiç tek bir uygulama olacak mı ve başka hiç kimse bunu kullanmayacak mı? Sadece somut bir sınıf yapın.
   1. "Şimdiye kadar" uzun zaman, güvenli oynayabilir ve yine de üstüne bir arayüz ekleyebilirsiniz.

Bir sonuç: tersi genellikle yanlış yapılır: bir şey kullanırken , her zaman gerçekten ihtiyacınız olan en genel sınıfı / arabirimi kullanmaya çalışın. Diğer bir deyişle, ArrayList theList = new ArrayList()aslında bir dizi listesi olmasına çok güçlü bir bağımlılığınız yoksa ve başka bir liste türü sizin için kesmeyeceği sürece değişkenlerinizi olarak bildirmeyin . List theList = new ArrayListBunun yerine kullanın veya Collection theCollection = new ArrayListbaşka bir koleksiyon türü değil, bir liste olduğu gerçeği bile önemli değildir.

Aslında asıl sorunun cevabı değil, aralarındaki farkın cevabını bulduğunuzda, ne zaman kullanacağınız her ikilemi gireceksiniz: Arayüzler veya soyut sınıflar ne zaman kullanılır? İkisi ne zaman kullanılır?

OOP bilgisini sınırladım, ancak arayüzleri dilbilgisinde bir sıfatın eşdeğeri olarak görmek şimdiye kadar benim için çalıştı (bu yöntem sahte ise beni düzeltin!). Örneğin, arabirim adları bir sınıfa verebileceğiniz öznitelikler veya yetenekler gibidir ve bir sınıf bunlardan çoğuna sahip olabilir: ISerializable, ICountable, IList, ICacheable, IHappy, ...

Kalıtım iki amaç için kullanılır:

• Bir nesnenin üst tür veri üyelerini ve yöntem uygulamalarını kendi olarak görmesine izin vermek.

• Süper tip nesneye bir başvuru bekleyen kod tarafından bir türdeki nesnelere başvuru yapılmasına izin vermek için.

Genelleştirilmiş çoklu kalıtımın desteklendiği dillerde / çerçevelerde, bir türü "arabirim" veya "soyut sınıf" olarak sınıflandırmak için genellikle çok az ihtiyaç vardır. Bununla birlikte, popüler diller ve çerçeveler, bir türün, bir türün rasgele sayıda başka türün yerine geçmesine izin verse de, başka bir türün veri üyelerini veya yöntem uygulamalarını kendi olarak görmesine izin verecektir.

Soyut sınıfların veri üyeleri ve yöntem uygulamaları olabilir, ancak yalnızca diğer sınıflardan miras alınmayan sınıflar tarafından miras alınabilir. Arabirimler, bunları uygulayan türler üzerinde neredeyse hiçbir kısıtlama getirmez, ancak veri üyelerini veya yöntem uygulamalarını içeremez.

Türlerin birçok farklı şeyin yerine geçmesinin yararlı olduğu zamanlar vardır; nesnelerin ebeveyn türü veri üyelerini ve yöntem uygulamalarını kendileri olarak görmelerinin yararlı olduğu başka zamanlar da vardır. Arabirimler ve soyut sınıflar arasında bir ayrım yapmak, bu yeteneklerin her birinin en alakalı olduğu durumlarda kullanılmasına izin verir.

Anahtar noktaları:

• Soyut sınıf her ikisi de özellik, Veri alanları, Yöntemler (tam / eksik) olabilir.
• Yöntem veya Özellikler türetilmiş sınıfta geçersiz kılınması gereken soyut anahtar sözcükte tanımlanırsa (sıkı sıkıya bağlı işlevsellik olarak çalışır)
• Soyut sınıftaki yöntem veya özellikler için soyut anahtar kelime tanımlarsanız, yöntem gövdesini tanımlayamaz ve özellikler için değer alamaz / ayarlayamazsınız ve bu türetilmiş sınıfta geçersiz kılınmalıdır.
• Soyut sınıf birden fazla mirası desteklemez.
• Soyut sınıf Yapıcılar içerir.
• Soyut bir sınıf subs, fonksiyonlar, özellikler için erişim değiştiricileri içerebilir.
• Sadece soyut sınıfın tam üyesi statik olabilir.
• Bir arabirim yalnızca başka bir arabirimden miras alabilir ve soyut bir sınıf olarak başka bir soyut sınıftan veya başka bir arabirimden miras alabileceği soyut bir sınıftan miras alamaz.

Avantajı:

• Tüm alt sınıfları aynı hiyerarşileri veya standartları sürdürmeye zorlayan bir tür sözleşmedir.
• Çeşitli uygulamalar aynı türdeyse ve ortak davranış veya durum kullanıyorsa, soyut sınıfın kullanılması daha iyidir.
• Soyut bir sınıfa yeni bir yöntem eklersek, varsayılan uygulamayı sağlama seçeneğimiz vardır ve bu nedenle mevcut kod düzgün çalışabilir.
• Arayüzden daha hızlı yürütülmesine izin verir. (Arayüz İlgili sınıflarda gerçek yöntemi bulmak için daha fazla zaman gerektirir.)
• Sıkı ve gevşek kuplaj için kullanılabilir.

ayrıntıları burada bulabilirsiniz ... http://pradeepatkari.wordpress.com/2014/11/20/interface-and-abstract-class-in-c-oops/

Özetlemek için en kısa yol, bir interface:

1. Tamamen soyut, dışında defaultve staticyöntemler; defaultve staticyöntemleri için tanımları (yöntem imzaları + uygulamalar) varken , diğer yöntemler için yalnızca bildirimleri (yöntem imzaları) vardır.
2. Sınıflardan daha laxer kurallarına tabidir (bir sınıf birden fazla interfaces uygulayabilir ve bir interfacekutu birden fazla interfaces'den miras alabilir ). Tüm değişkenler, belirtilmiş olsun public static finalya da olmasın, dolaylı olarak sabittir . Tüm üyeler dolaylı publicolarak belirtilmiş olsun ya da olmasın.
3. Genellikle uygulayıcı sınıfın belirtilen özelliklere sahip olacağını ve / veya aynı arabirimi uygulayan diğer sınıflarla uyumlu olacağını garanti etmek için kullanılır.

Bu arada, bir abstractsınıf:

1. Tamamen soyuttan tam uygulamaya kadar, bir veya daha fazla abstractyönteme sahip olma eğilimi olan her yerde . Hem bildirimleri hem de tanımları içerebilir ve bildirimler olarak işaretlenir abstract.
2. Tam teşekküllü bir sınıf ve diğer sınıfları yöneten kurallara tabidir (yalnızca bir sınıftan miras alınabilir), somutlaştırılamaması koşuluyla (tam olarak uygulandığının garantisi yoktur). Sabit olmayan üye değişkenleri olabilir. Üye erişim denetimi uygularken üye kısıtlayan Can protected, privateveya özel paketi (belirtilmemiş).
3. Genellikle ya birden çok alt sınıf tarafından paylaşılabilecek kadar çok uygulama sağlamak ya da programcının sağlayabildiği kadar çok uygulama sağlamak için kullanılır.

Biz tek cümleye bütün aşağı kaynatın istiyorsanız Veya: Bir interfaceuygulayan sınıf nedir vardır , ama bir abstractsınıf alt sınıf ne olduğunu .

Mantıklı bir fark daha eklemek istiyorum. Örneğin, binlerce satır kod içeren bir çerçeveniz var. Şimdi, bir EnhanUI () yöntemi kullanarak kod boyunca yeni bir özellik eklemek istiyorsanız, o yöntemi arabirim yerine soyut sınıfta eklemek daha iyidir. Çünkü, bu yöntemi bir arabirime eklerseniz, uygulanan tüm sınıfta uygulamanız gerekir, ancak yöntemi soyut sınıfta eklerseniz durum böyle değildir.

Basit ama net bir cevap vermek, bağlamı ayarlamanıza yardımcı olur: her ikisini de tam uygulamalar sağlamak istemediğinizde kullanırsınız.

Öyleyse temel fark, bir arayüzün hiç uygulaması olmadığıdır (sadece gövdesiz yöntemler), soyut sınıflar da bir gövdeye sahip üyelere ve yöntemlere sahip olabilir, yani kısmen uygulanabilir.

Gerçek uygulama adına soyut sınıf ve arayüz arasındaki farklar.

Arayüz : Bir anahtar kelimedir ve bir nesnenin şablonunu veya mavi baskısını tanımlamak için kullanılır ve tüm alt sınıfların uygulamada olduğu gibi aynı prototipi izlemesini zorlar, tüm alt sınıflar, bu şarttır.

Arabirimi kullanmamız gereken diğer kullanım durumlarından bazıları.

Arayüz aracılığıyla yapılan iki harici nesne (uygulamamızda üçüncü taraf entegrasyonu) arasındaki iletişim Arayüz burada Sözleşme olarak çalışır.

Abstract Class: Abstract, bu bir anahtar kelimedir ve bu anahtar kelimeyi herhangi bir sınıftan önce kullandığımızda o zaman soyut sınıf haline gelir.Özellikle şablonu ve tüm nesneler tarafından takip edilen bir nesnenin varsayılan işlevselliğini tanımlamamız gerektiğinde kullanılır. alt sınıflar ve bu şekilde gereksiz kodu kaldırır ve soyut sınıfı kullanabileceğimiz bir başka kullanım örneği , başka hiçbir sınıfın doğrudan sınıfın bir nesnesini somutlaştırmasını istemeyiz, sadece türetilmiş sınıflar işlevselliği kullanabilir.

Soyut Sınıf Örneği:

 public abstract class DesireCar
  {

 //It is an abstract method that defines the prototype.
     public abstract void Color();

  // It is a default implementation of a Wheel method as all the desire cars have the same no. of wheels.   
 // and hence no need to define this in all the sub classes in this way it saves the code duplicasy     

  public void Wheel() {          

               Console.WriteLine("Car has four wheel");
                }
           }


    **Here is the sub classes:**

     public class DesireCar1 : DesireCar
        {
            public override void Color()
            {
                Console.WriteLine("This is a red color Desire car");
            }
        }

        public class DesireCar2 : DesireCar
        {
            public override void Color()
            {
                Console.WriteLine("This is a red white Desire car");
            }
        }

Arayüz Örneği:

  public interface IShape
        {
          // Defines the prototype(template) 
            void Draw();
        }


  // All the sub classes follow the same template but implementation can be different.

    public class Circle : IShape
    {
        public void Draw()
        {
            Console.WriteLine("This is a Circle");
        }
    }

    public class Rectangle : IShape
    {
        public void Draw()
        {
            Console.WriteLine("This is a Rectangle");
        }
    }

Arayüz ve soyut sınıf arasında net bir fark bulabilirsiniz .

Arayüz

• Arayüz yalnızca soyut yöntemler içerir.
• Arayüzü uygularken kullanıcıları tüm yöntemleri uygulamaya zorlayın.
• Yalnızca nihai ve statik değişkenler içerir.
• Arayüz anahtar sözcüğünü kullanarak bildirin.
• Bir arabirimin tüm yöntemleri herkese açık olarak tanımlanmalıdır.
• Bir arabirim genişletilebilir veya bir sınıf birden çok başka arabirim uygulayabilir.

Soyut sınıf

• Soyut sınıf, soyut ve soyut olmayan yöntemleri içerir.

• Kullanıcıları, soyut sınıfı devralındığında tüm yöntemleri uygulamaya zorlamaz.

• İlkel ve ilkel olmayan her türlü değişkeni içerir

• Soyut anahtar kelime kullanarak beyan edin.

• Soyut bir sınıfın yöntemleri ve üyeleri herhangi bir görünürlükle tanımlanabilir.

• Çocuk sınıfı yalnızca tek bir sınıfı (soyut veya somut) genişletebilir.

Soyut sınıf, nesnesi oluşturulamayan veya somutlaştırılamayan bir sınıftır. Soyut bir yöntem sınıfı soyutlaştırır. Soyut sınıfta bildirilen yöntemleri geçersiz kılmak için bir soyut sınıfın miras alınması gerekir. Erişim belirteçlerinde herhangi bir kısıtlama yoktur. Soyut bir sınıfın içinde yapıcı ve diğer somut (soyut olmayan yöntemler) yöntemler olabilir ancak arayüz olamaz.

Bir arayüz, bir plan / yöntem şablonudur. (Örneğin, bir kağıt üzerinde bir ev verilir (arayüz evi) ve farklı mimarlar fikirlerini (ev arayüzünü uygulayan mimar sınıfları) inşa etmek için kullanırlar. soyut yöntemler, varsayılan yöntemler, statik yöntemler, son değişkenler ve iç içe sınıflar.Tüm üyelerin son ya da genel, korumalı ve özel erişim belirteçlerine izin verilmez.Nesnenin yaratılmasına izin verilmez. arabirimi uygulamak ve ayrıca arabirimde bildirilen soyut yöntemi geçersiz kılmak için: Bir arabirim gevşek birleştirme (dinamik polimorfizm / dinamik bağlanma) için iyi bir örnektir. Bir arabirim polimorfizm ve soyutlamayı uygular. uygulayan sınıf.bir otomobil şirketi ve bazı özelliklerin ürettiği tüm araba için aynı olmasını istiyor, böylece şirket bu özelliklere sahip olacak bir arayüz aracı yapacak ve farklı araba sınıfları (Maruti Suzkhi, Maruti 800 gibi) geçersiz kılacak bu özellikler (fonksiyonlar).

Zaten soyut sınıfımız olduğunda neden arayüz oluşturuyoruz? Java yalnızca çok düzeyli ve hiyerarşik kalıtımı destekler, ancak arabirim yardımıyla çoklu kalıtım uygulayabiliriz.

Pratiklik açısından (JAVA), soyut sınıf ve arayüz arasındaki en büyük fark, Soyut sınıfın devlet tutabilmesidir. Bekletme durumu dışında, Arayüz ile de dinlenme işlemleri gerçekleştirebiliriz.

Bir arayüzde tüm yöntemler sadece tanımlar olmalı, tek bir yöntem uygulanmamalıdır.

Ancak soyut bir sınıfta sadece tanım ile soyut bir yöntem olmalı, ancak diğer yöntemler de uygulama ile soyut sınıfta olabilir ...

Arayüz ve soyut sınıf arasında çeşitli yapısal / sözdizimsel farklarımız vardır. Bazı farklılıklar

[1] Senaryoya dayalı fark :

Soyut sınıflar, kullanıcıyı üst sınıf nesnesi oluşturmak için kısıtlamak istediğimizde senaryolarda kullanılır VE gelecekte daha fazla soyut yöntem ekleneceğine inanıyoruz.

Sağlanacak artık soyut bir yöntem kalmayacağından emin olduğumuzda arayüz kullanılmalıdır. Sonra sadece bir arayüz yayınlanır.

[2] Kavramsal fark :

EVET soyut sınıf yaparsa ve HAYIR ise Arayüz yaparsa, "Gelecekte daha soyut yöntemler sunmamız gerekiyor mu?"

(Java 1.7'ye kadar en uygun ve geçerli)

genellikle Soyut sınıf bir şey çekirdek için kullanılan ama periferik eklemek için kullanılan arayüz.

araç için temel tip oluşturmak istediğinizde soyut sınıfı kullanmalısınız, ancak temel araç konseptinin bir parçası olmayan bazı işlevler veya özellikler eklemek istiyorsanız, arabirim kullanmalısınız, örneğin "ToJSON ()" işlevini eklemek istiyorsunuz .

arayüz soyut sınıftan çok geniş bir soyutlama yelpazesine sahiptir. argümanları iletirken bunu görebilirsiniz. şu örneğe bakın:

aracı argüman olarak kullanırsanız, türetilmiş tiplerinden birini kullanabilirsiniz (otobüs veya araba ile aynı kategori-sadece araç kategorisi). ancak IMoveable arayüzünü argüman olarak kullandığınızda daha fazla seçeneğiniz olur.