OOP Mastery: Tính Trừu tượng – Abstraction trong Kotlin

OOP Mastery là chuỗi bài viết tự học Lập trình hướng đối tượng với ngôn ngữ Kotlin được biên soạn tại DanTech0xFF. Mục đích của chuỗi bài viết này là cung cấp cái nhìn toàn diện về Hướng đối tượng trong ngôn ngữ Kotlin. Đây sẽ là nền tảng vững chắc cho Lập trình viên trong tương lai nếu các bạn đi sâu về mảng Android, Mobile Cross Platform, hoặc Backend Java.

• Part 1: OOP Mastery: Các loại Class, Interface trong Kotlin
• Part 2: OOP Mastery: Encapsulation trong Kotlin
• Part 3: OOP Mastery: Inheritance trong Kotlin
• Part 4: OOP Mastery: Tính đa hình – Polymorphism trong Kotlin
• Part 5: OOP Mastery: Tính Trừu tượng – Abstraction trong Kotlin

Trong bài viết này chúng ta sẽ phân tích Tính Trừu tượng của OOP trong ngôn ngữ lập trình Kotlin.

Nhắc lại tính Trừu tượng

Tính trừu tượng – 1 đặc tính thú vị trong cách tiếp cận của lập trình hướng đối tượng.

Tính trừu tượng – abstraction được thể hiện thông qua việc khi thiết kế các tính năng của phần mềm các Lập trình viên sẽ tập trung vào việc thiết kế luồng làm việc của các hành vi (behaviour / method) rồi từ đó phân chia ra các Class mà chưa đi sâu vào các chi tiết cụ thể. Các Class được thiết kế ở giai đoạn này gọi là Abstract Class, hoặc cũng có thể gọi là Interface trong 1 vài trường hợp.

Abstraction trong Kotlin

Tính đa hình của OOP trong Kotlin thể hiện qua Interface và Abstract Class. Mình đã có nhắc tới trong bài viết về Tính đa hình trong Kotlin

Kotlin cung cấp giải pháp Interface và Abstract class để Lập trình viên có thể định nghĩa các giao diện rỗng trong quá trình thiết kế trước khi đi sâu vào hiện thực hóa (implementation)

interface MyInterface {
    val name: String // interface của Kotlin có thể chứa member variable
    fun myFunction() {
    // interface của Kotlin có thể chứa hàm đã được định nghĩa sẵn
        println("Hello from MyInterface")
    }
    // interface của Kotlin có thể chứa hàm chưa được định nghĩa
    fun myEmptyFunction()
}

abstract class MyAbstractClass {
    open val name: String = "Name"
    abstract val age: Int
    abstract fun myFunction()
    open fun myOpenFunction() {
        println("Hello from myEmptyFunction")
    }
    fun myNormalFunction() {
        println("Hello from myNormalFunction")
    }
}

Cách khai báo Interface và Abstract class trong Kotlin

Các lợi ích của việc tận dung Abstraction trong Kotlin

Việc thành thạo abstraction và tận dụng nó trong quá trình phát triển phần mềm là yêu cầu bắt buộc cho Lập trình viên.

Mục đích của abstraction là giúp các luồng logic sẽ dễ mở rộng, dễ triển khai trong quá trình phát triển phần mềm. Điều này thể hiện chặt chẽ trong các nguyên tắc của SOLID Principles

Ví dụ thực tế: Thiết kế giải pháp lưu trữ và đọc file nhạc cho ứng dụng Spotify. Yêu cầu phải mã hóa để đảm bảo tính an toàn dữ liệu.

Trong trường hợp này chúng ta chưa tìm ra một giải pháp cụ thể cho việc sẽ sử dụng thuật toán mã hóa nào, nếu cứ tiếp tục tìm kiếm thuật toán mã hóa thì việc development sẽ tiếp tục bị treo. Giải pháp lúc này là Abstraction.

• Bước 1, thiết kế ra Interface chung cho việc mã hóa, giải mã file âm nhạc

interface ICrypto {
  fun encrypt(arr: ByteArray): ByteArray
  fun decrypt(arr: ByteArray): ByteArray
}

• Bước 2, implement một giải pháp đơn giản tích hợp vào mã nguồn

class DummyCrypto : ICrypto {
  fun encrypt(arr: ByteArray): ByteArray {
    return arr
  }
  fun encrypt(arr: ByteArray): ByteArray {
    return arr
  }
}

• Bước 3, phát triển các phương án mã hóa, giải mã

class CryptoSolution1 : ICrypto {
    fun encrypt(arr: ByteArray): ByteArray {
      // implement logic for the Solution1
    }
    fun encrypt(arr: ByteArray): ByteArray {
      // implement logic for the Solution1
    }
}

class CryptoSolution2 : ICrypto {
    fun encrypt(arr: ByteArray): ByteArray {
      // implement logic for the Solution 2
    }
    fun encrypt(arr: ByteArray): ByteArray {
      // implement logic for the Solution 2
    }
}

• Bước 4, Test chúng

class CryptoSolution1Test {
  // write unit test for CryptoSolution1
}
class CryptoSolution2Test {
  // write unit test for CryptoSolution2
}

• Bước 5, Release sản phẩm

Bạn có thể thấy nhờ tính đa hình chúng ta có thể dễ dàng thay thế được DummyCrypto bằng các CryptoSolution1 hoặc CryptoSolution2. Đây chính là điểm mạnh của đa hình. Ngoài ra trong suốt quá trình phát triển, các Solution đều diễn ra độc lập với nhau nên việc testing cũng trở nên dễ dàng hơn, điều đó khiến cho tính năng được tin cậy cao khi release.

Vậy là mình đã chia sẻ dầy đủ 4 tính chất của Lập trình hướng đối tượng trong Kotlin. Rất mong bạn có thể học được gì đó thú vị từ chuỗi bài viết này.

Chúc bạn thành công!