Nesne Yönelimli Programlama Kavramı OOP¶

Nesne Yönelimli Programlama(Object Oriented Programming)

Nedir?¶

OOP, bir bilgisayar programlama tasarım felsefesi veya metodolojisidir. Yazılım tasarımını işlevler ve mantık yerine veriler veya nesneler etrafında düzenler ve modeller. OOP, bir grup veri özniteliğini işlevler veya yöntemlerle nesne adı verilen bir birimde birleştirir. Bir nesne, benzersiz niteliklere (özellikler) ve davranışlara (işlevler, yöntemler) sahip bir veri alanı olarak adlandırılır. Özellikler, nesnenin durumudur. Davranışlar, nesnemizin gerçekleştirdiği eylemlerdir. Davranışlar genellikle nesnenin özelliklerini değiştirir. OOP'nin sütunları soyutlama, kapsülleme, kalıtım ve polimorfizmdir. Bir nesnenin nitelikleri ve işlevleri vardır. Sınıf, bir nesnenin planı veya şablonudur.

Neden kullanırız?¶

OOP, programı küçük parçalara ayırmayı sağlar. Böylece problemler kolayca çözülecektir. OOP sistemleri, küçük sistemlerden büyük sistemlere kolayca yükseltilebilir. OOP, programcı üretkenliğini, yazılım kalitesini artırır ve bakım maliyetini düşürür. Programları, sıfırdan kod yazmaya başlamak yerine birbiriyle iletişim kuran standart çalışma modüllerinden oluşturabiliriz. Bağımlılıkları azaltmanın harika bir yolu olduğu için büyük ölçekli uygulamaları çok daha basit hale getirir.

Ne zaman kullanırız?¶

OOP, değiştirilebilir durumu kapsüllemekle ilgilidir ve bu nedenle etkileşimli uygulamalar, GUI'ler ve API'ler değiştirilebilir durumu açığa çıkarmak için daha uygundur. Her bir bileşeni anlaması gerekmeyen birden fazla programcınız var. Paylaşılabilecek ve yeniden kullanılabilecek çok sayıda kod var Projenin sık sık değişmesi ve zaman içinde eklenmesi beklenmektedir. Farklı bölümler, veri kaynağı ve donanım gibi farklı kaynaklardan yararlanabilir.

Nasıl kullanırız?¶

OOP'de bir problemi nesneler açısından modellediğimizde, sistemimizde olmasını istediğimiz nesne türlerini temsil eden soyut tanımlar yaratırız.

Örneğin, bir okulu modelliyor olsaydık, profesörleri temsil eden nesnelere sahip olmak isteyebilirdik. Her profesörün bazı ortak özellikleri vardır: Hepsinin adı ve öğrettikleri bir konu vardır. Ayrıca her profesör belirli şeyler yapabilir. Örneğin hepsi bir ödeve not verebilir ve sene başında öğrencilerine kendilerini tanıtabilirler.

Profesör, sistemimizde bir sınıf olabilir ve sınıfın tanımı, her profesörün sahip olduğu verileri (öznitelikler, özellikler) ve yöntemleri listeler.

Pseudo(sahte/fake) kod olarak, bir Profesör sınıfı şu şekilde yazılabilir:

class Professor
    properties:
        name
        teaches
    methods:
        grade(paper)
        introduce_self()

- Tek başına bir sınıf bir şey yapmaz. Bir türün somut nesnelerini oluşturmak için bir şablondur. - Oluşturduğumuz her somut profesör, Profesör sınıfının bir örneği olarak adlandırılır. - Bir nesne, sınıfın bir örneği olarak adlandırılır. - Bir örneğin oluşturulma süreci, bir yapıcı olarak adlandırılan özel bir işlev tarafından gerçekleştirilir. - Aşağıdaki örnekte OOP felsefesi takip edilerek bir Python programı oluşturulmuştur.

from abc import ABCMeta, abstractmethod


class WorkerInterface(metaclass=ABCMeta):
    @classmethod
    def __subclasshook__(cls, subclass):
        return (
            hasattr(subclass, 'work') and
            callable(subclass.work) and
            hasattr(subclass, 'calculate_salary') and
            callable(subclass.calculate_salary) or
            NotImplemented
        )

    @abstractmethod
    def work(self) -> None:
        raise NotImplementedError

    @abstractmethod
    def calculate_salary(self) -> float:
        raise NotImplementedError


class Employee(WorkerInterface):
    BASE_SALARY = 1000

    def __init__(self, no, name, year) -> None:
        super().__init__()
        self.__no = no
        self.__name = name
        self.__year = year

    @property
    def name(self):
        return self.__name

    def work(self):
        print(f"Employee {self.name} is working.")

    def calculate_salary(self):
        return self.__year * self.BASE_SALARY


class Manager(Employee):
    MANAGEMENT_PAYMENT = 10_000

    def __init__(self, no, name, year, department) -> None:
        super().__init__(no, name, year)
        self.__department = department

    def work(self) -> None:
        print(f"Manager {self.name} is working.")
        self._manage()

    def _manage(self) -> None:
        print(f'Manager {self.name} is managing.')

    def calculate_salary(self) -> float:
        return self.MANAGEMENT_PAYMENT + super().calculate_salary()


class Director(Manager):
    def __init__(self, no, name, year, department, bonus) -> None:
        super().__init__(no, name, year, department)
        self.__bonus = bonus

    def work(self) -> None:
        print(f"Director {self.name} is working.")
        self._manage()
        self._make_a_strategic_plan()

    def _manage(self) -> None:
        print(f'Director {self.name} is managing.')

    def _make_a_strategic_plan(self):
        print(f'Director {self.name} is making a strategic plan.')

    def calculate_salary(self) -> float:
        return self.__bonus + super().calculate_salary()


class HumanResources:
    def pay_salary(self, worker: WorkerInterface) -> None:
        salary = worker.calculate_salary()
        print(f'Paying {worker.name}, salary: {salary}')


if __name__ == '__main__':
    try:
        e = Employee(1, 'Adnan', 10)
        m = Manager(2, 'Kaya', 5, 'R&D')
        d = Director(3, 'Ibrahim', 3, 'Company', 20_000)

        e.work()
        m.work()
        d.work()
        print('_________HR__________')
        hr = HumanResources()
        hr.pay_salary(e)
        hr.pay_salary(m)
        hr.pay_salary(d)
    except Exception as e:
        raise e

"""Output

Employee Adnan is working.
Manager Kaya is working.
Manager Kaya is managing.
Director Ibrahim is working.
Director Ibrahim is managing.
Director Ibrahim is making a strategic plan.
_________HR__________
Paying Adnan, salary: 10000
Paying Kaya, salary: 15000
Paying Ibrahim, salary: 33000

"""