Abstract class hakkında

1

Abstract class bize ne gibi fayda sağlıyor? Direk olarak kullanamıyoruz. Sadece miras almada parent class olarak kullanabiliyoruz, ve miras alan class Abstract edilmiş methodu barındırmak zorunluluğu var. Bu durumun bize ne tür bir faydası var pek kavrayamadım. Yerinde bir örnek kullanarak açıklayabilir misiniz?
Abstract örneği olarak :

from abc import ABC, abstractmethod


# 1.  Soyut sınıflarda hiçbir şekilde a1 = Animal() şeklinde super classı kullanamayız
# Bunu yapabilmek için abc modülünden yararlanıyoruz.
# 2. olarak super classda kulandığım metodları sup classda kullanmak zorundayım.
class Hayvan(ABC):  # super class

    @abstractmethod
    def yuru(self): pass

    @abstractmethod
    def kac(self): pass


class kus(Hayvan): # sub class

    def __init__(self):
        print('kus')

    def yuru(self):
        print('yuru')

    def kac(self):
        print('run')
2

Diger metodlarin kullanmasi gibi durumlarda sart olan “bu class’in [cocuklarinin] bu metodu olmak zorundadir” kontratini dayatmamizi sagliyor:

abstract class Yazdirici
{
	abstract void yazdir(String msg);

	void guzelYazdir(String msg)
	{
		yazdir(":)");
		yazdir(msg);
		yazdir(":)");
	}

	void cokYazdir(String[] msgs)
	{
		for (var msg: msgs) {
			yazdir(msg);
		}
	}
}
2 Beğeni
3

Herhalde pythonda pek kullanılan bir class türü değil.
Javadan bu class türüne aşikarım ama kafam takılan tek soru bu yapıyı neden kullanmalıyız, veya özellikle kullanabileceğimiz bir durum var mı?
Bize nasıl bir kolaylık sağlıyor?
Yazdığım class da neden kendimi böyle bir zorunluluğun içene sokayım?!

4

Bazen yazdığınız bir sınıfı miras almak isteyen alt sınıflara bazı metotları override etme zorunluluğu koymak isteyebilirsiniz. Program sırasında, elinizdeki nesnenin bazı metotları ile işlem yapacaksanız bunun mutlaka tanımlı olmasını garanti etmek istersiniz.

from abc import ABC,abstractmethod

class Mesaj(ABC):
    @abstractmethod
    def yaz(self,mesaj): pass

class Uyari(Mesaj):
    def yaz(self,mesaj):
        print(f"[UYARI] {mesaj}")

class Bilgi(Mesaj):
    def yaz(self,mesaj):
        print(f"[BİLGİ] {mesaj}")

mesajlar = [Bilgi(),Uyari()]

for i in mesajlar:
    i.yaz()

Burada tüm mesajların yaz metoduna sahip olduğunu garanti ettiğimiz için hangi mesaj türü olursa olsun yaz metodunu çağırabiliyoruz ve sürekli yaz metoduna sahip mi? gibi bir kontrol mekanizmasıyla kontrol etmek zorunda kalmıyoruz. Çünkü daha program çalışmadan, implement etmediğimiz metotlar için uyarı alacağımız için bunu en baştan düzeltme şansımız oluyor.

Elbette basit bir örnek. Ancak programlar büyüdükçe kontrol etmek zor olur, bunun gibi garantili çözüm yöntemleri programı daha rahat ve kolay bir şekilde yönetmeyi ve test etmeyi sağlar.

2 Beğeni
5

Tek başına yazdığın bir kodda pek mantıklı gelmiyor, ama takım halinde çalıştığın bir projede veya yazdığın projeyi başkasına devretme gibi bir durum var ise kullanmak işe yarayabilir.

6

Tek başına veya ekip meselesi değil aslında soyutlama olayı. OOP konusunda daha çok çalışma yaparsanız anlarsınız sanırım, şu an anlatmak biraz zor…

7

Hic gormedim, hic kullanmadim.

Bunu “kullanmaliyiz” diyen kisiye sorman lazim, ben daha oyle bir argumana rastlamadim.

Ozellikle olmasina gerek yok, burada verilen ornekler yetiyor aslinda. Begenmedigin icin ozel bir durum ariyorsun.

Hic “yarin unutmayayim” diye bir seyi klavyenin ustune veya kapinin onune koydun mu? Veya arkadasina aldigin hediyeyi “kendime saklamayayim” diye onceden haber verdin mi? Planladigin bir seyi sirf kendine motivasyon olsun diye baskalarina acikladin mi? Alarm kuruyor musun?

Neden kendini boyle zorunluluklarin icine sokuyorsun?

Tek basina yazdigin bir kodu gecmisteki veya gelecekteki kendinle beraber yazdigin bir takim projesi olarak dusunebilirsin, atiyorum 3 aydan fazla ara vermeyi de devretme.

3 Beğeni