Что такое private?

private — Модификатор Доступа

private — это модификатор доступа в Java, который ограничивает видимость членов класса (переменных, методов, вложенных классов) только для этого класса. Член класса с модификатором private недоступен из других классов, даже если они находятся в том же пакете или являются наследниками.

Четыре уровня доступа в Java

Java имеет четыре уровня видимости, упорядоченные от наиболее ограничивающего к наиболее открытому:

Примеры использования private

public class BankAccount {
    // Приватные поля — защита инкапсуляции
    private String accountNumber;
    private double balance;
    private int pin;
    
    // Публичный конструктор
    public BankAccount(String accountNumber, double initialBalance) {
        this.accountNumber = accountNumber;
        this.balance = initialBalance;
        this.pin = 0;
    }
    
    // Публичные методы — контролируемый доступ
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
            logTransaction("Deposit", amount);  // Вызов приватного метода
        }
    }
    
    public boolean withdraw(double amount, int enteredPin) {
        if (validatePin(enteredPin) && amount <= balance) {  // Вызов приватного метода
            balance -= amount;
            logTransaction("Withdrawal", amount);
            return true;
        }
        return false;
    }
    
    public double getBalance(int pin) {
        if (validatePin(pin)) {
            return balance;
        }
        throw new SecurityException("Invalid PIN");
    }
    
    // Приватные методы — внутренняя логика
    private boolean validatePin(int enteredPin) {
        return enteredPin == this.pin;  // Доступ к приватному полю
    }
    
    private void logTransaction(String type, double amount) {
        System.out.println("Transaction: " + type + " - " + amount);
    }
    
    // Приватный вспомогательный метод
    private String getAccountInfo() {
        return "Account: " + accountNumber + ", Balance: " + balance;
    }
}

// Использование класса
public class BankingApp {
    public static void main(String[] args) {
        BankAccount account = new BankAccount("123-456-789", 1000.0);
        
        account.deposit(500);  // OK
        account.withdraw(200, 0);  // OK
        double balance = account.getBalance(0);  // OK
        System.out.println("Balance: " + balance);
        
        // Это ОШИБКА компиляции — private члены недоступны
        // System.out.println(account.pin);  // Compilation error!
        // account.balance = 100000;  // Compilation error!
        // account.logTransaction("Hack", 999);  // Compilation error!
    }
}

private в контексте наследования

public class Parent {
    private String secretData = "secret";  // Приватное поле
    
    protected void protectedMethod() {
        System.out.println(secretData);  // Доступ внутри класса
    }
}

public class Child extends Parent {
    public void test() {
        // System.out.println(secretData);  // Compilation error!
        // secretData наследуется, но недоступен для доступа
        
        protectedMethod();  // OK — protected доступен подклассам
    }
}

private для вложенных классов

public class OuterClass {
    private String outerData = "outer";
    
    // Приватный вложенный класс
    private class InnerClass {
        void accessOuterData() {
            System.out.println(outerData);  // OK — доступ к внешнему приватному полю
        }
    }
    
    public void createInner() {
        InnerClass inner = new InnerClass();  // OK — создание приватного вложенного класса
        inner.accessOuterData();
    }
}

public class Main {
    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        // OuterClass.InnerClass inner = outer.new InnerClass();  // Compilation error!
        outer.createInner();  // OK
    }
}

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

private — основной инструмент для реализации инкапсуляции:

public class Student {
    private String name;
    private int age;
    private double gpa;
    
    // Контролируемый доступ к приватным полям
    public void setName(String name) {
        if (name != null && !name.isEmpty()) {
            this.name = name;  // Валидация перед установкой
        }
    }
    
    public String getName() {
        return name;
    }
    
    public void setAge(int age) {
        if (age >= 0 && age <= 120) {
            this.age = age;
        } else {
            throw new IllegalArgumentException("Invalid age");
        }
    }
    
    public int getAge() {
        return age;
    }
    
    public void setGpa(double gpa) {
        if (gpa >= 0 && gpa <= 4.0) {
            this.gpa = gpa;
        }
    }
    
    public double getGpa() {
        return gpa;
    }
}

Преимущества private

1. Инкапсуляция — скрывает внутреннее состояние
2. Защита инвариантов — гарантирует корректность данных
3. Гибкость — можно менять реализацию без влияния на клиентов
4. Безопасность — предотвращает несанкционированный доступ
5. Тестируемость — приватные методы тестируются косвенно через публичный API

Особенности private

• Члены класса с private существуют в каждом экземпляре
• Приватные члены одного экземпляра видны другим экземплярам того же класса:

public class Example {
    private int value;
    
    public void copyFrom(Example other) {
        this.value = other.value;  // OK — доступ к приватному полю другого экземпляра
    }
}

• private нельзя применять к классам верхнего уровня (top-level classes)
• Статические приватные методы видны всем экземплярам класса

Лучшие практики

• Делай поля private по умолчанию
• Предоставляй публичные методы для управления приватными полями (getters/setters)
• Используй private для вспомогательных методов, которые не должны быть частью публичного API
• Комбинируй с final для предотвращения переопределения: private final int constant

Модификатор private — это фундамент инкапсуляции и хорошего объектно-ориентированного дизайна в Java.