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

# Методы абстрактного класса — модификаторы доступа

Ответ: НЕТ

Методы абстрактного класса могут быть любого модификатора доступа. Это частое заблуждение, что все они обязательно публичные.

Модификаторы доступа в Java

В Java есть четыре уровня доступа:

1. public — доступен отовсюду
2. protected — доступен в том же пакете и подклассах
3. default (package-private) — доступен только в том же пакете
4. private — доступен только в самом классе

Абстрактные методы с разными модификаторами

public abstract class Animal {
    
    // PUBLIC абстрактный метод
    // Должен быть реализован в подклассе
    public abstract void makeSound();
    
    // PROTECTED абстрактный метод
    // Доступен в подклассах и в том же пакете
    protected abstract void eat();
    
    // DEFAULT (package-private) абстрактный метод
    // Доступен только в том же пакете
    abstract void sleep();
    
    // PRIVATE абстрактный метод??? 
    // НЕЛЬЗЯ! Это ошибка компиляции!
    // private abstract void breathe(); // Синтаксическая ошибка
    
    // Конкретный метод в абстрактном классе (обычно public)
    public void info() {
        System.out.println("This is an animal");
    }
    
    // Конкретный protected метод
    protected void move() {
        System.out.println("Moving...");
    }
}

Примеры реализации

// Подкласс должен реализовать абстрактные методы
public class Dog extends Animal {
    
    @Override
    public void makeSound() {
        System.out.println("Woof!");
    }
    
    @Override
    protected void eat() {
        System.out.println("Eating bones");
    }
    
    @Override
    void sleep() {
        System.out.println("Dog is sleeping");
    }
}

// Подкласс может изменить модификатор доступа
public class Cat extends Animal {
    
    @Override
    public void makeSound() {
        System.out.println("Meow!");
    }
    
    @Override
    protected void eat() {
        System.out.println("Eating mice");
    }
    
    @Override
    void sleep() {
        System.out.println("Cat is sleeping");
    }
}

Правило переопределения (Overriding rule)

Когда подкласс реализует абстрактный метод, он не может уменьшить видимость:

public abstract class Shape {
    public abstract void draw();      // public
    protected abstract void validate(); // protected
}

public class Circle extends Shape {
    @Override
    public void draw() {              // OK: остаётся public
        System.out.println("Drawing circle");
    }
    
    @Override
    protected void validate() {       // OK: остаётся protected
        System.out.println("Validating");
    }
}

public class BadCircle extends Shape {
    @Override
    // protected void draw() { }     // ОШИБКА! Нельзя уменьшить видимость с public на protected
    
    @Override
    public void validate() {          // OK: можно увеличить видимость с protected на public
        System.out.println("Validating");
    }
}

Полный пример с разными модификаторами

public abstract class DatabaseManager {
    
    // PUBLIC — используется клиентами
    public abstract void connect(String url);
    public abstract void disconnect();
    
    // PROTECTED — используется подклассами для внутренней логики
    protected abstract void initializeConnection();
    protected abstract void validateCredentials(String user, String password);
    
    // DEFAULT — используется другими классами в пакете
    abstract void logQuery(String query);
    abstract void cacheResult(String key, Object value);
    
    // Конкретные методы
    public final void execute(String query) {
        logQuery(query);
        // внутренняя логика
    }
    
    protected void log(String message) {
        System.out.println("[Log] " + message);
    }
}

// Реализация
public class PostgresManager extends DatabaseManager {
    
    @Override
    public void connect(String url) {
        initializeConnection();
        System.out.println("Connected to PostgreSQL: " + url);
    }
    
    @Override
    public void disconnect() {
        System.out.println("Disconnected from PostgreSQL");
    }
    
    @Override
    protected void initializeConnection() {
        System.out.println("Initializing PostgreSQL connection");
    }
    
    @Override
    protected void validateCredentials(String user, String password) {
        System.out.println("Validating PostgreSQL credentials");
    }
    
    @Override
    void logQuery(String query) {
        System.out.println("[PostgreSQL] Query: " + query);
    }
    
    @Override
    void cacheResult(String key, Object value) {
        System.out.println("[PostgreSQL] Cached: " + key);
    }
}

Почему private абстрактные методы невозможны

public abstract class Example {
    // private abstract void test(); // COMPILE ERROR!
    
    // Почему это не имеет смысла:
    // 1. private метод не может быть переопределён в подклассе
    // 2. Подкласс не может получить доступ к private методу родителя
    // 3. Нет смысла в абстрактном методе, который никто не может реализовать
}

Наглядное сравнение

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

// Интерфейс VS Абстрактный класс

// Интерфейс (все методы по умолчанию public abstract)
public interface PaymentProcessor {
    void process(Payment payment); // Неявно public abstract
}

// Абстрактный класс (можно управлять видимостью)
public abstract class PaymentService {
    // API публичный
    public abstract void processPayment(Payment payment);
    
    // Внутренняя логика защищённая
    protected abstract void validate(Payment payment);
    protected abstract void log(String message);
    
    // Вспомогательные методы для подклассов
    protected final void notifyUser(String message) {
        log("Notification: " + message);
    }
}

public class StripePaymentService extends PaymentService {
    @Override
    public void processPayment(Payment payment) {
        validate(payment);
        log("Processing with Stripe");
        // реальная логика
    }
    
    @Override
    protected void validate(Payment payment) {
        if (payment.getAmount() <= 0) {
            throw new IllegalArgumentException("Invalid amount");
        }
    }
    
    @Override
    protected void log(String message) {
        System.out.println("[Stripe] " + message);
    }
}

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

✓ Public — для основной бизнес-логики, которую должны реализовать все подклассы
✓ Protected — для методов, нужных подклассам, но не публичного API
✓ Default — редко используется, для внутренних методов пакета
✗ Private — невозможен в абстрактных методах

✓ Не снижай видимость при переопределении
✓ Используй protected для методов, помогающих подклассам
✓ Используй public только для публичного контракта
✓ Минимизируй публичные абстрактные методы

Частые ошибки интервьюистов

❌ "Все методы абстрактного класса публичные" — НЕПРАВДА
❌ "Абстрактный метод обязательно public" — НЕПРАВДА
✓ "Абстрактный метод может быть protected или default" — ПРАВДА
✓ "Нельзя иметь private абстрактный метод" — ПРАВДА