การใช้งาน Inheritance ใน OOP Concept ในภาษา Delphi Object Pascal

การเขียนโปรแกรมที่เป็นเชิงวัตถุ (Object-Oriented Programming - OOP) ถือเป็นสิ่งที่สำคัญมากในวงการพัฒนาโปรแกรมปัจจุบัน โดยกระบวนการทำงานหลักๆ ที่ OOP ใช้นั้นคือการสร้างความสัมพันธ์ระหว่างวัตถุ (Object) ต่างๆ และการสืบทอดคุณสมบัติ (Inheritance) เป็นหนึ่งในหลักการที่ช่วยให้การเขียนโปรแกรมมีความยืดหยุ่นและสามารถนำกลับมาใช้ได้ใหม่ เช่นเดียวกับภาษา Delphi Object Pascal ที่รองรับ OOP อย่างเต็มที่ บทความนี้จะอธิบายการใช้งานมรดก (Inheritance) ใน Delphi พร้อมตัวอย่างโค้ดและใช้เคสในโลกจริง

ปูพื้นฐานเกี่ยวกับ Inheritance

Inheritance หรือมรดกใน OOP เป็นกระบวนการที่ช่วยให้คลาส (Class) หนึ่งสามารถสืบทอดคุณสมบัติและพฤติกรรม (Methods) จากคลาสอื่นได้ โดยการดำเนินการนี้จะช่วยลดความซ้ำซ้อนของโค้ด และทำให้การพัฒนาโปรแกรมมีประสิทธิภาพมากขึ้น ณ จุดนี้เรามักจะพูดถึง "คลาสแม่" (Base Class หรือ Parent Class) และ "คลาสลูก" (Derived Class หรือ Child Class) ซึ่งคลาสลูกจะสามารถเข้าถึงฟังก์ชันและคุณสมบัติจากคลาสแม่ได้

การสร้างคลาสใน Delphi

ก่อนที่เราจะดำเนินการกับ inheritance เรามาเริ่มกันด้วยการสร้างคลาสหลักกันก่อนค่ะ

 type
  TAnimal = class
  public
    procedure Speak; virtual; // ประกาศฟังก์ชัน Speak ให้สามารถ Override ได้
  end;

procedure TAnimal.Speak;
begin
  WriteLn('Animal speaks'); // ฟังก์ชัน Speak ในคลาสแม่
end;

ในตัวอย่างข้างต้น เราได้สร้างคลาส `TAnimal` ซึ่งประกอบด้วยฟังก์ชัน `Speak` ซึ่งเป็นฟังก์ชันเสมือน (virtual) เพื่อให้คลาสลูกสามารถ Override และกำหนดพฤติกรรมใหม่ได้

การสืบทอดคลาส

ต่อไปเราจะสร้างคลาสลูกซึ่งสืบทอดจาก `TAnimal`

 type
  TDog = class(TAnimal)
  public
    procedure Speak; override; // Override ฟังก์ชัน Speak
  end;

procedure TDog.Speak;
begin
  WriteLn('Dog barks'); // ฟังก์ชัน Speak ของคลาสลูก
end;

ในตัวอย่างนี้ เราได้กำหนดคลาส `TDog` ซึ่งสืบทอดมาจาก `TAnimal` และทำการ Override ฟังก์ชัน `Speak` เพื่อทำให้แสดงผล ‘Dog barks’ แทน

การใช้งาน

ตอนนี้เรามาดูการสร้างออบเจ็กต์และเรียกใช้งานฟังก์ชัน `Speak` กันค่ะ

 var
  animal: TAnimal;
  dog: TDog;
begin
  animal := TAnimal.Create;
  try
    animal.Speak; // แสดงผล: Animal speaks
  finally
    animal.Free;
  end;

  dog := TDog.Create;
  try
    dog.Speak; // แสดงผล: Dog barks
  finally
    dog.Free;
  end;
end;

ในส่วนนี้เราจะสร้างออบเจ็กต์ `animal` และ `dog` โดยอ้างอิงจากคลาส `TAnimal` และ `TDog` ตามลำดับ เราจะเห็นว่าการเรียกใช้ `Speak` จะให้ผลลัพธ์ที่แตกต่างกันตามประเภทของออบเจ็กต์ที่เราใช้

Use Case ในโลกจริง

การใช้ inheritance สามารถนำไปใช้ในหลากหลายสถานการณ์ ตัวอย่างเช่น ในโลกของการพัฒนาแอปพลิเคชันที่เกี่ยวข้องกับการจัดการสัตว์ สถานที่เลี้ยงสัตว์อาจมีการสร้างคลาสต่างๆ เช่น `TAnimal`, `TDog`, `TCat` เป็นต้น ซึ่งแต่ละคลาสจะมีฟังก์ชัน `Speak` ที่แตกต่างกันออกไป การสืบทอดจะช่วยให้เราไม่ต้องเขียนฟังก์ชันที่ซ้ำซ้อนสำหรับคลาสต่างๆ และสามารถเรียกใช้งานได้ง่าย ทีมพัฒนาจึงสามารถปรับแก้ไขและขยายฟังก์ชันต่างๆ ในอนาคตได้ง่ายดาย

สรุป

การใช้งาน inheritance เป็นแนวทางที่มีประสิทธิภาพในการเขียนโปรแกรมเชิงวัตถุ โดยเฉพาะเมื่อเรามีคลาสที่มีความสัมพันธ์หรือคุณสมบัติคล้ายกัน การสืบทอดจะช่วยให้เราสามารถจัดการโค้ดได้ง่ายขึ้น, ลดความซ้ำซ้อน และทำให้โปรแกรมมีโครงสร้างที่ชัดเจน

สำหรับใครที่สนใจเรียนรู้การเขียนโปรแกรมเพื่อพัฒนาทักษะด้านการพัฒนาโปรแกรม ควรพิจารณาศึกษาเพิ่มเติม โดยเฉพาะการเรียนรู้ภาษาที่หลากหลายและแนวคิด OOP ที่มีอยู่ใน EPT (Expert-Programming-Tutor) ซึ่งจะมีการสอนเทคนิคและแนวทางการเขียนโปรแกรมในรูปแบบที่สนุกสนานและมีประสิทธิภาพมากมาย

ห้ามพลาด! มาร่วมสนุกไปกับการเรียนรู้และพัฒนาโปรแกรมที่ EPT กันเถอะ!

หมายเหตุ: ข้อมูลในบทความนี้อาจจะผิด โปรดตรวจสอบความถูกต้องของบทความอีกครั้งหนึ่ง บทความนี้ไม่สามารถนำไปใช้อ้างอิงใด ๆ ได้ ทาง EPT ไม่ขอยืนยันความถูกต้อง และไม่ขอรับผิดชอบต่อความเสียหายใดที่เกิดจากบทความชุดนี้ทั้งทางทรัพย์สิน ร่างกาย หรือจิตใจของผู้อ่านและผู้เกี่ยวข้อง