На что влияют модификаторы области видимости?

Access Modifiers - public, private, protected

Access modifiers kontrolisuju gde se metode i svojstva mogu pristupiti. Ovo je fundamentalno za enkapsulaciju i kontrolu pristupa.

Tri tipa modifikatora

public - dostupno svuda

public function getName(): string {
    return $this->name;
}

$user = new User();
echo $user->getName(); // OK

private - samo unutar klase

private function hashPassword(string $pwd): string {
    return hash('sha256', $pwd);
}

$user = new User();
$user->hashPassword('test'); // ERROR - private

protected - u klasi i nasleđenim klasama

protected function log(string $msg): void {
    echo $msg;
}

class Admin extends User {
    public function action() {
        $this->log('admin action'); // OK - protected dostupan
    }
}

Na sta utiču modifikatori?

1. Enkapsulacija - Sakrivanje detalja

Privatna svojstva sprečavaju direktnu manipulaciju:

class BankAccount {
    private float $balance = 0.0;
    
    public function withdraw(float $amount): bool {
        if ($amount > $this->balance) {
            return false; // Validacija
        }
        $this->balance -= $amount;
        return true;
    }
}

$account = new BankAccount();
$account->balance = -1000; // ERROR - ne moze se direktno promeniti

2. Kontrola pristupa

Javne metode predstavljaju kontrolisani interfejs:

class Database {
    private PDO $connection;
    
    private function connect(): void {
        $this->connection = new PDO('...');
    }
    
    public function query(string $sql): array {
        return $this->connection->query($sql)->fetchAll();
    }
}

3. Sigurnost

Sakrivanje osjetljivih podataka:

class PaymentProcessor {
    private string $apiKey = 'secret_key_123';
    
    private function makeRequest(string $endpoint): array {
        return curl_request($this->apiKey, $endpoint);
    }
    
    public function charge(Money $amount): bool {
        return $this->makeRequest('/charge');
    }
}

// Nema pristupa $apiKey
$proc = new PaymentProcessor();
echo $proc->apiKey; // ERROR

4. Verzionisanje API-ja

Javne metode su obaveza prema korisnicima:

class UserService {
    // Javni interfejs - ne sme se menjati
    public function findById(int $id): User {
        return $this->internalFind($id);
    }
    
    // Privatna - moze se slobodno menjati
    private function internalFind(int $id): User {
        // Kompleksna logika
    }
}

Dobar dizajn sa modifikatorima

class User {
    private int $id;
    private string $name;
    private string $email;
    private string $passwordHash;
    protected DateTime $createdAt;
    
    public function __construct(string $name, string $email) {
        $this->name = $name;
        $this->email = $email;
        $this->createdAt = new DateTime();
    }
    
    public function getName(): string {
        return $this->name;
    }
    
    public function getEmail(): string {
        return $this->email;
    }
    
    public function setPassword(string $password): void {
        if (strlen($password) < 8) {
            throw new Exception('Password too short');
        }
        $this->passwordHash = password_hash($password, PASSWORD_BCRYPT);
    }
    
    public function verifyPassword(string $password): bool {
        return password_verify($password, $this->passwordHash);
    }
    
    // Protected - mogu pristupiti samo nasleđene klase
    protected function getCreatedAt(): DateTime {
        return $this->createdAt;
    }
}

class Admin extends User {
    public function getAuditInfo(): string {
        return 'Created at: ' . $this->getCreatedAt()->format('Y-m-d');
    }
}

// Upotreba
$user = new User('John', 'john@example.com');
$user->setPassword('secure_password_123'); // OK
echo $user->getName(); // OK

// Nisu dostupni
echo $user->passwordHash; // ERROR - private
echo $user->id; // ERROR - private

Problemi bez dobrih modifikatora

// LOSE - sve je javno
class BadUser {
    public int $id;
    public string $name;
    public string $email;
    public string $password;
    public string $role;
}

$user = new BadUser();
$user->password = ''; // Obrisana lozinka!
$user->role = 'admin'; // Promenjena uloga!
$user->id = 999; // Promenjen ID!

Protected za nasleđivanje

abstract class Animal {
    private string $name; // Nije dostupan nasleđenim klasama
    protected string $species; // Dostupan nasleđenim klasama
    public string $color; // Dostupan svuda
    
    protected function makeSound(): void {
        echo 'Some sound';
    }
}

class Dog extends Animal {
    public function bark(): void {
        $this->makeSound(); // OK - protected
        echo $this->species; // OK - protected
        echo $this->name; // ERROR - private nije dostupno
    }
}

Best Practices

• Koristi private kao podrazumevan - najstrozi nivo
• Koristi protected za nasledjivanje
• Koristi public samo za interfejs
• Koristi getter/setter metode za pristup
• Radi validaciju u setterima
• Minimaliziraj javnu povrsinu

Zakljucak: Modifikatori vidljivosti su kritični za pisanje sigurnog, održivog koda koji se može refaktorisati bez brige o uticaju na ostatak sistema.