C# C-Sharp คือ ตอนที่ 6 : การเขียนโปรแกรมเชิงวัตถุ (OOP)

21ก.ค. 2023 by รับทำแอพ สบายไอที

ทำความเข้าใจกับการเขียนโปรแกรมเชิงวัตถุ (Understanding Object-Oriented Programming)
คลาส (Classes)และวัตถุ (Objects)
การสืบทอด (Inheritance)
ความหลากหลาย (Polymorphism)
Encapsulation
Abstraction

รากฐานของกระบวนการทำแอพที่มั่นคงนั้นอยู่ที่การทำความเข้าใจ Object-Oriented Programming (OOP) C# ซึ่งเป็นภาษาแบบสแตติกที่พัฒนาโดย Microsoft มีรากฐานมาจากหลักการ OOP อย่างลึกซึ้ง หลักการเหล่านี้จัดเตรียมพิมพ์เขียวเพื่อทำแอพที่ยืดหยุ่น โมดูลาร์ และปรับขนาดได้

1. ทำความเข้าใจกับการเขียนโปรแกรมเชิงวัตถุ (Understanding Object-Oriented Programming)

การเขียนโปรแกรมเชิงวัตถุเป็นกระบวนทัศน์การเขียนโปรแกรมที่ใช้ “objects” – อินสแตนซ์ของคลาส – เพื่อออกแบบและใช้งานโปรแกรม ออบเจ็กต์ห่อหุ้มทั้งข้อมูล (properties) และพฤติกรรม (methods) แนวคิดพื้นฐานของ OOP ได้แก่ คลาส วัตถุ การสืบทอด ความหลากหลาย การห่อหุ้ม และนามธรรม เราจะเจาะลึกแต่ละรายการในบริบทของ C# และความหมายในการทำแอพ

2. คลาส (Classes)และวัตถุ (Objects)

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

ตัวอย่างเช่น พิจารณาคลาส ‘MobilePhone’ อาจมีคุณสมบัติเช่น ‘brand’ ‘model’ ‘color’ และวิธีการเช่น ‘makeCall()’ ‘sendText()’ เป็นต้น

public class MobilePhone
{
    public string Brand { get; set; }
    public string Model { get; set; }
    public string Color { get; set; }

    public void MakeCall(string number)
    {
        // Code to make a call
    }

    public void SendText(string number, string message)
    {
        // Code to send a text message
    }
}

วัตถุคือตัวอย่างของการเรียน. คุณสามารถสร้างวัตถุโดยใช้คำหลัก ‘new’ ใน C #

MobilePhone myPhone = new MobilePhone();
myPhone.Brand = "Apple";
myPhone.Model = "iPhone 13";
myPhone.Color = "Blue";
myPhone.MakeCall("1234567890");

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

3. การสืบทอด (Inheritance)

การสืบทอด (Inheritance) เป็นกลไกที่สามารถสร้างคลาสใหม่ที่เรียกว่า ‘subclass’ จากคลาสที่มีอยู่ซึ่งเรียกว่า ‘superclass’ หรือ ‘base class’ คลาสย่อยสืบทอดคุณสมบัติและวิธีการทั้งหมดของคลาสพื้นฐาน แต่ยังสามารถขยาย (เพิ่มคุณสมบัติใหม่ไปยัง) และแก้ไข (แทนที่ (override)) คุณสมบัติที่สืบทอดมา

ในบริบทของการทำแอพ การสืบทอดส่งเสริมการนำโค้ดกลับมาใช้ใหม่และการจัดโครงสร้างเชิงตรรกะของโค้ด ตัวอย่างเช่น พิจารณาคลาสพื้นฐาน ‘AppUser’ และ 2 คลาสย่อย ‘FreeUser’ และ ‘PremiumUser’

public class AppUser
{
    public string Name { get; set; }
    public string Email { get; set; }

    public virtual void DisplayBenefits()
    {
        // Display general benefits
    }
}

public class FreeUser : AppUser
{
    public override void DisplayBenefits()
    {
        // Display benefits for free users
    }
}

public class PremiumUser : AppUser
{
    public override void DisplayBenefits()
    {
        // Display benefits for premium users
    }
}

4. ความหลากหลาย (Polymorphism)

ความแตกต่างหลากหลายหมายถึง ‘many forms’ ทำให้วัตถุมีหลายรูปแบบขึ้นอยู่กับประเภทข้อมูลหรือคลาส C# รองรับ polymorphism สองประเภท – เวลาคอมไพล์ (function overloading) และรันไทม์ (function overriding)

การโอเวอร์โหลดฟังก์ชันช่วยให้เมธอดหลายเมธอดที่มีชื่อเดียวกันแต่มีพารามิเตอร์ต่างกัน ในขณะที่การโอเวอร์ไรด์ฟังก์ชันทำให้คลาสย่อยจัดเตรียมการใช้งานที่แตกต่างกันสำหรับเมธอดที่กำหนดไว้แล้วในคลาสพื้นฐาน (ดังที่เห็นในตัวอย่างการสืบทอดก่อนหน้า)

ในการทำแอพ ความหลากหลายให้ความยืดหยุ่นในการใช้วัตถุ คุณสามารถกำหนดเมธอดที่ต้องการวัตถุคลาสพื้นฐาน แต่จัดเตรียมวัตถุคลาสย่อยได้ด้วยหลักการของความหลากหลาย

5. Encapsulation

Encapsulation เป็นแนวคิดของการรวมข้อมูล (properties) และพฤติกรรม (methods) ไว้ในหน่วยเดียว (class) และจำกัดการเข้าถึงข้อมูล การห่อหุ้มทำได้ใน C# โดยใช้ตัวดัดแปลงการเข้าถึง: สาธารณะ (public) ส่วนตัว (private) ป้องกัน (protected) และภายใน (internal)

Encapsulation ช่วยให้มั่นใจได้ว่าวัตถุจะรักษาสถานะภายในได้อย่างถูกต้อง ตัวอย่างเช่น ในแอปพลิเคชัน คุณสามารถมีคลาส ‘BankAccount’ โดยที่ฟิลด์ ‘balance’ เป็นแบบส่วนตัว ยอดคงเหลือสามารถแก้ไขได้ด้วยวิธีการสาธารณะเท่านั้น เช่น ‘Deposit’ และ ‘Withdraw’ ซึ่งสามารถใช้กฎทางธุรกิจที่จำเป็นได้

public class BankAccount
{
    private decimal balance;

    public void Deposit(decimal amount)
    {
        // Business rules for deposit
        balance += amount;
    }

    public void Withdraw(decimal amount)
    {
        // Business rules for withdrawal
        balance -= amount;
    }

    public decimal GetBalance()
    {
        return balance;
    }
}

6. Abstraction

Abstraction เป็นแนวคิดของการซ่อนรายละเอียดการใช้งานที่ซับซ้อนและแสดงเฉพาะคุณสมบัติที่จำเป็นต่อผู้ใช้ C# รองรับสิ่งที่เป็นนามธรรมโดยใช้อินเตอร์เฟสและคลาสนามธรรม

ในการทำแอพ สิ่งที่เป็นนามธรรมสามารถทำให้ซอฟต์แวร์ใช้งานได้ง่ายขึ้นและลดความซับซ้อนลง ตัวอย่างเช่น เมื่อใช้ API เพื่อส่งการแจ้งเตือนทางอีเมล ผู้ใช้ไม่จำเป็นต้องทราบรายละเอียดพื้นฐานของโปรโตคอล SMTP

public interface IEmailService
{
    void SendEmail(string to, string subject, string body);
}

public class SmtpEmailService : IEmailService
{
    public void SendEmail(string to, string subject, string body)
    {
        // Implementation of email sending using SMTP
    }
}

public class AppService
{
    private IEmailService emailService;

    public AppService(IEmailService emailService)
    {
        this.emailService = emailService;
    }

    public void NotifyUser(string email)
    {
        emailService.SendEmail(email, "Notification", "Hello, User!");
    }
}

ในตัวอย่างนี้ AppService ไม่จำเป็นต้องทราบรายละเอียดวิธีการส่งอีเมล เพียงแต่สามารถส่งอีเมลโดยใช้รูปแบบที่ให้มา IEmailService

การเขียนโปรแกรมเชิงวัตถุใน C# นำเสนอเฟรมเวิร์กที่มีประสิทธิภาพสำหรับนักพัฒนาแอปเพื่อทำแอพที่เชื่อถือได้ ใช้ซ้ำได้ และบำรุงรักษาได้ การทำความเข้าใจหลักการเหล่านี้เป็นรากฐานที่แข็งแกร่งสำหรับการเจาะลึกด้านที่ซับซ้อนมากขึ้นของ C# เช่น การเขียนโปรแกรมแบบ async, LINQ หรือ Entity Framework ในขณะที่โลกของการทำแอพยังคงพัฒนาไปอย่างต่อเนื่อง การเรียนรู้หลักการ OOP เหล่านี้อย่างเชี่ยวชาญจะช่วยให้คุณทำแอพที่ซับซ้อนซึ่งทนทานต่อการทดสอบของเวลา