การใช้งาน OOP object oriented programming ในภาษา Kotlin แบบง่ายๆ พร้อมตัวอย่าง CODE 3 ตัวอย่าง และอธิบายการทำงาน และยกตัวอย่าง usecase ในโลกจริง

สวัสดีครับทุกคนในวงการเขียนโปรแกรม! ถ้าคุณได้ยินคำว่า "การเขียนโปรแกรมแบบวัตถุ" หรือ Object-Oriented Programming (OOP) ในภาษา Kotlin แล้วรู้สึกยากลำบากใจ วันนี้ผมมีตัวอย่าง code ในภาษา Kotlin มาให้ศึกษากันครับ พร้อมทั้งการอธิบายขั้นตอนและ usecase ที่จะช่วยคลายความสับสนนั้นให้หายไป!

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

ตัวอย่างที่ 1: การสร้าง Class

ใน Kotlin เราสามารถสร้าง class ซึ่งเป็นแบบแผนหลักของวัตถุได้ง่ายๆ จะเริ่มจาก class ง่ายๆ สำหรับการจัดการกับหนังสือ ดูตัวอย่างโค้ดด้านล่างครับ:

class Book(val title: String, val author: String, var yearOfPublication: Int) {
    fun getBookDetails() {
        println("Book: $title, Author: $author, Published: $yearOfPublication")
    }
}

fun main() {
    val myBook = Book("Learn Kotlin", "Expert Programmer", 2023)
    myBook.getBookDetails()
}

ในโค้ดตัวอย่างข้างต้น, `Book` เป็น class ที่มี attributes ได้แก่ `title`, `author`, และ `yearOfPublication` และมี method เดียวคือ `getBookDetails` ที่ใช้แสดงรายละเอียดของหนังสือออกมา

ตัวอย่างที่ 2: การใช้ Inheritance

Inheritance เป็นแนวคิดหลักของ OOP ที่ช่วยให้ class หนึ่งสามารถ "รับมรดก" คุณสมบัติและการกระทำมาจากอีก class หนึ่ง ว่าแต่ใน Kotlin ต้องประกาศ class ให้เป็น open ก่อนถึงจะสามารถทำ inheritance:

open class Book(val title: String, val author: String) {
    open fun read() {
        println("Reading $title by $author...")
    }
}

class Ebook(title: String, author: String, val format: String): Book(title, author) {
    override fun read() {
        println("Reading $title by $author in $format format...")
    }
}

fun main() {
    val myEbook = Ebook("Learn Kotlin", "Expert Programmer", "PDF")
    myEbook.read() // Output: Reading Learn Kotlin by Expert Programmer in PDF format...
}

ในตัวอย่างนี้ `Ebook` เป็น subclass ของ `Book` เราสามารถ override method `read` ได้เพื่อให้มีพฤติกรรมที่ต่างออกไป

ตัวอย่างที่ 3: การใช้ Polymorphism

Polymorphism ช่วยให้สามารถใช้งาน(class) ในรูปแบบต่างๆ โดยที่ยังคง interface เดียวกัน:

open class Shape {
    open fun draw() {
        println("Drawing a shape...")
    }
}

class Circle : Shape() {
    override fun draw() {
        println("Drawing a circle...")
    }
}

fun main() {
    val myShape: Shape = Circle() // Polymorphism
    myShape.draw() // Output: Drawing a circle...
}

โดยตามตัวอย่างนี้ `Shape` เป็น super class ที่มี method `draw` และ `Circle` เป็น subclass ที่ override method `draw` พอเราประกาศตัวแปรเป็น `Shape` แต่อ้างอิงไปยัง instance ของ `Circle`, มันจะเรียก method `draw` ของ `Circle`, นั่นคือการแสดงถึงความสามารถของ Polymorphism.

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

ถ้าคุณสนใจที่จะศึกษาเพิ่มเติมและต้องการพัฒนาทักษะการเขียนโปรแกรมของคุณ อย่าลืมมาที่ EPT (Expert-Programming-Tutor) นะครับ เรามีหลักสูตรและผู้เชี่ยวชาญที่พร้อมที่จะช่วยคุณเข้าใจศาสตร์แห่งโอบเจ็คต์-โอเรียนเท็ด โปรแกรมมิ่งในภาษา Kotlin และภาษาโปรแกรมมิ่งอื่นๆ อีกมากมายครับ!

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

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