---
# System prepended metadata

title: Untitled

---

# LESSON 2
## 1. Lập Trình Hướng Đối Tượng trong PHP
Lập trình hướng đối tượng (OOP - Object-Oriented Programming) là một mô hình lập trình tổ chức code thành các đối tượng (objects), thay vì chỉ sử dụng các hàm (functions) và biến (variables). OOP giúp mã dễ đọc, dễ bảo trì và tái sử dụng.

PHP hỗ trợ đầy đủ OOP với các khái niệm cơ bản như class, object, inheritance (kế thừa), polymorphism (đa hình), encapsulation (đóng gói).

## 2. Các Thành Phần Cơ Bản trong OOP PHP
### 2.1. Class và Object
####  Class: Là một khuôn mẫu (template) để tạo ra các đối tượng.
#### Object: Là một thể hiện (instance) của class.

``` PHP
<?php
class Car {
    // Thuộc tính (properties)
    public $brand;
    public $color;

    // Phương thức (methods)
    public function showInfo() {
        return "Hãng xe: " . $this->brand . ", Màu: " . $this->color;
    }
}

// Tạo đối tượng từ class
$car1 = new Car();
$car1->brand = "Toyota";
$car1->color = "Đỏ";

echo $car1->showInfo(); // Output: Hãng xe: Toyota, Màu: Đỏ
?>

```

### 2.2. Constructor (Hàm Khởi Tạo)
Hàm __construct() tự động chạy khi tạo đối tượng.

``` PHP
<?php
class Car {
    public $brand;
    public $color;

    // Constructor
    public function __construct($brand, $color) {
        $this->brand = $brand;
        $this->color = $color;
    }

    public function showInfo() {
        return "Hãng xe: " . $this->brand . ", Màu: " . $this->color;
    }
}

// Tạo đối tượng và truyền tham số vào constructor
$car2 = new Car("Honda", "Xanh");
echo $car2->showInfo(); // Output: Hãng xe: Honda, Màu: Xanh
?>

```

### 2.3. Phạm Vi Truy Cập (Access Modifiers)
#### Có 3 loại phạm vi truy cập:

public: Có thể truy cập ở bất kỳ đâu.
private: Chỉ truy cập được trong class chứa nó.
protected: Truy cập được trong class chứa nó và các class con.

``` PHP
<?php
class Car {
    public $brand; // Ai cũng có thể truy cập
    private $price; // Chỉ có thể truy cập bên trong class

    public function __construct($brand, $price) {
        $this->brand = $brand;
        $this->price = $price;
    }

    // Hàm getter để lấy giá (vì price là private)
    public function getPrice() {
        return $this->price;
    }
}

$car3 = new Car("Ford", 20000);
echo $car3->brand; // OK
echo $car3->getPrice(); // OK
// echo $car3->price; // Lỗi: Không thể truy cập thuộc tính private
?>

```

## 3. Tính Chất Của OOP
### 3.1. Kế Thừa (Inheritance)
Kế thừa giúp một class có thể sử dụng lại code từ class khác.

``` PHP
<?php
class Vehicle {
    public $brand;
    public $speed;

    public function __construct($brand, $speed) {
        $this->brand = $brand;
        $this->speed = $speed;
    }

    public function showInfo() {
        return "Hãng: " . $this->brand . ", Tốc độ: " . $this->speed . "km/h";
    }
}

// Class Car kế thừa từ Vehicle
class Car extends Vehicle {
    public $seats;

    public function __construct($brand, $speed, $seats) {
        parent::__construct($brand, $speed); // Gọi constructor của lớp cha
        $this->seats = $seats;
    }

    public function showCarInfo() {
        return parent::showInfo() . ", Số ghế: " . $this->seats;
    }
}

$car4 = new Car("BMW", 250, 4);
echo $car4->showCarInfo();
?>
```

### 3.2. Đa Hình (Polymorphism)
Đa hình cho phép một phương thức có thể hoạt động khác nhau tùy theo từng class.

``` PHP
<?php
class Animal {
    public function makeSound() {
        return "Âm thanh chung";
    }
}

class Dog extends Animal {
    public function makeSound() {
        return "Gâu gâu";
    }
}

class Cat extends Animal {
    public function makeSound() {
        return "Meo meo";
    }
}

$dog = new Dog();
$cat = new Cat();

echo $dog->makeSound(); // Output: Gâu gâu
echo $cat->makeSound(); // Output: Meo meo
?>

```

### 3.3. Đóng Gói (Encapsulation)
Đóng gói giúp bảo vệ dữ liệu bằng cách sử dụng private và protected, đồng thời cung cấp các phương thức (getter/setter) để truy cập.

``` PHP
<?php
class BankAccount {
    private $balance;

    public function __construct($balance) {
        $this->balance = $balance;
    }

    public function getBalance() {
        return $this->balance;
    }

    public function deposit($amount) {
        $this->balance += $amount;
    }

    public function withdraw($amount) {
        if ($amount > $this->balance) {
            return "Không đủ tiền!";
        }
        $this->balance -= $amount;
    }
}

$account = new BankAccount(500);
$account->deposit(200);
$account->withdraw(100);
echo $account->getBalance(); // Output: 600
?>

```

### 4. Interface và Abstract Class
#### 4.1. Interface
Interface định nghĩa các phương thức mà class con phải triển khai.

``` PHP
<?php
interface Animal {
    public function makeSound();
}

class Dog implements Animal {
    public function makeSound() {
        return "Gâu gâu";
    }
}

$dog = new Dog();
echo $dog->makeSound(); // Output: Gâu gâu
?>
```

#### 4.2. Abstract Class
Abstract class giống class bình thường nhưng không thể tạo đối tượng và có thể chứa phương thức trừu tượng (không có nội dung).

``` PHP
<?php
abstract class Animal {
    abstract public function makeSound(); // Phương thức trừu tượng

    public function move() {
        return "Di chuyển";
    }
}

class Bird extends Animal {
    public function makeSound() {
        return "Chíp chíp";
    }
}

$bird = new Bird();
echo $bird->makeSound(); // Output: Chíp chíp
?>
```


