Object-Oriented Programming Basics in PHP

1class User {
2    // Properties (data)
3    public string $name;
4    public string $email;
5    public int $age;
6
7    // Methods (behavior)
8    public function greet(): string {
9        return "Hello, my name is {$this->name}";
10    }
11
12    public function isAdult(): bool {
13        return $this->age >= 18;
14    }
15}

1// Create an object (instance)
2$user = new User();
3
4// Set properties
5$user->name = "John Doe";
6$user->email = "[email protected]";
7$user->age = 30;
8
9// Call methods
10echo $user->greet();  // "Hello, my name is John Doe"
11echo $user->isAdult() ? "Adult" : "Minor";  // "Adult"

1$user1 = new User();
2$user1->name = "Alice";
3$user1->age = 25;
4
5$user2 = new User();
6$user2->name = "Bob";
7$user2->age = 35;
8
9echo $user1->greet();  // "Hello, my name is Alice"
10echo $user2->greet();  // "Hello, my name is Bob"

1class Product {
2    public string $name;
3    public float $price;
4
5    public function applyDiscount(float $percentage): float {
6        // $this->price refers to this object's price
7        return $this->price * (1 - $percentage);
8    }
9
10    public function displayInfo(): string {
11        // Access multiple properties using $this
12        return "{$this->name}: \${$this->price}";
13    }
14}

1class BankAccount {
2    public string $accountNumber;
3    public float $balance;
4    public bool $isActive;
5
6    public function deposit(float $amount): void {
7        $this->balance += $amount;
8    }
9
10    public function getBalance(): float {
11        return $this->balance;
12    }
13}

1class Employee {
2    // Typed properties (PHP 7.4+)
3    public string $firstName;
4    public string $lastName;
5    public int $employeeId;
6    public float $salary;
7    public bool $isFullTime;
8    public ?string $department = null;  // Nullable
9
10    // Array and object properties
11    public array $skills = [];
12    public DateTime $hireDate;
13}

1class Configuration {
2    public string $environment = 'development';
3    public int $timeout = 30;
4    public bool $debug = true;
5    public array $options = [];
6}
7
8$config = new Configuration();
9echo $config->environment;  // "development"

1class Calculator {
2    // Regular method
3    public function add(int $a, int $b): int {
4        return $a + $b;
5    }
6
7    // Method with no return value
8    public function logOperation(string $operation): void {
9        echo "Operation: $operation\n";
10    }
11
12    // Method returning $this for chaining
13    public function reset(): self {
14        // Reset state
15        return $this;
16    }
17
18    // Method with default parameters
19    public function multiply(int $a, int $b = 1): int {
20        return $a * $b;
21    }
22}

1class QueryBuilder {
2    private string $query = "";
3
4    public function select(string $fields): self {
5        $this->query = "SELECT $fields ";
6        return $this;
7    }
8
9    public function from(string $table): self {
10        $this->query .= "FROM $table ";
11        return $this;
12    }
13
14    public function where(string $condition): self {
15        $this->query .= "WHERE $condition";
16        return $this;
17    }
18
19    public function getQuery(): string {
20        return $this->query;
21    }
22}
23
24// Chained method calls
25$query = (new QueryBuilder())
26    ->select('*')
27    ->from('users')
28    ->where('age > 18')
29    ->getQuery();

1class MathHelper {
2    // Static property - shared across all instances
3    public static int $calculationCount = 0;
4
5    // Instance property - unique per object
6    public float $lastResult;
7
8    // Static method - called on class, not object
9    public static function square(float $n): float {
10        self::$calculationCount++;
11        return $n * $n;
12    }
13
14    // Instance method - called on object
15    public function saveResult(float $result): void {
16        $this->lastResult = $result;
17    }
18}
19
20// Static method call
21$squared = MathHelper::square(5);  // 25
22echo MathHelper::$calculationCount;  // 1
23
24// Instance method call
25$helper = new MathHelper();
26$helper->saveResult(25);
27echo $helper->lastResult;  // 25

1class Article {
2    /**
3     * Article title
4     */
5    public string $title;
6
7    /**
8     * Publication date
9     */
10    public DateTime $publishedAt;
11
12    /**
13     * Check if article is published
14     *
15     * @return bool True if published, false otherwise
16     */
17    public function isPublished(): bool {
18        return $this->publishedAt <= new DateTime();
19    }
20
21    /**
22     * Get article excerpt
23     *
24     * @param int $length Maximum length of excerpt
25     * @return string Truncated content
26     */
27    public function getExcerpt(int $length = 100): string {
28        // Implementation
29    }
30}

1class BankAccount {
2    // Public - accessible everywhere
3    public string $accountNumber;
4
5    // Protected - accessible in this class and child classes
6    protected float $balance = 0;
7
8    // Private - accessible only in this class
9    private string $pin;
10
11    public function getBalance(): float {
12        return $this->balance;  // OK - same class
13    }
14}
15
16$account = new BankAccount();
17$account->accountNumber = "123456";  // OK - public
18
19// $account->balance = 1000;  // ERROR - protected
20// $account->pin = "1234";    // ERROR - private

1class Temperature {
2    private float $celsius;
3
4    // Controlled access through public methods
5    public function setCelsius(float $temp): void {
6        if ($temp < -273.15) {
7            throw new InvalidArgumentException(
8                "Temperature cannot be below absolute zero"
9            );
10        }
11        $this->celsius = $temp;
12    }
13
14    public function getCelsius(): float {
15        return $this->celsius;
16    }
17
18    public function getFahrenheit(): float {
19        return ($this->celsius * 9/5) + 32;
20    }
21}
22
23$temp = new Temperature();
24$temp->setCelsius(25);  // Validated
25echo $temp->getFahrenheit();  // 77
26
27// $temp->celsius = -500;  // ERROR - private, validation bypassed

1class User {
2    private string $email;
3    private int $age;
4    private array $roles = [];
5
6    // Getter - read access
7    public function getEmail(): string {
8        return $this->email;
9    }
10
11    // Setter with validation
12    public function setEmail(string $email): void {
13        if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
14            throw new InvalidArgumentException("Invalid email");
15        }
16        $this->email = strtolower($email);
17    }
18
19    public function getAge(): int {
20        return $this->age;
21    }
22
23    public function setAge(int $age): void {
24        if ($age < 0 || $age > 150) {
25            throw new InvalidArgumentException("Invalid age");
26        }
27        $this->age = $age;
28    }
29
30    // Getter with computed value
31    public function isAdult(): bool {
32        return $this->age >= 18;
33    }
34
35    // Controlled array access
36    public function addRole(string $role): void {
37        if (!in_array($role, $this->roles)) {
38            $this->roles[] = $role;
39        }
40    }
41
42    public function getRoles(): array {
43        return $this->roles;
44    }
45
46    public function hasRole(string $role): bool {
47        return in_array($role, $this->roles);
48    }
49}

1// Traditional way
2class Point {
3    private float $x;
4    private float $y;
5
6    public function __construct(float $x, float $y) {
7        $this->x = $x;
8        $this->y = $y;
9    }
10}
11
12// PHP 8+ property promotion
13class Point {
14    public function __construct(
15        private float $x,
16        private float $y
17    ) {}
18
19    public function getX(): float {
20        return $this->x;
21    }
22
23    public function getY(): float {
24        return $this->y;
25    }
26}

1class Product {
2    public function __construct(
3        public readonly string $id,
4        public readonly string $name,
5        public float $price  // Mutable
6    ) {}
7}
8
9$product = new Product('P001', 'Laptop', 999);
10$product->price = 899;  // OK - not readonly
11
12// $product->id = 'P002';  // ERROR - readonly
13// $product->name = 'Desktop';  // ERROR - readonly

1class User {
2    private string $name;
3    private string $email;
4    private DateTime $createdAt;
5
6    public function __construct(string $name, string $email) {
7        $this->name = $name;
8        $this->email = $email;
9        $this->createdAt = new DateTime();
10    }
11
12    public function getInfo(): string {
13        return "{$this->name} ({$this->email})";
14    }
15}
16
17// Constructor is called automatically
18$user = new User("John Doe", "[email protected]");
19echo $user->getInfo();

1class Configuration {
2    private string $environment;
3    private bool $debug;
4    private int $timeout;
5
6    public function __construct(
7        string $environment = 'production',
8        bool $debug = false,
9        int $timeout = 30
10    ) {
11        $this->environment = $environment;
12        $this->debug = $debug;
13        $this->timeout = $timeout;
14    }
15}
16
17$config1 = new Configuration();  // All defaults
18$config2 = new Configuration('development', true);
19$config3 = new Configuration(timeout: 60);  // Named arguments

1class BankAccount {
2    private string $accountNumber;
3    private float $balance;
4
5    public function __construct(string $accountNumber, float $initialBalance) {
6        if ($initialBalance < 0) {
7            throw new InvalidArgumentException(
8                "Initial balance cannot be negative"
9            );
10        }
11
12        if (strlen($accountNumber) !== 10) {
13            throw new InvalidArgumentException(
14                "Account number must be 10 digits"
15            );
16        }
17
18        $this->accountNumber = $accountNumber;
19        $this->balance = $initialBalance;
20    }
21}
22
23// Valid
24$account = new BankAccount("1234567890", 1000);
25
26// Throws exception
27// $account = new BankAccount("123", -500);

1class Product {
2    public function __construct(
3        private string $id,
4        private string $name,
5        private float $price,
6        private int $stock = 0
7    ) {
8        // Properties are automatically created and assigned
9        // Additional initialization logic can go here
10        if ($price < 0) {
11            throw new InvalidArgumentException("Price cannot be negative");
12        }
13    }
14
15    public function getName(): string {
16        return $this->name;
17    }
18
19    public function getPrice(): float {
20        return $this->price;
21    }
22}

1class DatabaseConnection {
2    private $connection;
3
4    public function __construct(string $host, string $database) {
5        $this->connection = new PDO(
6            "mysql:host=$host;dbname=$database",
7            "username",
8            "password"
9        );
10        echo "Database connected\n";
11    }
12
13    public function __destruct() {
14        $this->connection = null;
15        echo "Database connection closed\n";
16    }
17}
18
19// Constructor called
20$db = new DatabaseConnection("localhost", "mydb");
21
22// ... use connection ...
23
24// Destructor automatically called when:
25// 1. Script ends
26// 2. Object is explicitly unset: unset($db)
27// 3. Object goes out of scope

1class FileLogger {
2    private $fileHandle;
3
4    public function __construct(string $filename) {
5        $this->fileHandle = fopen($filename, 'a');
6    }
7
8    public function log(string $message): void {
9        fwrite($this->fileHandle, date('Y-m-d H:i:s') . " - $message\n");
10    }
11
12    public function __destruct() {
13        if ($this->fileHandle) {
14            fclose($this->fileHandle);
15        }
16    }
17}
18
19class CacheManager {
20    private array $cache = [];
21    private bool $modified = false;
22
23    public function set(string $key, mixed $value): void {
24        $this->cache[$key] = $value;
25        $this->modified = true;
26    }
27
28    public function __destruct() {
29        // Save cache to disk if modified
30        if ($this->modified) {
31            file_put_contents('cache.json', json_encode($this->cache));
32        }
33    }
34}