Что такое private?

Private (Приватный модификатор доступа)

private — это модификатор доступа в ООП, который делает свойства и методы класса доступными только внутри самого класса. Это один из трёх основных модификаторов в PHP (public, protected, private).

Основная идея

// ❌ Без модификаторов — проблема
class BankAccount {
    public $balance = 1000; // Любой может изменить баланс!
}

$account = new BankAccount();
$account->balance = 0; // Легко украсть деньги!

// ✅ С private — безопасность
class BankAccount {
    private $balance = 1000; // Только класс может менять
    
    public function withdraw($amount) {
        if ($amount > 0 && $amount <= $this->balance) {
            $this->balance -= $amount;
            return $amount;
        }
        return 0;
    }
    
    public function getBalance() {
        return $this->balance;
    }
}

$account = new BankAccount();
echo $account->getBalance(); // 1000
$account->withdraw(100); // Безопасно
echo $account->getBalance(); // 900

// $account->balance = 0; // Ошибка: property is private

Три модификатора доступа

class Example {
    public $publicProp = "Видна везде"; // Доступна везде
    protected $protectedProp = "Видна в наследниках"; // В классе и наследниках
    private $privateProp = "Видна только здесь"; // Только в этом классе
    
    public function publicMethod() { }
    protected function protectedMethod() { }
    private function privateMethod() { }
}

$obj = new Example();
$obj->publicProp; // ✅ Работает
$obj->protectedProp; // ❌ Ошибка: cannot access protected
$obj->privateProp; // ❌ Ошибка: cannot access private

Практические примеры

Инкапсуляция данных:

class User {
    private $password; // Пароль никогда не возвращаем напрямую
    private $email;
    
    public function __construct($email, $password) {
        $this->email = $email;
        $this->password = password_hash($password, PASSWORD_BCRYPT);
    }
    
    public function verifyPassword($plain) {
        return password_verify($plain, $this->password);
    }
    
    public function getEmail() {
        return $this->email;
    }
    
    public function setPassword($old, $new) {
        if ($this->verifyPassword($old)) {
            $this->password = password_hash($new, PASSWORD_BCRYPT);
            return true;
        }
        return false;
    }
}

$user = new User("user@example.com", "secret123");
echo $user->getEmail(); // user@example.com
$user->setPassword("secret123", "newsecret"); // Безопасная смена
// echo $user->password; // Ошибка: cannot access private

Защита внутренней логики:

class PaymentProcessor {
    private $apiKey; // Никто не может получить ключ
    private $transactions = []; // История в безопасности
    
    public function __construct($apiKey) {
        $this->apiKey = $apiKey;
    }
    
    public function processPayment($amount) {
        // Проверяем баланс
        if (!$this->hasBalance($amount)) {
            throw new Exception("Insufficient balance");
        }
        
        // Делаем платёж через приватный метод
        $result = $this->chargeCard($amount);
        
        // Логируем транзакцию
        $this->logTransaction($amount, $result);
        
        return $result;
    }
    
    private function hasBalance($amount) {
        // Внутренняя проверка, никто не может переопределить
        return true;
    }
    
    private function chargeCard($amount) {
        // Взаимодействие с API — защищено
        return ["status" => "success", "amount" => $amount];
    }
    
    private function logTransaction($amount, $result) {
        // История не может быть изменена снаружи
        $this->transactions[] = [
            "amount" => $amount,
            "result" => $result,
            "time" => time()
        ];
    }
    
    public function getTransactionCount() {
        return count($this->transactions);
    }
}

С наследованием:

class Parent {
    private $secret = "Только для Parent"; // Не передаётся детям!
    protected $shared = "Для Parent и детей";
    public $open = "Для всех";
    
    private function privateMethod() {
        echo "Видна только здесь";
    }
}

class Child extends Parent {
    public function test() {
        echo $this->secret; // ❌ Ошибка: private из Parent
        echo $this->shared; // ✅ Работает: protected
        echo $this->open; // ✅ Работает: public
        
        $this->privateMethod(); // ❌ Ошибка: private из Parent
    }
}

$child = new Child();
echo $child->secret; // ❌ Ошибка
echo $child->shared; // ❌ Ошибка (protected тоже не видна снаружи)
echo $child->open; // ✅ Работает

Getter и Setter (лучшая практика)

class Product {
    private $price;
    private $quantity;
    
    // Getter — только чтение
    public function getPrice() {
        return $this->price;
    }
    
    // Setter — с проверкой
    public function setPrice($value) {
        if ($value > 0) {
            $this->price = $value;
        } else {
            throw new Exception("Price must be positive");
        }
    }
    
    public function getQuantity() {
        return $this->quantity;
    }
    
    public function setQuantity($value) {
        if ($value >= 0 && is_int($value)) {
            $this->quantity = $value;
        } else {
            throw new Exception("Invalid quantity");
        }
    }
    
    public function getTotalValue() {
        return $this->price * $this->quantity;
    }
}

$product = new Product();
$product->setPrice(99.99); // ✅ Проверка
$product->setPrice(-10); // ❌ Ошибка: validation
echo $product->getPrice(); // 99.99

Сравнение модификаторов

Когда использовать private

• Скрытие реализации — детали, которые могут меняться
• Защита данных — пароли, токены, ключи API
• Инкапсуляция — внутренняя логика класса
• Безопасность — чтобы никто не мог случайно сломать логику
• Контрактные обязательства — гарантировать инварианты

Анти-паттерны

// ❌ Плохо: public везде
class Account {
    public $balance = 1000;
    public $password = "secret123";
}

// ✅ Хорошо: private + getters/setters
class Account {
    private $balance = 1000;
    private $password = "secret123";
    
    public function getBalance() { return $this->balance; }
    public function verifyPassword($pass) { }
}