Зачем нужна область видимости?

Зачем нужна область видимости

Область видимости (access modifiers) — это механизм контроля доступа к членам класса (поля, методы, классы). Они определяют, откуда можно получить доступ к переменной, методу или классу.

Основная цель

Инкапсуляция — скрывать внутренние детали реализации и предоставлять только публичный интерфейс:

Внутри класса (private):
├─ Сложная логика
├─ Внутренние переменные
└─ Служебные методы

Снаружи класса (public):
└─ Только нужные методы

Четыре уровня видимости в Java

Пример на коде

public class BankAccount {
    // private — видна только в этом классе
    private double balance;
    
    // protected — видна в классе, пакете и потомках
    protected String accountNumber;
    
    // package-private (нет модификатора) — видна в пакете
    String accountType;
    
    // public — видна везде
    public String ownerName;
    
    // private метод — внутренняя логика
    private void validateBalance() {
        if (balance < 0) {
            throw new IllegalArgumentException("Отрицательный баланс");
        }
    }
    
    // public метод — публичный интерфейс
    public void withdraw(double amount) {
        if (amount > balance) {
            throw new IllegalArgumentException("Недостаточно средств");
        }
        balance -= amount;
        validateBalance();  // Используем private метод
    }
    
    public double getBalance() {
        return balance;
    }
}

1. public — полная открытость

public class Main {
    public static void main(String[] args) {
        BankAccount account = new BankAccount();
        account.ownerName = "Ivan";  // ✓ Можно (public)
        account.withdraw(100);        // ✓ Можно (public)
        // account.balance = -1000;   // ✗ ОШИБКА (private)
        // account.validateBalance(); // ✗ ОШИБКА (private)
    }
}

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

• Методы, которые должны вызывать другие классы
• Основные операции класса
• API-методы

2. private — полное укрытие

public class BankAccount {
    private double balance = 1000;
    
    private void logTransaction(String type, double amount) {
        System.out.println(type + ": " + amount);
    }
    
    public void withdraw(double amount) {
        balance -= amount;
        logTransaction("WITHDRAW", amount);  // ✓ Можно внутри класса
    }
}

public class Hacker {
    public static void main(String[] args) {
        BankAccount account = new BankAccount();
        // account.balance = -999;              // ✗ ОШИБКА (private)
        // account.logTransaction("HACK", 999); // ✗ ОШИБКА (private)
    }
}

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

• Внутренние поля
• Служебные методы
• Реализационные детали

3. protected — для наследников

public class Vehicle {
    protected int speed = 0;  // Видна наследникам
    
    protected void accelerate() {
        speed += 10;
    }
}

public class Car extends Vehicle {
    public void goFast() {
        // ✓ Можем использовать protected
        speed = 100;
        accelerate();
    }
}

public class Main {
    public static void main(String[] args) {
        Car car = new Car();
        // car.speed = 50;      // ✗ ОШИБКА (protected, Car вне пакета)
        // car.accelerate();    // ✗ ОШИБКА (protected)
    }
}

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

• Методы для переопределения в потомках
• Поля, которые должны быть доступны наследникам
• Шаблонные методы (Template Method pattern)

4. package-private — видна в пакете

// Файл: com/bank/internal/AccountValidator.java
package com.bank.internal;

class AccountValidator {  // Без public — package-private
    static boolean isValid(String account) {
        return account != null && account.length() > 0;
    }
}

// Файл: com/bank/BankAccount.java
package com.bank;
import com.bank.internal.AccountValidator;

public class BankAccount {
    public void setAccount(String number) {
        if (AccountValidator.isValid(number)) {  // ✓ Можно в пакете
            this.accountNumber = number;
        }
    }
}

// Файл: com/shop/ShopApp.java
package com.shop;
import com.bank.internal.AccountValidator;  // ✗ ОШИБКА
// Не видна за пределами пакета com.bank

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

• Вспомогательные классы внутри пакета
• Внутренние API, не предназначенные для внешнего использования
• Группировка связанных функций

Практические примеры инкапсуляции

Плохо: открытое поле

public class User {
    public int age;  // Могут установить отрицательный возраст!
}

User user = new User();
user.age = -50;  // Ошибка данных!

Хорошо: приватное поле + валидация

public class User {
    private int age;  // Защищено
    
    public void setAge(int age) {
        if (age < 0 || age > 150) {
            throw new IllegalArgumentException("Некорректный возраст");
        }
        this.age = age;  // Валидировано
    }
    
    public int getAge() {
        return age;
    }
}

User user = new User();
user.setAge(-50);  // ✗ Исключение
user.setAge(25);   // ✓ Установлено

SOLID: Принцип инкапсуляции

Область видимости реализует Single Responsibility и Dependency Inversion:

// Интерфейс — только публичные контракты
public interface PaymentProcessor {
    void processPayment(double amount);
}

// Реализация может менять внутри, не ломая код
public class StripeProcessor implements PaymentProcessor {
    private String apiKey;  // private
    private HttpClient client;  // private
    
    @Override
    public void processPayment(double amount) {
        // Внутренняя реализация скрыта
        validateAmount(amount);
        callStripeAPI(amount);
        logTransaction(amount);
    }
    
    private void validateAmount(double amount) { /* ... */ }
    private void callStripeAPI(double amount) { /* ... */ }
    private void logTransaction(double amount) { /* ... */ }
}

Правила хорошего кода

1. Максимальное ограничение — начни с private, расширяй только если нужно

   private → package-private → protected → public
   

2. Поля обычно private

   public class User {
       private String email;  // private
       private String password;  // private
       public String getName() { /* ... */ }  // Предоставляем доступ через методы
   }
   

3. Методы public или private

   public void publicOperation() { /* ... */ }
   private void internalHelper() { /* ... */ }
   

4. protected редко нужен

   // Используй protected только если есть наследники
   protected void templateMethod() { /* ... */ }
   

Итог

Область видимости нужна для:

1. Инкапсуляции — скрывать детали
2. Безопасности — валидировать данные
3. Модульности — чёткие границы классов
4. Поддерживаемости — легче менять внутри без влияния на внешний код
5. API-контрактов — ясно, какой интерфейс предоставляет класс

Помни: принцип наименьших привилегий — предоставляй минимально необходимый доступ.