9.1 การออกแบบโครงสร้างโปรแกรมขนาดใหญ่โดยใช้ OOP 

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

หลักการสำคัญของ OOP ในการออกแบบโปรแกรมขนาดใหญ่

การออกแบบโปรแกรมเชิงวัตถุใช้หลักการสำคัญที่ประกอบด้วย 4 ส่วนหลัก ได้แก่:

1. Abstraction (นามธรรม): การสร้างนามธรรมเป็นการแยกความซับซ้อนออกจากรายละเอียดที่ไม่จำเป็น ทำให้เราสามารถสร้างคลาส (class) ที่มีคุณสมบัติและพฤติกรรมที่สำคัญต่อโปรแกรมได้ โดยรายละเอียดภายในคลาสจะถูกซ่อนและเปิดเผยเฉพาะฟังก์ชันการทำงานที่จำเป็นต่อการใช้งาน

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

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

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

กระบวนการออกแบบโปรแกรมขนาดใหญ่โดยใช้ OOP

การออกแบบโปรแกรมขนาดใหญ่โดยใช้ OOP ประกอบไปด้วยขั้นตอนสำคัญ ดังนี้:

1. การวิเคราะห์ความต้องการของระบบ

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

2. การระบุคลาสและอ็อบเจกต์ที่จำเป็น

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

ตัวอย่างเช่น หากเรากำลังออกแบบระบบจองห้องพักของโรงแรม คลาสที่จำเป็นอาจประกอบไปด้วย Hotel, Room, Guest, และ Reservation โดยแต่ละคลาสจะมีคุณสมบัติและพฤติกรรมของตัวเอง เช่น Room อาจมีคุณสมบัติของห้องพัก เช่น หมายเลขห้อง และประเภทห้อง ส่วน Reservation จะมีพฤติกรรมในการตรวจสอบสถานะการจองและการจัดการการจอง

3. การกำหนดความสัมพันธ์ระหว่างคลาส

เมื่อระบุคลาสที่จำเป็นแล้ว เราต้องวิเคราะห์ว่าคลาสเหล่านี้มีความสัมพันธ์กันอย่างไรบ้าง เช่น:

• ความสัมพันธ์แบบการสืบทอด (Inheritance) เช่น คลาส Employee อาจสืบทอดจากคลาส Person

• ความสัมพันธ์แบบการใช้งาน (Association) เช่น คลาส Reservation มีความสัมพันธ์กับคลาส Guest ซึ่งหมายถึงการใช้งานของคลาสนี้ร่วมกัน

• ความสัมพันธ์แบบการบรรจุ (Composition) เช่น คลาส Hotel อาจมีหลายคลาส Room บรรจุอยู่ภายใน

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

4. การออกแบบอินเทอร์เฟซของคลาส (Class Interface)

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

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

5. การใช้หลักการออกแบบ (Design Patterns)

การออกแบบโปรแกรมขนาดใหญ่มีความซับซ้อนมาก และการใช้ Design Patterns เช่น Factory, Singleton, Observer หรือ MVC (Model-View-Controller) จะช่วยให้โครงสร้างโปรแกรมมีความยืดหยุ่นและสามารถปรับเปลี่ยนหรือเพิ่มเติมได้ง่าย

ตัวอย่างเช่น การใช้ Design Pattern แบบ Factory ในการสร้างอ็อบเจกต์เฉพาะประเภท ทำให้ไม่จำเป็นต้องทราบรายละเอียดของอ็อบเจกต์นั้น และช่วยให้โค้ดดูสะอาดและสามารถขยายโปรแกรมได้ง่าย

6. การทดสอบและปรับปรุง (Testing and Refactoring)

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

ตัวอย่าง การออกแบบโปรแกรมขนาดใหญ่โดยใช้ OOP

ตัวอย่างต่อไปนี้เป็นการออกแบบโครงสร้างของระบบจองห้องพักในโรงแรมโดยใช้ OOP ซึ่งประกอบไปด้วยคลาสหลักที่เกี่ยวข้องกับการจัดการโรงแรมและการจองห้อง

#include <iostream>

#include <string>

#include <vector>

using namespace std;

class Guest {

private:

    string name;

    int guestID;

public:

    Guest(string n, int id) : name(n), guestID(id) {}

    string getName() const { return name; }

    int getGuestID() const { return guestID; }

};

class Room {

private:

    int roomNumber;

    string roomType;

    bool isBooked;

public:

    Room(int number, string type) : roomNumber(number), roomType(type), isBooked(false) {}

    bool getBookingStatus() const { return isBooked; }

    void bookRoom() { isBooked = true; }

    void releaseRoom() { isBooked = false; }

    int getRoomNumber() const { return roomNumber; }

    string getRoomType() const { return roomType; }

};

class Reservation {

private:

    Guest* guest;

    Room* room;

public:

    Reservation(Guest* g, Room* r) : guest(g), room(r) {}

    void makeReservation() {

        if (!room->getBookingStatus()) {

            room->bookRoom();

            cout << "Reservation successful for " << guest->getName() << " in Room " << room->getRoomNumber() << endl;

        } else {

            cout << "Room is already booked." << endl;

        }

    }

    void cancelReservation() {

        room->releaseRoom();

        cout << "Reservation canceled for " << guest->getName() << endl;

    }

};

int main() {

    Guest guest("John Doe", 101);

    Room room(201, "Deluxe");

    Reservation reservation(&guest, &room);

    reservation.makeReservation();

    reservation.cancelReservation();

    return 0;

}

ในตัวอย่างนี้:

• คลาส Guest เป็นตัวแทนของผู้เข้าพักที่มีข้อมูลเกี่ยวกับชื่อและรหัสประจำตัว

• คลาส Room จัดเก็บข้อมูลเกี่ยวกับห้องพัก หมายเลขห้อง ประเภทห้อง และสถานะการจองห้อง

• คลาส Reservation ใช้ในการจัดการการจองห้องพัก โดยทำงานร่วมกับคลาส Guest และ Room เพื่อทำให้การจองและการยกเลิกเป็นไปอย่างราบรื่น