Nesneye yönelik programlama kavramı içerisinde bulunan “soyutlama” kavramını işleyeceğimiz Java Abstract Class Nedir konu anlatımı içerisinde bir önceki konumuz olan kalıtım kavramına sıklıkla değineceğim. Bu yüzden eğer kalıtım konusu hakkında bir fikriniz yoksa önce Java’da Kalıtım konuma göz atabilirsiniz.
Java Abstract Class Nedir?
Kalıtım yaparken bir sınıf üzerinden sınıf türetiriz ve üst sınıf içerisindeki özellikleri alt sınıfta kullanmayı hedefleriz. Abstract özellikte sınıf ve metot tanımlaması gerçekleştirdiğimiz zaman bizlere avantaj sağlayacaktır.
Abstract (Soyut) sınıfların kullanımındaki amaç, nesne türetilirken şablon oluşturmaktır. Yani yukarıda bahsettiğim üzere kalıtım yaparak kullandığımız abstract sınıf özelliklerini override işlemine tabi tutarak yeniden tanımlayabiliriz. Örnek olarak Apple, Samsung, Huawei gibi markaları ele alalım. Bu örnek verdiğim markalarının birtakım ortak özellikleri ve birbirlerinden farklı özellikleri de bulunmaktadır. Hepsinin ortak noktasını düşünürsek hepsinin Akıllı telefon üreticisi olduğunu görürüz. Aralarındaki farklara ise işletim sistemleri, vergi hükümlülükleri gibi örnekler verebilirim.
Her zaman bahsettiğim üzere teorik bilgiler sıkıcı olsada elimiz az sonra tabiri caizse çamura bulaştırarak Java abstract class nedir sorusuna cevap bulmuş olacağız.
Java Abstract Class Kullanımı
Bir sınıf üzerinde soyutlama yapmak istediğimiz zaman içerisinde mutlaka bir soyut metot bulundurmamız gerekmektedir. Bir abstract tanımlaması için yazmamız gereken kod dizisi şu şekildedir;
public abstract class AbstractExample { // Üst Sınıf
// Sınıf İçeriği Buraya.
public abstract void AbstractMetot(); // Abstract Metot Tanımlaması.
}
class Abs extends AbstractExample{ // Üst Sınıftan Alt sınıf türedi.
@Override
public void AbstractMetot(){
// Abstract Metot Override Edildi.
}
}
Abstract tanımlaması basit bir işlem olsada bazı dikkat etmemiz noktalar bulunuyor bu noktalar ise şu şekildedir;
- Programımız içerisinde bir sınıf altında tanımladığımız bir metot soyut olarak tanımlandıysa, metodun bulunduğu sınıf da mutlaka abstract (soyut) olarak tanımlanması gerekmektedir.
- Soyut sınıf içerisine tanımlamasını yaptığımız abstract metot alt sınıf içerisinde override edilmezse, kod derleme esnasında hata ile karşılanılır.
Java abstract class nedir sorusuna cevap bulduğumuzu düşünüyorum ama elimizi biraz daha çamura daldırarak bir kaç örnek üzerinde Abstract Class kullanımını ele alalım.
Oluşturacağım ilk örnek üzerinde ekmek satışı gerçekleştiren iki market üzerinden hesaplama gerçekleştirecek temel bir soyutlama örneği kuralım. Bu örnek üzerinde uyguladığım aşamalar şu şekildedir;
#1 Öncelikle iki market için işlemlerimi aktaracağım BaseShopCalculatorManager isminde bir abstract sınıf ve sınıf içerisinde ekmek fiyatını hesaplayacak breadBuy isminde geriye değer döndürecek soyut bir metot oluşturdum.
public abstract class BaseShopCalculatorManager {
abstract double breadBuy(int howMuchBread); // Ekmek hesaplamasını yaptırtacağımız soyut metot tanımlaması.
}#2 Oluşturmuş olduğum üst sınıf üzerinden süpermarket ve normal market üzerinde farklı hesaplamalar gerçekleştirmek için iki adet alt sınıf tanımladım. Süpermarket üzerinde ekmek alacağımız zaman ekmek fiyatı 2.50 TL olarak belirlenecek.
public class SuperMarketCalculatorManager extends BaseShopCalculatorManager{
@Override
double breadBuy(int howMuchBread){
return howMuchBread*2.50;
}
}
#3 Süpermarket aksine market üzerinden ekmek almak istersek fiyatımız 1.75 TL olacaktır.
public class MarketCalculatorManager extends BaseShopCalculatorManager{
@Override
double breadBuy(int howMuchBread){
return howMuchBread*1.75;
}
}
#4 Bu tanımlamaları gerçekleştirdikten sonra CustomerManager sınıfı oluşturarak içerisine kullanıcıdan kaç ekmek almak istediğini klavyeden gireceği değer ile tanımladıktan sonra ilgili işlem sonucunu ekrana yazdıracak bir doTheShopping() metodu tanımladım.
import java.util.Scanner;
public class CustomerManager {
// Belirlenen sınıfa göre hesaplamalar yapmak istediğimiz için:
BaseShopCalculatorManager baseShopCalculatorManager;
Scanner scanner = new Scanner(System.in);
void doTheShopping(){
System.out.println("-------------------\n-> Ekmek Hesaplaması\n-------------------");
System.out.print("-> Kaç Ekmek Alacaksınız: ");
int x = scanner.nextInt();
System.out.println("-> Ekmek Fiyatı: "+baseShopCalculatorManager.breadBuy(x)/x+" TL");
System.out.println("-> Almış Olduğunuz "+ x +" Ekmek İçin Ödeyeceğiniz Fiyat: "+baseShopCalculatorManager.breadBuy(x)+" TL");
System.out.println("-------------------");
}
}
#5 İşlemlerimi Main sınıfım içerisinde çalıştırabilmek için gerekli sınıfları tanımladıktan sonra doTheShopping metodumu çağırarak işlemlerimi başlatıyorum.
public class Main {
public static void main(String[] args) {
CustomerManager customerManager = new CustomerManager();
customerManager.baseShopCalculatorManager = new SuperMarketCalculatorManager(); // Süpermarket için hesaplama yaptırtacağız.
// new olarak MarketCalculatorManager belirlemiş olsaydık o sınıfa göre hesaplama yaptırtacaktık.
customerManager.doTheShopping();
}
}
Kod Çıktısı:
Karmaşık olarak gözükebilir ama yazması oldukça zevkli ve projelerimize işlevsellik katan soyutlama kavramını daha iyi anlayabilmek için ilk örneğimiz olan çeşitli markaların telefon hesaplamalarını gerçekleştirecek örnek oluşturalım. Bu örneği oluştururken gerçekleştirdiğim aşamalar şu şekildedir;
#1 Çeşitli markaların özelliklerini tutmamız için BasePhoneManager isminde bir üst sınıf tanımlaması gerçekleştirerek bu sınıf üzerinde bazı işlemleri gerçekleştirmemize olanak sağlayacak metot tanımlamaları gerçekleştirdim.
public abstract class BasePhoneManager {
private String phoneBrand; // Telefon Markası İçin Değişkenimiz.
public String phoneModel; // Telefon Modelimizi Hafızasında Tutacak Değişken
public void setPhoneBrand(String phoneBrand){
this.phoneBrand = phoneBrand; // Telefon Markamızı Belirledik.
}
public String getPhoneBrand() {
return phoneBrand;
}
public abstract double buyTelephone(int price,double otv);
}
#2 Üst sınıftan üç adet marka için alt sınıflar türettim ve bu sınıflarda yapıcı metotlar kullanarak marka bilgilerini ve firma bilgilerini güncelledim.
#3 Alt sınıf olarak oluşturduğum SamsungPhoneMoanager sınıfı içerisinde telefon alımlarında fiyat ne olursa olsun 250 TL indirim uygulayarak hesaplama yaptırdım.
public class SamsungPhoneManager extends BasePhoneManager{
SamsungPhoneManager(String phoneModel){
setPhoneBrand("Samsung");
super.phoneModel = phoneModel;
}
@Override
public double buyTelephone(int price, double otv){
double totalTax = ((price*0.18)+(price*0.10)+(price*0.01));
return (price+(price*otv)+totalTax)-250;
}
}
#4 Bir diğer oluşturduğum alt sınıf olan ApplePhoneManager sınıfı üzerinde %20 zam uygulayarak hesaplamasını gerçekleştirdim.
public class ApplePhoneManager extends BasePhoneManager{
ApplePhoneManager(String phoneModel){
setPhoneBrand("Apple");
super.phoneModel = phoneModel;
}
@Override
public double buyTelephone(int price, double otv){
double totalTax = ((price*0.18)+(price*0.10)+(price*0.01));
return (price+(price*otv)+totalTax+(price*0.20)); // Iphone telefon alanlara %20 bir ekstra fiyat ekliyoruz.
}
}
#5 Son markamız için oluşturduğum HuaweiPhoneManager sınıfı üzerinde ise %25 oranında indirim uygulayarak hesaplama işlemini gerçekleştirdim.
public class HuaweiPhoneManager extends BasePhoneManager{
HuaweiPhoneManager(String phoneModel){
setPhoneBrand("Huawei");
super.phoneModel = phoneModel;
}
@Override
public double buyTelephone(int price, double otv){
double totalTax = ((price*0.18)+(price*0.10)+(price*0.01));
return (price+(price*otv)+totalTax-(price*0.25)); // Huawei telefon alanlara %25 bir ekstra fiyat ekliyoruz.
}
}
#6 Tüm bu sınıflardan alacağımız verileri CustomerManager isimli sınıf içerisinde çeşitli işlemlere tabi tutarak bazı metotlar oluşturdum.
import java.util.Scanner;
public class CustomerManager {
// Belirlenen sınıfa göre hesaplamalar yapmak istediğimiz için:
BasePhoneManager basePhoneManager;
Scanner scanner = new Scanner(System.in);
int phonePrice;
double phoneOtv;
void infoMessage(){
System.out.println("-----------------\n< Telefon Ücret Bilgileri >\n-----------------");
System.out.print("-> Telefon Geliş Ücreti: ");
phonePrice = scanner.nextInt();
if(phonePrice>=3000){ // OTV Hesaplamasını Yapacak if-else-if sorgusu
phoneOtv = 0.4;
}
else if(phonePrice<=3000 && phonePrice>1500){
phoneOtv = 0.25;
}
else {
phoneOtv = 0.15;
}
System.out.println("-> Hükümlü Olduğunuz ÖTV Ücreti: %"+phoneOtv*100);
}
void doTheShopping(){
System.out.println("-----------------\n< Telefon Bilgileri >\n-----------------");
System.out.println("-> Telefon Markası: "+basePhoneManager.getPhoneBrand());
System.out.println("-> Telefon Modeli: "+basePhoneManager.phoneModel);
System.out.println("-----------------\n< Telefon Hesaplaması >\n-----------------");
System.out.println("-> Telefon Fiyatı: "+ basePhoneManager.buyTelephone(phonePrice,phoneOtv));
System.out.println("-----------------");
}
}
#7 Oluşturmuş olduğum bu metotlar içerisinde kullanıcıdan telefon fiyatını isteyerek yapılacak ötv miktarını belirleyen bir if-else-if kontrol yapısına giriyor ve ilgili hesaplama metotlarını çağırarak işlemi gerçekleştirerek ekranımıza çıktı veriyor.
#8 Tüm bu işlemleri çalıştırabilmek için Main sınıfı içerisinde CustomerManager sınıfını nesneye çevirerek ekranıma gerekli çıktıları sağlayacak infoMessage ve doTheShopping metotlarını çağırarak programımı çalıştırıyorum.
public class Main {
public static void main(String[] args) {
CustomerManager customerManager = new CustomerManager();
customerManager.basePhoneManager = new HuaweiPhoneManager("P20 Lite");
customerManager.infoMessage();
customerManager.doTheShopping();
}
}
Kod Çıktısı:
Güzel ve detaylı bir örnek daha oluşturmuş olduk eğer aklınızda Java abstract class nedir, ne işe yarar, kullanımı gibi sorular hala duruyorsa veya konu işleyişi hakkında bir öneriniz bulunuyorsa aşağıda bulunan yorum yap kısmından benimle iletişime geçebilirsiniz.
Java Abstract Class nedir, kullanım yolları gibi sorulara Oracle tarafından yayımlanan içeriğe göz atmak isterseniz buradan ilgili dokümana ulaşabilirsiniz.
