Какие знаешь способы ограничения в Java?

Способы ограничения (модификаторы доступа) в Java

В Java есть четыре уровня доступа, которые контролируют видимость классов, полей, методов и конструкторов.

Четыре модификатора доступа

1. public (Публичный)

Доступен отовсюду - из любого класса, пакета, модуля.

public class PublicExample {
    public String publicField = "I am public";
    
    public void publicMethod() {
        System.out.println("Public method");
    }
    
    public PublicExample() {
        System.out.println("Public constructor");
    }
}

// Доступен из другого пакета
PublicExample obj = new PublicExample();
obj.publicMethod();
String value = obj.publicField;

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

• Публичный API вашего класса
• Методы, которые должны вызывать другие классы
• Точки входа в приложение

2. private (Приватный)

Доступен ТОЛЬКО внутри своего класса. Самый строгий уровень ограничения.

public class PrivateExample {
    private String password;
    private int internalState;
    
    private void secretMethod() {
        System.out.println("This is secret");
    }
    
    private PrivateExample() {
        // Приватный конструктор - класс нельзя создавать извне
    }
    
    public void publicMethod() {
        // Внутри класса можем обращаться к private
        secretMethod();
        System.out.println(password);
    }
}

// Из другого класса
PrivateExample obj = new PrivateExample();  // ОШИБКА КОМПИЛЯЦИИ!
obj.secretMethod();  // ОШИБКА КОМПИЛЯЦИИ!
obj.password = "123";  // ОШИБКА КОМПИЛЯЦИИ!

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

• Внутренние поля класса
• Вспомогательные методы
• Скрытие деталей реализации (Encapsulation)
• Singleton pattern (приватный конструктор)

Пример Singleton:

public class DatabaseConnection {
    private static DatabaseConnection instance;
    
    // Приватный конструктор - нельзя создавать new
    private DatabaseConnection() {
        // Инициализация БД
    }
    
    public static DatabaseConnection getInstance() {
        if (instance == null) {
            instance = new DatabaseConnection();
        }
        return instance;
    }
}

3. protected (Защищённый)

Доступен:

• Внутри своего пакета
• В подклассах (даже в других пакетах)

public class Parent {
    protected String protectedField = "Accessible in subclass";
    
    protected void protectedMethod() {
        System.out.println("Protected method");
    }
}

// Подкласс в другом пакете
public class Child extends Parent {
    public void childMethod() {
        // Можем обратиться к protected полям/методам родителя
        System.out.println(protectedField);
        protectedMethod();
    }
}

// Не-подкласс в другом пакете
public class OtherClass {
    public void someMethod() {
        Parent parent = new Parent();
        parent.protectedField = "...";  // ОШИБКА КОМПИЛЯЦИИ!
        parent.protectedMethod();  // ОШИБКА КОМПИЛЯЦИИ!
    }
}

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

• Методы/поля, которые нужны подклассам
• Template Method pattern
• Иерархии классов

Пример Template Method:

public abstract class PaymentProcessor {
    public void processPayment(double amount) {
        // Общий алгоритм
        validatePayment(amount);
        executeTransaction(amount);
        logTransaction(amount);
    }
    
    // Подклассы переопределяют
    protected abstract void executeTransaction(double amount);
    
    protected void validatePayment(double amount) {
        // Базовая валидация
    }
    
    protected void logTransaction(double amount) {
        System.out.println("Transaction logged: " + amount);
    }
}

public class CreditCardProcessor extends PaymentProcessor {
    @Override
    protected void executeTransaction(double amount) {
        // Специфичная реализация для кредитных карт
        System.out.println("Processing credit card payment: " + amount);
    }
}

4. package-private (Умолчание, default)

Доступен только внутри ОДНОГО пакета. Используется, если не указать модификатор.

// com/example/utils/Helper.java
public class PublicClass {  // public - видна везде
    public void publicMethod() { }
}

class PackagePrivateClass {  // package-private - видна только в пакете com.example.utils
    void packagePrivateMethod() { }  // package-private метод
}

// com/example/other/Other.java
public class Other {
    public void someMethod() {
        PublicClass obj1 = new PublicClass();  // OK
        obj1.publicMethod();  // OK
        
        PackagePrivateClass obj2 = new PackagePrivateClass();  // ОШИБКА - класс не видна
    }
}

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

• Классы, которые используются только в одном пакете
• Вспомогательные классы
• Скрытие внутренней реализации

Матрица видимости

Практический пример: Хорошая инкапсуляция

public class User {
    // private поля - скрыты от внешнего мира
    private String username;
    private String password;
    private LocalDateTime createdAt;
    private LocalDateTime lastLogin;
    
    // private конструктор для контроля создания
    private User(String username, String password) {
        this.username = username;
        this.password = password;
        this.createdAt = LocalDateTime.now();
    }
    
    // public factory method вместо конструктора
    public static User create(String username, String password) {
        if (!isValidPassword(password)) {
            throw new IllegalArgumentException("Password is too weak");
        }
        return new User(username, encryptPassword(password));
    }
    
    // public getter - только чтение
    public String getUsername() {
        return username;
    }
    
    // public setter с валидацией
    public void setPassword(String newPassword) {
        if (!isValidPassword(newPassword)) {
            throw new IllegalArgumentException("Password is too weak");
        }
        this.password = encryptPassword(newPassword);
    }
    
    public LocalDateTime getLastLogin() {
        return lastLogin;
    }
    
    // public метод поведения
    public void login() {
        this.lastLogin = LocalDateTime.now();
    }
    
    // private вспомогательные методы
    private static boolean isValidPassword(String password) {
        return password != null && password.length() >= 8;
    }
    
    private static String encryptPassword(String password) {
        // Логика шифрования
        return password;  // Упрощено для примера
    }
}

// Использование
User user = User.create("john_doe", "securePassword123");
user.login();
System.out.println(user.getUsername());  // OK
user.setPassword("newPassword456");  // OK - с валидацией
user.password = "123";  // ОШИБКА - private

Другие модификаторы (не уровни доступа)

static

Принадлежит классу, а не объекту.

public class Counter {
    private static int count = 0;  // Статичное поле - общее для всех объектов
    
    public Counter() {
        count++;  // Увеличиваем при создании
    }
    
    public static int getCount() {  // Статичный метод
        return count;
    }
}

Counter c1 = new Counter();
Counter c2 = new Counter();
System.out.println(Counter.getCount());  // 2

final

Запрещает изменение/переопределение.

public final class Immutable {  // Нельзя наследоваться
    private final String value;  // Нельзя менять
    
    public Immutable(String value) {
        this.value = value;
    }
    
    public final void criticalMethod() {  // Нельзя переопределить
        System.out.println(value);
    }
}

abstract

Сигнализирует о том, что класс/метод нужно реализовать в подклассе.

public abstract class Shape {
    // abstract метод - должен быть реализован подклассом
    public abstract double getArea();
    
    // Обычный метод
    public void display() {
        System.out.println("Area: " + getArea());
    }
}

public class Circle extends Shape {
    private double radius;
    
    @Override
    public double getArea() {
        return Math.PI * radius * radius;
    }
}

Best Practices

1. По умолчанию - private

   // ✗ Плохо - слишком открыто
   public String userName;
   public int userAge;
   
   // ✓ Хорошо - protected with getters/setters
   private String userName;
   private int userAge;
   public String getUserName() { return userName; }
   public void setUserAge(int age) { if (age > 0) userAge = age; }
   

2. Принцип наименьших привилегий

   • Давайте доступ ровно столько, сколько нужно
   • private > package-private > protected > public

3. Инкапсуляция

   // ✗ Плохо - прямой доступ к полям
   user.balance = user.balance - 100;
   
   // ✓ Хорошо - через метод с логикой
   user.withdraw(100);  // Содержит валидацию
   

4. Классы обычно public, методы - selective

   public class MyService {  // public класс
       public void publicAPI() { }  // public метод - часть API
       protected void forSubclasses() { }  // protected - для наследников
       private void internal() { }  // private - только для себя
   }
   

Резюме

• public - максимальная доступность
• protected - доступно в пакете и подклассам
• package-private - доступно только в пакете
• private - доступно только в классе

Правильное использование модификаторов - основа хорошей архитектуры и безопасности кода.