Soyut bir sınıf, somutlaştırılamayan bir sınıftır. Soyut bir sınıf, devralınabilen bir alt sınıf oluşturarak kullanılır örneği. Soyut bir sınıf, miras kalan alt sınıf için birkaç şey yapar:
- Devralınan alt sınıf tarafından kullanılabilecek yöntemleri tanımlayın.
- Devralma alt sınıfının uygulaması gereken soyut yöntemleri tanımlayın.
- Alt sınıfın diğer tüm alt sınıflarla değiştirilmesine izin veren ortak bir arabirim sağlayın.
İşte bir örnek:
abstract public class AbstractClass
{
abstract public void abstractMethod();
public void implementedMethod() { System.out.print("implementedMethod()"); }
final public void finalMethod() { System.out.print("finalMethod()"); }
}
"AbstractMethod ()" öğesinin herhangi bir yöntem gövdesi olmadığına dikkat edin. Bu nedenle, aşağıdakileri yapamazsınız:
public class ImplementingClass extends AbstractClass
{
// ERROR!
}
Uygulayan bir yöntem yok abstractMethod()! Yani JVM'nin böyle bir şey olduğunda ne yapması gerektiğini bilmesi mümkün değilnew ImplementingClass().abstractMethod() .
İşte doğru ImplementingClass.
public class ImplementingClass extends AbstractClass
{
public void abstractMethod() { System.out.print("abstractMethod()"); }
}
implementedMethod()Veya tanımlamak zorunda olmadığınıza dikkat edin finalMethod(). Tarafından zaten tanımlanmışlardı AbstractClass.
İşte başka bir doğru ImplementingClass.
public class ImplementingClass extends AbstractClass
{
public void abstractMethod() { System.out.print("abstractMethod()"); }
public void implementedMethod() { System.out.print("Overridden!"); }
}
Bu durumda, geçersiz kıldınız implementedMethod().
Ancak, finalanahtar kelime nedeniyle aşağıdakiler mümkün değildir.
public class ImplementingClass extends AbstractClass
{
public void abstractMethod() { System.out.print("abstractMethod()"); }
public void implementedMethod() { System.out.print("Overridden!"); }
public void finalMethod() { System.out.print("ERROR!"); }
}
Uygulanması çünkü bunu yapamaz finalMethod()içinde AbstractClassnihai uygulama olarak işaretlenir finalMethod(): hayır diğer uygulamalar izin verilecektir, asla.
Şimdi yapabilirsiniz ayrıca iki kez soyut bir sınıf uygulamak:
public class ImplementingClass extends AbstractClass
{
public void abstractMethod() { System.out.print("abstractMethod()"); }
public void implementedMethod() { System.out.print("Overridden!"); }
}
// In a separate file.
public class SecondImplementingClass extends AbstractClass
{
public void abstractMethod() { System.out.print("second abstractMethod()"); }
}
Şimdi bir yere başka bir yöntem yazabilirsiniz.
public tryItOut()
{
ImplementingClass a = new ImplementingClass();
AbstractClass b = new ImplementingClass();
a.abstractMethod(); // prints "abstractMethod()"
a.implementedMethod(); // prints "Overridden!" <-- same
a.finalMethod(); // prints "finalMethod()"
b.abstractMethod(); // prints "abstractMethod()"
b.implementedMethod(); // prints "Overridden!" <-- same
b.finalMethod(); // prints "finalMethod()"
SecondImplementingClass c = new SecondImplementingClass();
AbstractClass d = new SecondImplementingClass();
c.abstractMethod(); // prints "second abstractMethod()"
c.implementedMethod(); // prints "implementedMethod()"
c.finalMethod(); // prints "finalMethod()"
d.abstractMethod(); // prints "second abstractMethod()"
d.implementedMethod(); // prints "implementedMethod()"
d.finalMethod(); // prints "finalMethod()"
}
bBir AbstractClasstür bildirmiş olsak da , görüntülendiğine dikkat edin "Overriden!". Biz örneği nesne aslında bir oldu olmasıdır ImplementingClass, kiminimplementedMethod() elbette geçersiz kılınmış olmasıdır. (Bunun polimorfizm olarak adlandırıldığını görmüş olabilirsiniz.)
Belirli bir alt sınıfa özgü bir üyeye erişmek istiyorsak, önce o alt sınıfa inmeliyiz:
// Say ImplementingClass also contains uniqueMethod()
// To access it, we use a cast to tell the runtime which type the object is
AbstractClass b = new ImplementingClass();
((ImplementingClass)b).uniqueMethod();
Son olarak, aşağıdakileri yapamazsınız:
public class ImplementingClass extends AbstractClass, SomeOtherAbstractClass
{
... // implementation
}
Bir seferde yalnızca bir sınıf genişletilebilir. Birden fazla sınıfı genişletmeniz gerekiyorsa, bunlar arayüz olmalıdır. Bunu yapabilirsiniz:
public class ImplementingClass extends AbstractClass implements InterfaceA, InterfaceB
{
... // implementation
}
İşte bir örnek arayüz:
interface InterfaceA
{
void interfaceMethod();
}
Bu temel olarak aynıdır:
abstract public class InterfaceA
{
abstract public void interfaceMethod();
}
Tek fark, ikinci yolun derleyicinin aslında bir arayüz olduğunu bilmemesidir. İnsanların yalnızca arayüzünüzü uygulamasını ve başkalarının uygulamasını istemiyorsanız bu yararlı olabilir. Bununla birlikte, genel bir başlangıç kuralı olarak, soyut sınıfınızda sadece soyut yöntemler varsa, muhtemelen bir arayüz yapmalısınız.
Aşağıdakiler yasa dışıdır:
interface InterfaceB
{
void interfaceMethod() { System.out.print("ERROR!"); }
}
Bir arabirime yöntem uygulayamazsınız. Bu, iki farklı arabirim uygularsanız, bu arabirimlerdeki farklı yöntemlerin çarpışamayacağı anlamına gelir. Bir arabirimdeki tüm yöntemler soyut olduğundan, yöntemi uygulamanız gerekir ve yönteminiz kalıtım ağacındaki tek uygulama olduğundan, derleyici yönteminizi kullanması gerektiğini bilir.
