OOP’nin 4 Temel Özelliği Nelerdir? (C++ ile Açıklamalı)

Kod yazarken kodu okunabilir, sürdürülebilir ve genişletilebilir hâle getirebilecek nesne yönelimli programlamanın (OOP) dört faktörü: Encapsulation, Inheritance, Polymorphism ve Abstraction. Bu yazıda C++ örnekleriyle, her biri ne işe yarar, nasıl uygulanır bir arada göreceğiz.

1. Encapsulation (Kapsülleme)

Encapsulation’ın amacı veriyi ve bu veri üzerindeki işlemleri tek bir yapıda toplamaktır. Bir nesnenin iç işleyişini dış dünyadan gizler. Sınıf üyelerine erişim, erişim belirleyiciler (örneğin public, private, protected) ile kontrol altına alınır. Bir nesnenin nasıl yaptığına değil, ne yaptığına odaklanmayı sağlar. Kısaca Encapsulation veriyi ve işlemleri birleştirir, erişimi kontrol eder.

Örneğin:

include <iostream>

using namespace std;

class BankAccount {

private:

// Encapsulation: Bu değişkenler dışarıdan doğrudan erişilemez.

// Sadece sınıf içinde kontrol edilen fonksiyonlarla değiştirilebilir.

double balance;

string owner;

public:

// Constructor: Hesap sahibi ve başlangıç bakiyesi atanıyor.

BankAccount(string ownerName, double initialBalance)

: owner(ownerName), balance(initialBalance) {}

// Para yatırma işlemi

void deposit(double amount) {

if (amount > 0) {

balance += amount;

}

}

// Para çekme işlemi

bool withdraw(double amount) {

if (amount > 0 && amount <= balance) {

balance -= amount;

return true;

}

return false;

}

// Encapsulation: balance değişkenine erişim kontrollü bir şekilde sağlanıyor

double getBalance() const {

return balance;

}

string getOwner() const {

return owner;

}

};

int main() {

BankAccount account(“Ezgi”, 1000.0);

account.deposit(500.0); // 500 TL yatır

account.withdraw(200.0); // 200 TL çek

cout << account.getOwner() << “ bakiyesi: “

<< account.getBalance() << “ TL” << endl;

return 0;

}

Balance değişkeni private olarak tanımlandığı için dışarıdan doğrudan erişilemez. Kullanıcı bu değeri istediği gibi değiştiremez veya müdahale edemez. Bu değişkene erişim yalnızca sınıfın sunduğu deposit, withdraw ve getBalance metodları üzerinden yapılır. Yapı, hesabın yanlışlıkla veya kontrolsüz bir şekilde değiştirilmesini engeller. Böylece nesnenin tutarlılığı korunur, veri güvenliği sağlar ve sistemin daha temiz, yönetilebilir bir hâle gelmesine yardımcı olur.

2. Inheritance (Kalıtım / Miras)

Inheritance, bir sınıfın başka bir sınıftan özellik ve davranışları miras almasını sağlayan mekanizmadır. Ortak özellikler üst sınıfta (parent class) toplanır, alt sınıflar (child class) ise kendine yeni davranışlar ekleyebilir. Böylece üst sınıftaki genel tanımlar korunurken, alt sınıflarda daha özel yapılar oluşturulur.

Bu prensip, sınıflar arasında “bir türdür” (is-a) ilişkisini kurar. Örneğin Kedi, bir Hayvandır. Kedi sınıfı, Hayvan sınıfının yürümek, nefes almak gibi davranışlarını otomatik olarak devralır ve üzerine kendi özelliklerini ekleyebilir.

Inheritance’ın en önemli özelliklerinden biri kod tekrarını azaltmasıdır. Ortak özellikler tek bir üst sınıfta tanımlandığından dolayı alt sınıflar bunları yeniden yazmak zorunda kalmaz. Bu da kodların daha düzenli, az kod içeren ve kolay bir kod yapısı sağlar.

Örneğin:

include <iostream>

using namespace std;

// Üst sınıf (parent class)

class Animal {

public:

void eat() {

cout << “Animal is eating…” << endl;

}

void breathe() {

cout << “Animal is breathing…” << endl;

}

};

// Alt sınıf (child class) -> Animal sınıfından kalıtım alıyor

class Dog : public Animal {

public:

void bark() {

cout << “Dog is barking: Woof!” << endl;

}

};

int main() {

Dog myDog;

// Dog sınıfı Animal’dan eat ve breathe metodlarını miras alır

myDog.eat(); // Animal sınıfından

myDog.breathe(); // Animal sınıfından

myDog.bark(); // Dog sınıfına özgü davranış

return 0;

}

3. Polymorphism (Çok Biçimlilik)

Polymorphism, aynı isimli metodun farklı davranışlar gösterebilmesi anlamına gelir. C++’ta polymorphism çoğunlukla virtual anahtar kelimesiyle gerçekleştirilir. Yani polymorphism birçok forma sahip olmak anlamına gelir. Gerçek hayattan bir örnek verecek olursak, bir kadın aynı zamanda anne, eş ve çocuk olabilir. Farklı durumlarda farklı davranışlar sergileyebilir. Bu davranışlar nesne türlerine bağlıdır.

Örneğin:

include <iostream>

using namespace std;

// Temel sınıf (base class)

class Woman {

public:

// Polymorphism: aynı metod farklı şekillerde davranabilir

virtual void role() const {

cout << “Kadın kendi rolünü sergiliyor.” << endl;

}

virtual ~Woman() = default;

};

// Anne rolü

class Mother : public Woman {

public:

void role() const override {

cout << “Anne: Çocuğuyla ilgileniyor.” << endl;

}

};

// Eş rolü

class Wife : public Woman {

public:

void role() const override {

cout << “Eş: Eşiyle iletişim kuruyor.” << endl;

}

};

// Çocuk rolü

class Daughter : public Woman {

public:

void role() const override {

cout << “Çocuk: Ailesiyle konuşuyor.” << endl;

}

};

int main() {

Woman* w1 = new Mother();

Woman* w2 = new Wife();

Woman* w3 = new Daughter();

w1->role(); // Mother sınıfının davranışı

w2->role(); // Wife sınıfının davranışı

w3->role(); // Daughter sınıfının davranışı

delete w1;

delete w2;

delete w3;

return 0;

}

4. Abstraction (Soyutlama)

Abstraction, karmaşık detayları kullanıcıdan gizler ve sadece gerekli olan bilgilerin görünmesini sağlar. Yani kullanıcıya “ne yapılacağını” gösterirken “nasıl yapılacağını” saklar. Abstraction’ın amacı sade ve daha anlaşılır olmaktır, böylelikle kullanıcıların gereksiz detaylarla uğraşmasını engeller ve sistem bakımını kolaylaştırır. Örneğin bir arabayı sürmek için direksiyon, gaz ve fren pedallarını kullanırız. Ancak motorun içinde tam olarak ne olduğunu bilemeyiz; bilmemize de gerek yoktur. Bize ihtiyaç duyduğumuz kontrol paneli verilir.

Örneğin:

include <iostream>

using namespace std;

// Soyut sınıf: Kullanıcıya yalnızca gerekli arayüzü sağlar

class Vehicle {

public:

// Pure virtual method: Bu sınıf soyut hale gelir

virtual void drive() = 0;

virtual ~Vehicle() = default;

};

// Araba sınıfı: Kullanıcı sadece drive() metodunu görür

class Car : public Vehicle {

private:

// Kullanıcı bu detayları bilmez (soyutlanan kısım)

void startEngine() {

cout << “Motor çalışıyor…” << endl;

}

public:

void drive() override {

startEngine(); // İç detay

cout << “Araba hareket ediyor…” << endl;

}

};

// Motosiklet sınıfı

class Motorcycle : public Vehicle {

private:

void igniteEngine() {

cout << “Motosiklet motoru ateşleniyor…” << endl;

}

public:

void drive() override {

igniteEngine();

cout << “Motosiklet hareket ediyor…” << endl;

}

};

int main() {

Vehicle* v1 = new Car();

Vehicle* v2 = new Motorcycle();

// Kullanıcı sadece drive() metodunu kullanır

v1->drive();

v2->drive();

delete v1;

delete v2;

return 0;

}

Yazar:Ezgi Bacak