Inheritance (Kalıtım) Nedir?

Nesne yönelimli programlamada, yazılım geliştirme süreçlerini daha verimli hale getirmek için birçok farklı kavram ve teknik kullanılır. Bu tekniklerden biri de, Nesne Yönelimli Programlama (Object-Oriented Programming) temel yapılarından biri olan kalıtım (inheritance) prensibidir.

Kalıtım, yazılım tasarımında kodun tekrarını azaltmak, sınıflar arasında ilişki kurmak ve daha esnek bir yapı inşa etmek amacıyla kullanılan temel bir yaklaşımdır. Bir sınıf, başka bir sınıfın özelliklerini ve davranışlarını devralabilir, böylece yalnızca yeni ve özgün işlevsellik ekleyerek daha özelleşmiş sınıflar oluşturulabilir.

Kalıtım mantığını oturtmak için klasikleşmiş örneklere güvenirim: Bir otomobil düşünelim, tüm otomobillerin ortak özellikleri vardır: direksiyon, tekerlekler ve motor. Bu genel özellikleri bir "Otomobil" sınıfında tanımlayabiliriz. Ardından, "Spor Araba" ve "Kamyon" gibi özel sınıflar oluşturduğumuzda, "Otomobil" sınıfından türeterek genel özellikleri devralır, sadece özel nitelikleri ve davranışları ekleriz.

Bu yazımda, kalıtım kavramının nasıl çalıştığını ve bu prensibin yazılım geliştiricilerine nasıl büyük kolaylıklar sunduğunu detaylı bir şekilde inceleyeceğiz. Kalıtımın farklı türlerini örnekler senaroylarla açıklayarak, pratikte nasıl uygulanabileceğine dair önemli bilgiler içerecektir.

Base Class (Parent) ve Derived Class (Child) Kavramları

Kalıtımda (inheritance), temel sınıf (yani Base Class) ve türetilmiş sınıf (yani derived class) kavramları, sınıflar arasındaki hiyerarşiyi anlamak için oldukça önemlidir.

• Base Class (Parent): Diğer sınıflara miras bırakılacak ortak özellik ve davranışları tanımlar.
• Derived Class (Child): Temel sınıftan miras alır ve üzerine kendi özelliklerini ekleyebilir veya temel sınıfın metodlarını yeniden tanımlayabilir.

Bir senaryo üzerinden örneklendirelim, bir şirkette çalışanlar için bir sistem geliştirdiğimizi düşünelim. Tüm çalışanların ortak özellikleri vardır, ancak bazı roller özel niteliklere sahip olabilir.

1// Base Class: Employee
2public class Employee
3{
4    public string Name { get; set; }
5    public int EmployeeID { get; set; }
6
7    public void Work()
8    {
9        Console.WriteLine($"{Name} is working.");
10    }
11}
12
13// Derived Class: Manager
14public class Manager : Employee
15{
16    public void ConductMeeting()
17    {
18        Console.WriteLine($"{Name} is conducting a meeting.");
19    }
20}
21
22// Derived Class: Developer
23public class Developer : Employee
24{
25    public void WriteCode()
26    {
27        Console.WriteLine($"{Name} is writing code.");
28    }
29}
30
31// Kullanım
32class Program
33{
34    static void Main(string[] args)
35    {
36        Manager manager = new Manager { Name = "Ahmet", EmployeeID = 1 };
37        Developer developer = new Developer { Name = "Elif", EmployeeID = 2 };
38
39        manager.Work();          // Ahmet is working.
40        manager.ConductMeeting(); // Ahmet is conducting a meeting.
41
42        developer.Work();        // Elif is working.
43        developer.WriteCode();   // Elif is writing code.
44    }
45}

Employee sınıfı temel sınıf olarak tanımlandı ve tüm çalışanlara ait olan Name ve EmployeeID özelliklerini içeriyor. Manager ve Developer sınıfları, Employee sınıfından türetilmiştir ve kendi özel metodlarını (ConductMeeting ve WriteCode) ekleyerek davranışlarını genişletmiştir. Türetilmiş sınıflar, Work metodunu da temel sınıftan devralır ve bu metod aynı şekilde çalışır.

Access Modifiers (Erişim Belirleyicileri)

Access Modifiers (Erişim Belirleyicileri), sınıf üyelerine (özellikler, metodlar) erişim düzeyini kontrol eder. Kalıtımda erişim belirleyicileri, türetilmiş sınıfların base sınıftan hangi üyeleri miras alacağını ve bu üyelere nasıl erişeceğini belirler.

• Public: Tüm sınıflardan erişilebilir.
• Protected: Sadece base sınıf ve türetilmiş sınıflardan erişilebilir.
• Private: Sadece tanımlandığı sınıf içerisinden erişilebilir.
• Internal: Aynı assembly içerisindeki sınıflardan erişilebilir.

Bir senaryo üzerinden örneklendirelim, bir bankacılık sistemi geliştirdiğimizi düşünelim. Temel sınıf olan BankAccount sınıfı, hesap bilgilerini korumalı (protected) olarak tanımlar, böylece bu bilgilere doğrudan dışarıdan erişilemez.

1// Base Class: BankAccount
2public class BankAccount
3{
4    public string AccountHolder { get; set; }
5    protected decimal Balance { get; set; }
6
7    public void DisplayBalance()
8    {
9        Console.WriteLine($"Current balance: {Balance}");
10    }
11
12    protected void Deposit(decimal amount)
13    {
14        Balance += amount;
15        Console.WriteLine($"{amount} deposited. New balance: {Balance}");
16    }
17}
18
19// Derived Class: SavingsAccount
20public class SavingsAccount : BankAccount
21{
22    public void AddInterest(decimal interestRate)
23    {
24        decimal interest = Balance * interestRate / 100;
25        Deposit(interest);  // Protected metoda türetilmiş sınıftan erişim
26    }
27}
28
29// Kullanım
30class Program
31{
32    static void Main(string[] args)
33    {
34        SavingsAccount savings = new SavingsAccount();
35        savings.AccountHolder = "Ali";
36
37        // savings.Balance = 1000; // Hata! Balance protected olduğu için erişilemez.
38
39        // Protected metoda türetilmiş sınıf üzerinden erişim
40        savings.AddInterest(5);
41        savings.DisplayBalance();
42    }
43}

Balance özelliği protected olarak tanımlandığı için doğrudan dışarıdan erişilemez, ancak türetilmiş sınıflar (SavingsAccount) erişebilir. Deposit metodu da protected olduğundan, türetilmiş sınıflar bu metodu kullanarak işlemler yapabilir, ancak dışarıdan çağrılamaz. Public olan DisplayBalance metoduna ise her yerden erişilebilir.

Private erişim belirleyicisi (access modifier) için alternatif bir örnek verecek olursak, bir BankAccount sınıfında, hesap bakiyesi gibi bilgilerin private olması gereklidir. Bu bilgilere yalnızca BankAccount sınıfının içinden erişilebilir, türetilmiş sınıflar ya da dışarıdaki başka sınıflar doğrudan erişemez.

1// Base Class: BankAccount
2public class BankAccount
3{
4    private decimal balance; // Private üye
5
6    public BankAccount(decimal initialBalance)
7    {
8        balance = initialBalance;
9    }
10
11    // Private üyeye erişim sağlayan public metod
12    public void Deposit(decimal amount)
13    {
14        balance += amount;
15        Console.WriteLine($"{amount} deposited. Current balance: {balance}");
16    }
17
18    public void DisplayBalance()
19    {
20        Console.WriteLine($"Current balance: {balance}");
21    }
22}
23
24// Derived Class: SavingsAccount
25public class SavingsAccount : BankAccount
26{
27    public SavingsAccount(decimal initialBalance) : base(initialBalance) { }
28
29    public void TryAccessBalance()
30    {
31        // balance'a doğrudan erişim sağlanamaz:
32        // Console.WriteLine(balance); // Hata! Private üye.
33
34        DisplayBalance(); // Public metod aracılığıyla dolaylı erişim.
35    }
36}
37
38// Farklı bir sınıf: BankOperations
39public class BankOperations
40{
41    public void PerformOperation()
42    {
43        BankAccount account = new BankAccount(500);
44        account.Deposit(200);
45
46        // account.balance = 1000; // Hata! Private üye doğrudan erişilemez.
47    }
48}
49
50class Program
51{
52    static void Main(string[] args)
53    {
54        SavingsAccount savings = new SavingsAccount(1000);
55        savings.Deposit(500);
56        savings.TryAccessBalance();
57
58        BankOperations operations = new BankOperations();
59        operations.PerformOperation();
60    }
61}

Açıklama: balance değişkeni BankAccount sınıfında private olarak tanımlanmıştır. Bu yüzden: SavingsAccount sınıfı, balance değişkenine doğrudan erişemez. Ancak, Deposit ve DisplayBalance gibi public metodlar aracılığıyla bakiyeye erişebilir. BankOperations gibi dışarıdan başka bir sınıf da balance değişkenine doğrudan erişemez.

Erişim Yolu: balance değişkeni üzerinde işlem yapmak için sınıf içindeki public metodlar kullanılmalıdır. Bu yöntem, encapsulation (kapsülleme) ilkesinin bir örneğidir.

Single vs. Multiple Inheritance

Kalıtımda, sınıfların nasıl miras aldığına bağlı olarak iki temel model vardır: Single Inheritance (Tekli Kalıtım) ve Multiple Inheritance (Çoklu Kalıtım). Bu iki kavram, farklı dillerde farklı şekillerde desteklenir.

Single Inheritance (Tekli Kalıtım)

Bir sınıf yalnızca bir base (temel) sınıftan miras alabilir. Çoğu modern programlama dili (C#, Java, vb.) bu modeli destekler.

Senaryo üzerinden örneklendirelim, aslında bu konuyu az önce de örneklendirmiştik, yine benzer bir örnekle ilerleyelim. Bir araç sistemi geliştirdiğimizi düşünelim. Car sınıfı, Vehicle sınıfından miras alır.

1// Base Class: Vehicle
2public class Vehicle
3{
4    public int Wheels { get; set; }
5    public void Move()
6    {
7        Console.WriteLine("The vehicle is moving.");
8    }
9}
10
11// Derived Class: Car
12public class Car : Vehicle
13{
14    public string Brand { get; set; }
15
16    public void Honk()
17    {
18        Console.WriteLine($"{Brand} is honking.");
19    }
20}
21
22// Kullanım
23class Program
24{
25    static void Main(string[] args)
26    {
27        Car car = new Car { Wheels = 4, Brand = "Toyota" };
28        car.Move();      // The vehicle is moving.
29        car.Honk();      // Toyota is honking.
30    }
31}

Açıklama: Car sınıfı, Vehicle sınıfından türetilmiştir ve onun özelliklerini (örneğin Move metodu) devralır.

Single Inheritance ile bir sınıf, sadece tek bir temel sınıftan miras alabilir.

Multiple Inheritance (Çoklu Kalıtım)

Bir sınıfın birden fazla sınıftan miras almasıdır. Ancak, bu özellik C# ve Java gibi dillerde desteklenmez çünkü karmaşıklığa ve Diamond Problem (Elmas Problemi) gibi sorunlara yol açabilir. C++, Python, Perl gibi dillerde ise çoklu kalıtım mümkündür.

C# ve Java'da Çoklu Kalıtım Alternatifi: Çoklu kalıtım yerine interface kullanılır. Bu, bir sınıfın birden fazla interface'i uygulayarak çoklu davranışları devralmasını sağlar.

Bir senaryo üzerinden örneklendirecek olursak, bir FlyingCar oluşturacağımızı farz edelim, bunun için hem Vehicle hem de IFlyable arayüzlerinden faydalanalım.

1// Base Class
2public class Vehicle
3{
4    public void Move()
5    {
6        Console.WriteLine("The vehicle is moving.");
7    }
8}
9
10// Interface
11public interface IFlyable
12{
13    void Fly();
14}
15
16// Derived Class implementing multiple behaviors
17public class FlyingCar : Vehicle, IFlyable
18{
19    public void Fly()
20    {
21        Console.WriteLine("The flying car is flying.");
22    }
23}
24
25// Kullanım
26class Program
27{
28    static void Main(string[] args)
29    {
30        FlyingCar flyingCar = new FlyingCar();
31        flyingCar.Move();  // The vehicle is moving.
32        flyingCar.Fly();   // The flying car is flying.
33    }
34}

Açıklama: FlyingCar, hem Vehicle sınıfından türetilmiş hem de IFlyable arayüzünü uygulamıştır. Böylece çoklu kalıtımın avantajları elde edilmiş olur. Arayüzler, birden fazla yetenek veya davranışı bir sınıfa kazandırmak için kullanılır.

Multilevel Inheritance (Zincirleme Kalıtım)

Kalıtım türlerine değinmişken değinmemiz gereken bir diğer başlık Multilevel Inheritance. Aslında temel olarak multilevel inheritance, bir sınıfın başka bir türetilmiş sınıftan miras alması durumudur. Yani, bir sınıf, türetilmiş bir sınıftan türetilir ve bu süreç birden fazla seviyede devam eder. Bu, sınıflar arasında bir zincir oluşturur.

Avantajı: Temel özellikler ve davranışlar üst sınıflarda tanımlanır ve alt sınıflarda tekrar kullanılabilir, böylece kod tekrarını azaltır.

Dikkat Edilmesi Gerekenler: Çok fazla kalıtım seviyesi kullanmak, kodun anlaşılabilirliğini zorlaştırabilir, bu da aşırı karmaşıklığa yol açar. Ayrıca bir üst sınıfta yapılan değişiklikler, tüm türetilmiş sınıfları etkileyebilir.

Örnek senaryo üzerinden pekiştirelim.

1// Base Class: Person
2public class Person
3{
4    public string Name { get; set; }
5
6    public void Introduce()
7    {
8        Console.WriteLine($"Hello, my name is {Name}.");
9    }
10}
11
12// Derived Class: Teacher (inheriting from Person)
13public class Teacher : Person
14{
15    public string Subject { get; set; }
16
17    public void Teach()
18    {
19        Console.WriteLine($"I teach {Subject}.");
20    }
21}
22
23// Derived Class: MathTeacher (inheriting from Teacher)
24public class MathTeacher : Teacher
25{
26    public void ExplainMathConcept()
27    {
28        Console.WriteLine($"Let’s solve a math problem.");
29    }
30}
31
32// Kullanım
33class Program
34{
35    static void Main(string[] args)
36    {
37        MathTeacher mathTeacher = new MathTeacher
38        {
39            Name = "Ayşe",
40            Subject = "Mathematics"
41        };
42
43        mathTeacher.Introduce();           // Hello, my name is Ayşe.
44        mathTeacher.Teach();               // I teach Mathematics.
45        mathTeacher.ExplainMathConcept();  // Let’s solve a math problem.
46    }
47}

Açıklama: Person sınıfı temel sınıftır ve genel özellikleri (örneğin Name ve Introduce metodu) tanımlar. Teacher sınıfı, Person sınıfından miras alır ve üzerine Subject gibi yeni özellikler ekler. MathTeacher sınıfı ise Teacher sınıfından türetilmiştir ve matematiğe özgü davranışları (ExplainMathConcept) ekler. Her sınıf, miras aldığı üst sınıfın üyelerine erişebilir ve bu üyeleri genişletebilir.

Hierarchical Inheritance (Hiyerarşik Kalıtım)

Hierarchical inheritance, bir temel sınıfın birden fazla türetilmiş sınıf tarafından miras alındığı bir yapıyı ifade eder. Bu durumda, tüm türetilmiş sınıflar aynı temel sınıftan özellik ve davranışları devralır, ancak her biri kendine özgü özellikler ekleyebilir.

Tabii ki avantaj ve dezavantajları vardır: Birden fazla türetilmiş sınıf aynı temel sınıfı paylaşarak ortak davranışları devralır, ortak özellikler ve metodlar sadece bir kez tanımlanır, tekrar edilmez, böylece verimli ve düzenli kalır. Ancak, çok fazla türetilmiş sınıf olması, kodun bakımı ve anlaşılabilirliği açısından karmaşık hale gelebilir. Buna ek olarak temel sınıfta yapılan değişiklikler tüm türetilmiş sınıfları etkileyeceği için dikkatli olunmalı ve değişiklikler minimumda tutulmalıdır.

Az önceki başlığa benzer bir yapıdır, yine örnek bir senaryoyla örneklendirelim.

1// Base Class: User
2public class User
3{
4    public string Username { get; set; }
5    public string Email { get; set; }
6
7    public void Login()
8    {
9        Console.WriteLine($"{Username} logged in.");
10    }
11}
12
13// Derived Class 1: Admin (inheriting from User)
14public class Admin : User
15{
16    public void ManageSystem()
17    {
18        Console.WriteLine("Admin is managing the system.");
19    }
20}
21
22// Derived Class 2: Customer (inheriting from User)
23public class Customer : User
24{
25    public void Shop()
26    {
27        Console.WriteLine("Customer is shopping.");
28    }
29}
30
31// Kullanım
32class Program
33{
34    static void Main(string[] args)
35    {
36        Admin admin = new Admin { Username = "admin123", Email = "admin@example.com" };
37        admin.Login();       // admin123 logged in.
38        admin.ManageSystem(); // Admin is managing the system.
39
40        Customer customer = new Customer { Username = "john_doe", Email = "john@example.com" };
41        customer.Login();    // john_doe logged in.
42        customer.Shop();     // Customer is shopping.
43    }
44}

Açıklama: User sınıfı temel sınıf olarak tanımlandı ve tüm kullanıcılar için ortak özellikler (Username, Email, Login metodu) içeriyor. Admin ve Customer sınıfları, User sınıfından türetilmiştir ve her biri kendine özgü metodlar eklemiştir (ManageSystem ve Shop). Bu yapı, her iki türetilmiş sınıfın aynı temel sınıftan miras aldığı özelliklerin verimli bir şekilde paylaşılmasını sağlar.

Hybrid Inheritance (Hibrit Kalıtım)

Hybrid inheritance, bir sınıfın birden fazla kalıtım türünü birleştirdiği bir yapıdır. Bu, aynı sınıfın hem multilevel inheritance (zincirleme kalıtım) hem de hierarchical inheritance (hiyerarşik kalıtım) özelliklerini taşıması durumudur. Hibrit kalıtım, farklı kalıtım türlerinin avantajlarını bir arada kullanmaya olanak tanır.

Ancak, hibrit kalıtım bazı dillerde karmaşıklığa yol açabilir. Python gibi bazı diller, hibrit kalıtımı doğal bir şekilde desteklerken, C# ve Java gibi dillerde bu tür yapıların kullanımını sınırlayan veya doğrudan desteklemeyen özellikler bulunabilir.

1// Base Class: Person
2public class Person
3{
4    public string Name { get; set; }
5    public int Age { get; set; }
6
7    public void Introduce()
8    {
9        Console.WriteLine($"Hi, I am {Name} and I am {Age} years old.");
10    }
11}
12
13// Intermediate Class: Employee (Inheriting from Person)
14public class Employee : Person
15{
16    public string EmployeeId { get; set; }
17
18    public void Work()
19    {
20        Console.WriteLine($"Employee {Name} is working.");
21    }
22}
23
24// Derived Class 1: Teacher (Inheriting from Employee)
25public class Teacher : Employee
26{
27    public string Subject { get; set; }
28
29    public void Teach()
30    {
31        Console.WriteLine($"Teacher {Name} is teaching {Subject}.");
32    }
33}
34
35// Derived Class 2: Student (Inheriting from Employee)
36public class Student : Employee
37{
38    public string Major { get; set; }
39
40    public void Study()
41    {
42        Console.WriteLine($"Student {Name} is studying {Major}.");
43    }
44}
45
46// Kullanım
47class Program
48{
49    static void Main(string[] args)
50    {
51        Teacher teacher = new Teacher
52        {
53            Name = "John",
54            Age = 35,
55            EmployeeId = "T123",
56            Subject = "Mathematics"
57        };
58
59        teacher.Introduce(); // Hi, I am John and I am 35 years old.
60        teacher.Work();      // Employee John is working.
61        teacher.Teach();     // Teacher John is teaching Mathematics.
62
63        Student student = new Student
64        {
65            Name = "Emma",
66            Age = 20,
67            EmployeeId = "S456",
68            Major = "Computer Science"
69        };
70
71        student.Introduce(); // Hi, I am Emma and I am 20 years old.
72        student.Work();      // Employee Emma is working.
73        student.Study();     // Student Emma is studying Computer Science.
74    }
75}

Açıklama: Person sınıfı temel sınıf olarak, ortak özellikleri (örneğin Name, Age) tanımlar. Employee sınıfı, Person sınıfından türetilmiş ve ortak özelliklerin yanı sıra çalışanlara özgü işlevsellik ekler (EmployeeId, Work). Teacher ve Student sınıfları ise, Employee sınıfından türetilmiştir ve her biri kendine özgü işlevsellik eklemiştir (Teach ve Study). Bu yapı, hem multilevel (zincirleme) hem de hierarchical (hiyerarşik) kalıtımın birleşiminden oluşan bir hibrit kalıtım modelidir.

Method Overriding (Metod Geçersiz Kılma)

Metod geçersiz kılma (method overriding), bir türetilmiş sınıfın, temel sınıfta tanımlanan bir metodu kendi ihtiyacına göre yeniden tanımlamasıdır. Bu, özellikle nesne yönelimli programlamada, polimorfizmin temel bileşenlerinden biridir. Temel sınıfta tanımlanan metot, türetilmiş sınıfta "geçersiz kılınarak" daha spesifik bir işlevsellik sağlanabilir.

Method Overriding'ın Avantajları:

• Polimorfizm: Aynı metot adı, farklı sınıflarda farklı implementasyonlarla çağrılabilir, bu da polimorfizmi sağlar.
• Esneklik ve Özelleştirme: Temel sınıfın sunduğu genel işlevsellik, türetilmiş sınıflarda özel ihtiyaçlara göre özelleştirilebilir.
• Bakım Kolaylığı: Türetilmiş sınıflarda yapılan değişiklikler temel sınıfın işleyişini etkilemeden yapılabilir.

Dikkat Edilmesi Gerekenler:

• Kapsama: Metod geçersiz kılma yalnızca virtual veya abstract metodlarla yapılabilir. Bu, temel sınıfın metodunun değiştirilip değiştirilmediği konusunda belirli bir kısıtlama getirir.
• Yanlış Kullanım: Metodun geçersiz kılınması, yanlış kullanım sonucu beklenmedik davranışlara yol açabilir.

Bunu bir senaryo üzerinden örneklendirelim, bir ödeme sistemi üzerinden bankaların farklı ödeme yöntemlerini işlediğini varsayalım. Temel sınıfımızda genel bir ödeme metodu olabilir, ancak her banka kendine özgü ödeme metodunu implement edebilir.

1// Base Class: Payment
2public class Payment
3{
4    public virtual void ProcessPayment()
5    {
6        Console.WriteLine("Processing payment...");
7    }
8}
9
10// Derived Class 1: CreditCardPayment (Override the ProcessPayment method)
11public class CreditCardPayment : Payment
12{
13    public override void ProcessPayment()
14    {
15        Console.WriteLine("Processing credit card payment...");
16    }
17}
18
19// Derived Class 2: PayPalPayment (Override the ProcessPayment method)
20public class PayPalPayment : Payment
21{
22    public override void ProcessPayment()
23    {
24        Console.WriteLine("Processing PayPal payment...");
25    }
26}
27
28// Kullanım
29class Program
30{
31    static void Main(string[] args)
32    {
33        Payment payment1 = new CreditCardPayment();
34        payment1.ProcessPayment();  // Processing credit card payment...
35
36        Payment payment2 = new PayPalPayment();
37        payment2.ProcessPayment();  // Processing PayPal payment...
38    }
39}

Açıklama: Payment sınıfı temel sınıf olarak, tüm ödeme türleri için genel bir ProcessPayment metodu tanımlar. CreditCardPayment ve PayPalPayment sınıfları, Payment sınıfından türetilmiştir ve her biri ProcessPayment metodunu kendi ihtiyacına göre geçersiz kılarak farklı ödeme yöntemleri sunar.

virtual anahtar kelimesi, temel sınıf metodunun geçersiz kılınabileceğini belirtirken, override anahtar kelimesi türetilmiş sınıfta metodu geçersiz kılmak için kullanılır.

Sonuç

Kalıtım, nesne yönelimli programlamanın güçlü bir özelliği olup, yazılım geliştirme sürecini daha verimli ve yönetilebilir hale getirir. Temel sınıflar ve türetilmiş sınıflar arasındaki ilişkiler, kod tekrarını azaltırken, özelleştirilmiş davranışlar eklemek için esneklik sağlar. Kalıtımın sağladığı bu yapıyı doğru kullanmak, yazılımın bakımını kolaylaştırır ve kodun okunabilirliğini artırır. Bununla birlikte, kalıtım türlerine karar verirken dikkat edilmesi gereken bazı hususlar vardır; örneğin, çoklu kalıtımın karmaşıklığı veya zincirleme kalıtımın mantıksal tutarsızlıklar yaratma potansiyeli gibi. Doğru bir tasarım yaparak, yazılımın sürdürülebilirliğini ve esnekliğini en üst seviyeye çıkarabiliriz.

Referanslar

Martin, R. C. (2008). Clean Code: A Handbook of Agile Software Craftsmanship.

Meyer, B. (1997). Object-Oriented Software Construction (2nd ed.).

Inheritance - derive types to create more specialized behavior