Khóa học python

Inner Classes trong Python

0 phút đọc

Inner classes, hay còn gọi là nested classes, là các lớp được định nghĩa bên trong một lớp khác. Inner classes thường được sử dụng để nhóm các lớp có liên quan với nhau, giúp mã nguồn trở nên gọn gàng và dễ quản lý hơn. Inner classes có thể truy cập các thuộc tính và phương thức của lớp bao ngoài (outer class), và ngược lại, lớp bao ngoài cũng có thể truy cập các thuộc tính và phương thức của inner class.

Tại Sao Sử Dụng Inner Classes?

  • Tổ Chức Mã Nguồn: Inner classes giúp tổ chức mã nguồn tốt hơn bằng cách nhóm các lớp có liên quan với nhau.
  • Tính Bao Đóng: Inner classes có thể truy cập các thuộc tính và phương thức của lớp bao ngoài, giúp tăng tính bao đóng và bảo mật.
  • Tính Độc Lập: Inner classes có thể được sử dụng để tạo ra các lớp độc lập mà không cần phải khai báo chúng ở cấp độ module.

Cú Pháp của Inner Classes

Để định nghĩa một inner class trong Python, bạn chỉ cần định nghĩa một lớp bên trong một lớp khác. Dưới đây là cú pháp cơ bản:

class OuterClass:
    class InnerClass:
        # Định nghĩa các thuộc tính và phương thức của InnerClass
        pass

    # Định nghĩa các thuộc tính và phương thức của OuterClass
    pass

Ví Dụ về Inner Classes

Ví Dụ 1: Hệ Thống Quản Lý Sinh Viên

Giả sử bạn đang xây dựng một hệ thống quản lý sinh viên. Bạn có thể sử dụng inner classes để nhóm các lớp có liên quan với nhau, chẳng hạn như lớp Student và lớp Address.

class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age
        self.address = self.Address()

    def display(self):
        print(f"Name: {self.name}, Age: {self.age}")
        self.address.display()

    class Address:
        def __init__(self):
            self.street = "123 Main St"
            self.city = "Hometown"
            self.zipcode = "12345"

        def display(self):
            print(f"Address: {self.street}, {self.city}, {self.zipcode}")

# Tạo một đối tượng Student
student = Student("Alice", 20)

# Gọi phương thức display
student.display()

Kết Quả:

Name: Alice, Age: 20
Address: 123 Main St, Hometown, 12345

Trong ví dụ trên, lớp Address được định nghĩa bên trong lớp Student. Điều này giúp nhóm các thông tin liên quan đến sinh viên lại với nhau, làm cho mã nguồn trở nên gọn gàng và dễ quản lý hơn.

Ví Dụ 2: Hệ Thống Quản Lý Ngân Hàng

Giả sử bạn đang xây dựng một hệ thống quản lý ngân hàng. Bạn có thể sử dụng inner classes để nhóm các lớp có liên quan với nhau, chẳng hạn như lớp Bank và lớp Account.

class Bank:
    def __init__(self, name):
        self.name = name
        self.accounts = []

    def add_account(self, account_number, balance):
        account = self.Account(account_number, balance)
        self.accounts.append(account)

    def display_accounts(self):
        print(f"Bank: {self.name}")
        for account in self.accounts:
            account.display()

    class Account:
        def __init__(self, account_number, balance):
            self.account_number = account_number
            self.balance = balance

        def display(self):
            print(f"Account Number: {self.account_number}, Balance: {self.balance}")

# Tạo một đối tượng Bank
bank = Bank("MyBank")

# Thêm các tài khoản vào ngân hàng
bank.add_account("123456", 1000)
bank.add_account("789012", 2000)

# Hiển thị thông tin các tài khoản
bank.display_accounts()

Kết Quả:

Bank: MyBank
Account Number: 123456, Balance: 1000
Account Number: 789012, Balance: 2000

Trong ví dụ trên, lớp Account được định nghĩa bên trong lớp Bank. Điều này giúp nhóm các thông tin liên quan đến ngân hàng lại với nhau, làm cho mã nguồn trở nên gọn gàng và dễ quản lý hơn.

Truy Cập Các Thuộc Tính và Phương Thức của Inner Class

Inner classes có thể truy cập các thuộc tính và phương thức của lớp bao ngoài. Để làm điều này, bạn cần truyền một tham chiếu của lớp bao ngoài vào inner class.

Ví Dụ

class Outer:
    def __init__(self, value):
        self.value = value
        self.inner = self.Inner(self)

    def display(self):
        print(f"Outer value: {self.value}")
        self.inner.display()

    class Inner:
        def __init__(self, outer_instance):
            self.outer_instance = outer_instance

        def display(self):
            print(f"Inner accessing outer value: {self.outer_instance.value}")

# Tạo một đối tượng Outer
outer = Outer(10)

# Gọi phương thức display
outer.display()

Kết Quả:

Outer value: 10
Inner accessing outer value: 10

Trong ví dụ trên, inner class Inner truy cập thuộc tính value của lớp bao ngoài Outer thông qua tham chiếu outer_instance.

Sử Dụng Inner Classes để Tạo Các Lớp Độc Lập

Inner classes có thể được sử dụng để tạo ra các lớp độc lập mà không cần phải khai báo chúng ở cấp độ module. Điều này giúp giảm sự lộn xộn trong mã nguồn và tăng tính bao đóng.

Ví Dụ

class Car:
    def __init__(self, make, model):
        self.make = make
        self.model = model
        self.engine = self.Engine()

    def display(self):
        print(f"Car: {self.make} {self.model}")
        self.engine.display()

    class Engine:
        def __init__(self):
            self.horsepower = 300

        def display(self):
            print(f"Engine horsepower: {self.horsepower}")

# Tạo một đối tượng Car
car = Car("Toyota", "Camry")

# Gọi phương thức display
car.display()

Kết Quả:

Car: Toyota Camry
Engine horsepower: 300

Trong ví dụ trên, lớp Engine được định nghĩa bên trong lớp Car. Điều này giúp nhóm các thông tin liên quan đến xe hơi lại với nhau, làm cho mã nguồn trở nên gọn gàng và dễ quản lý hơn.

Sử Dụng Inner Classes để Tạo Các Lớp Liên Quan

Inner classes có thể được sử dụng để tạo ra các lớp liên quan với nhau, giúp tăng tính bao đóng và bảo mật.

Ví Dụ

class Computer:
    def __init__(self, brand):
        self.brand = brand
        self.cpu = self.CPU()
        self.memory = self.Memory()

    def display(self):
        print(f"Computer brand: {self.brand}")
        self.cpu.display()
        self.memory.display()

    class CPU:
        def __init__(self):
            self.cores = 4
            self.speed = "3.5 GHz"

        def display(self):
            print(f"CPU: {self.cores} cores, {self.speed}")

    class Memory:
        def __init__(self):
            self.size = "16 GB"

        def display(self):
            print(f"Memory: {self.size}")

# Tạo một đối tượng Computer
computer = Computer("Dell")

# Gọi phương thức display
computer.display()

Kết Quả:

Computer brand: Dell
CPU: 4 cores, 3.5 GHz
Memory: 16 GB

Trong ví dụ trên, các lớp CPUMemory được định nghĩa bên trong lớp Computer. Điều này giúp nhóm các thông tin liên quan đến máy tính lại với nhau, làm cho mã nguồn trở nên gọn gàng và dễ quản lý hơn.

Kết Luận

Inner classes là một công cụ mạnh mẽ trong Python, giúp tổ chức mã nguồn tốt hơn, tăng tính bao đóng và bảo mật, và tạo ra các lớp độc lập hoặc liên quan với nhau. Bằng cách sử dụng inner classes, bạn có thể nhóm các lớp có liên quan lại với nhau, làm cho mã nguồn trở nên gọn gàng và dễ quản lý hơn.

Hy vọng bài viết này đã giúp bạn hiểu rõ hơn về inner classes trong Python và cách sử dụng chúng để đạt được mục tiêu của bạn.

Avatar
Được viết bởi

TechMely Team

Gợi ý câu hỏi phỏng vấn

entry

Liệt kê các kiểu dữ liệu trong Python?

entry

Biến cục bộbiến toàn cục trong Python là gì?

entry

Trong Python có những built-in types nào?

Bình luận

Chưa có bình luận nào

Chưa có bình luận nào