Class và object hoạt động thế nào trong Ruby?

Question

Accepted Answer

Ruby **hướng đối tượng thuần túy** — bạn định nghĩa **class** (bản thiết kế) và tạo **object** (instance). Class dùng `initialize` làm constructor, `@variable` cho trạng thái instance, và access modifier cho đóng gói (encapsulation). Cú pháp class của Ruby sạch và giàu biểu đạt.

## Định nghĩa một class

```ruby
class Person
  def initialize(name, age)    # CONSTRUCTOR (được gọi khi .new)
    @name = name               # @ → biến instance (theo từng object)
    @age = age
  end

def greet                    # một instance method
    "Hi, I'm #{@name}"
  end
end

person = Person.new("Ann", 30)   # tạo một instance (gọi initialize)
person.greet                      # "Hi, I'm Ann"
```

Method `initialize` là constructor (được gọi tự động bởi `.new`), và biến instance `@name` giữ trạng thái theo từng object. Method được định nghĩa bằng `def`.

## Truy cập biến instance (cần method accessor)

```ruby
class Person
  attr_accessor :name           # tạo getter VÀ setter cho @name
  attr_reader :age              # chỉ getter (chỉ đọc)

def initialize(name, age)
    @name = name
    @age = age
  end
end

person.name          # "Ann" — getter
person.name = "Bob"   # setter
```

Biến instance (`@name`) là private theo mặc định — bạn phơi bày chúng bằng method accessor. **`attr_accessor`**/`attr_reader`/`attr_writer` tự động tạo các method getter/setter này (một tiện ích của Ruby).

## Kiểm soát truy cập và class method

```ruby
class Account
  def deposit(amount)       # public theo mặc định
    update_balance(amount)
  end

private                   # các method bên dưới là PRIVATE
  def update_balance(amount)
    @balance += amount
  end

def self.create           # CLASS method (self.) — gọi trên class, không phải instance
    new(...)
  end
end
Account.create              # class method
```

Method là public theo mặc định; `private`/`protected` hạn chế truy cập. `def self.method` định nghĩa một **class method** (gọi trên chính class).

## Tại sao điều này quan trọng

Class và object là nền tảng của Ruby, vốn là ngôn ngữ hướng đối tượng thuần túy, nên hiểu chúng là thiết yếu cho bất kỳ việc phát triển Ruby nào — gần như mọi code Ruby (và các framework như Rails) đều được tổ chức thành class.

Biết cách định nghĩa class với **constructor `initialize`**, dùng **biến `@instance`** cho trạng thái theo từng object (và rằng chúng private theo mặc định, cần method accessor để phơi bày), định nghĩa instance method và **class method** (`def self.method`), và áp dụng kiểm soát truy cập (`private`/`protected`) là kiến thức nền tảng dùng hằng ngày.

Một tiện ích đặc biệt quan trọng của Ruby là **`attr_accessor`/`attr_reader`/`attr_writer`**, tự động tạo method getter/setter cho biến instance — loại bỏ code lặp và phản ánh sự thanh lịch của Ruby (thay vì viết getter/setter tường minh như nhiều ngôn ngữ, bạn khai báo chúng trong một dòng).

Hiểu cú pháp class sạch của Ruby, mô hình constructor và biến instance, method accessor, và class method là tài liệu cốt lõi, phải-biết cho Ruby hướng đối tượng.

Vì class là cách bạn mô hình hóa dữ liệu và hành vi xuyên suốt các ứng dụng Ruby, và vì các tính năng class của Ruby (quy ước `initialize`, biến instance `@`, accessor `attr_*`, kiểm soát public/private) là cách Ruby hướng đối tượng được viết, thành thạo chúng là kiến thức thiết yếu, nền tảng làm cốt lõi cho mọi việc phát triển Ruby và là điểm khởi đầu thường gặp để hiểu bản chất hướng đối tượng của ngôn ngữ.