PHP-இல் classes மற்றும் objects எவ்வாறு செயல்படுகின்றன?

Question

Accepted Answer

PHP முழு **object-oriented programming** ஆதரவைக் கொண்டுள்ளது: classes கட்டமைப்பு மற்றும் நடத்தையை வரையறுக்கின்றன, objects உদாரணங்கள். நவீன PHP OOP சுத்தமாகவும் அம்சங்களில் செறிந்ததாகவும் உள்ளது, visibility modifiers, constructors, மற்றும் constructor property promotion போன்ற வசதிகள் உள்ளன.

## Class வரையறுத்தல்

```php
<?php
class User {
    public string $name;            // typed property
    private int $age;                // visibility: public / private / protected

public function __construct(string $name, int $age) {   // constructor
        $this->name = $name;          // $this refers to the instance; -> accesses members
        $this->age = $age;
    }

public function greet(): string {
        return "Hi, I'm {$this->name}";
    }
}

$user = new User("Ann", 30);     // create an instance
echo $user->name;                 // access a property
echo $user->greet();              // call a method
```

Classes **typed properties**, `__construct` method, மற்றும் methods களைக் கொண்டுள்ளன. `$this` தற்போதைய object ஐ குறிப்பிடுகிறது, மற்றும் `->` properties/methods களை அணுகுகிறது (PHP `->` ஐ பயன்படுத்துகிறது, `.` ஐ அல்ல).

## Visibility modifiers (encapsulation)

```php
public    // accessible everywhere
private   // only within THIS class
protected // this class and subclasses
```

## Constructor property promotion (PHP 8 — குறைந்த boilerplate)

```php
class User {
    // declare AND assign properties directly in the constructor signature
    public function __construct(
        public string $name,
        private int $age = 0,
    ) {}
    // equivalent to declaring the properties + assigning them — much less code
}
```

PHP 8 இன் **constructor property promotion** மீண்டும் மீண்டும் வரும் declare-then-assign boilerplate ஐ நீக்குகிறது — ஒரு முக்கிய நவீன வசதி.

## Static members மற்றும் constants

```php
class Counter {
    public static int $count = 0;      // belongs to the CLASS, not instances
    const MAX = 100;                    // class constant

public static function increment(): void {
        self::$count++;                  // access static via self::
    }
}
Counter::increment();                    // call via ClassName::
Counter::MAX;
```

Static members (`::` syntax) class க்கு சொந்தமானவை; constants `const` ஐ பயன்படுத்துகின்றன.

## ஏன் இது முக்கியமானது

Object-oriented programming நவீன PHP இன் மையமாகும் — frameworks (Laravel, Symfony) மற்றும் தொழில்முறை codebases classes வைச் சுற்றிக் கட்டப்பட்டுள்ளன, எனவே PHP OOP ஐ புரிந்துகொள்வது எந்தவொரு தீவிரமான PHP development க்கும் அடிப்படையாகும்.

Typed properties, constructors, மற்றும் methods களுடன் classes ஐ வரையறுப்பது, **visibility modifiers** (`public`/`private`/`protected`) ஐ encapsulation ஐ செயல்படுத்துவது, `$this`/`->`/`::` syntax, மற்றும் static members/constants ஐ தெரிந்துகொள்வது அவசிய தினசரி அறிவு.

நவீன வசதிகள் குறிப்பாக தெரிந்துகொள்ளுவதற்கு மதிப்பு வாய்ந்தவை — **constructor property promotion** (PHP 8) boilerplate ஐ வியத்தகு முறையில் குறைக்கிறது மற்றும் தற்போதைய code இல் பரவலாகப் பயன்படுத்தப்படுகிறது, மற்றும் **typed properties** classes ஐ மேலும் வலுவாக்குகின்றன.

நவீன PHP OOP சுத்தமாகவும் திறமையாகவும் உள்ளது (PHP இன் ஆரம்பகால நடைமுறை நற்சீர்திருத்தத்திலிருந்து வெகு தூரம்), மற்றும் அனைத்து நவீன PHP frameworks மற்றும் applications object-oriented ஆக இருப்பதால், classes மற்றும் objects ஐ தேர்ச்சி பெறுவது — PHP-specific syntax மற்றும் நவீன அம்சங்கள் உட்பட — தொழில்முறை PHP எழுதுவதற்கான அடிப்படை, அவசியமான அறிவு.