Можно ли убрать public abstract в сигнатуре метода интерфейса?

Можно ли убрать public abstract в сигнатуре метода интерфейса?

Краткий ответ

Да, вы можете убрать public abstract из сигнатуры метода интерфейса, потому что они неявно добавляются компилятором Java. Методы интерфейса всегда public и всегда abstract (кроме default методов в Java 8+).

Явное vs неявное указание

Явное указание (работает):

public interface PaymentProcessor {
    public abstract void process(double amount);
    public abstract double getBalance();
}

Неявное указание (также работает):

public interface PaymentProcessor {
    void process(double amount);      // public и abstract неявны
    double getBalance();              // public и abstract неявны
}

Оба варианта эквивалентны! Компилятор автоматически добавляет public abstract.

Почему методы интерфейса всегда public?

Логика интерфейса:

public interface Repository<T> {
    // ❌ Это была бы ошибкой
    // private void find(T id);
    
    // ✅ Методы интерфейса обязаны быть public
    T find(T id);
    void save(T entity);
}

// Причина: интерфейс определяет контракт (договор)
// Если метод private, это противоречит назначению интерфейса
public class UserRepository implements Repository<User> {
    @Override
    public User find(User id) {  // ДОЛЖЕН быть public
        // реализация
    }
}

Правило: Принцип Лисков (Liskov Substitution)

Вы НЕ можете сужать видимость при переопределении:

public interface Database {
    void connect();  // Неявно: public abstract
}

// ❌ ОШИБКА компиляции
public class MySQLDatabase implements Database {
    @Override
    private void connect() {  // ❌ Нельзя сужать видимость
        // Компилятор ошибка:
        // "The method connect of type MySQLDatabase should be tagged with @Override"
    }
}

// ✅ ПРАВИЛЬНО
public class MySQLDatabase implements Database {
    @Override
    public void connect() {  // ✅ Сохраняем public
        // реализация
    }
}

###历史: изменения в Java 8+

Java 7 и ранее: только abstract методы

public interface OldInterface {
    void method1();  // abstract
    void method2();  // abstract
    
    // Невозможно было иметь методы с реализацией
}

Java 8+: default методы

public interface NewInterface {
    void abstractMethod();  // abstract (без реализации)
    
    // ✅ default методы с реализацией
    default void defaultMethod() {
        System.out.println("Default implementation");
    }
}

Java 9+: private методы

public interface ModernInterface {
    void publicAbstract();  // public abstract (неявно)
    
    default void publicDefault() {
        // public реализация
        sharedLogic();
    }
    
    // ✅ private методы для общей логики
    private void sharedLogic() {
        System.out.println("Shared between public methods");
    }
}

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

// Интерфейс без explicit public abstract
public interface PaymentService {
    // Без explicit модификаторов
    void pay(double amount);
    double getBalance();
    boolean isAvailable();
    
    // Default метод с реализацией
    default void logTransaction(String description) {
        System.out.println("Transaction: " + description);
    }
    
    // Private метод (Java 9+)
    private void validateAmount(double amount) {
        if (amount <= 0) {
            throw new IllegalArgumentException("Amount must be positive");
        }
    }
}

// Реализация: все методы ДОЛЖНЫ быть public
public class StripePaymentService implements PaymentService {
    @Override
    public void pay(double amount) {  // ✅ public обязателен
        // реализация
    }
    
    @Override
    public double getBalance() {  // ✅ public обязателен
        // реализация
    }
    
    @Override
    public boolean isAvailable() {  // ✅ public обязателен
        // реализация
    }
    
    @Override
    public void logTransaction(String description) {  // ✅ переопределение default метода
        System.out.println("Stripe: " + description);
    }
}

Что компилятор видит

Ваш код:

public interface Calculator {
    int add(int a, int b);
    int subtract(int a, int b);
}

Что компилятор обрабатывает:

public interface Calculator {
    public abstract int add(int a, int b);
    public abstract int subtract(int a, int b);
}

В bytecode:

javap Calculator.class

public interface Calculator {
  public abstract int add(int, int);
  public abstract int subtract(int, int);
}

Правила видимости в интерфейсах

public interface ModernAPI {
    // ✅ Все эти варианты эквивалентны
    void method1();                       // public abstract (неявно)
    public void method2();                // public abstract (неявно)
    abstract void method3();              // public abstract (неявно)
    public abstract void method4();       // public abstract (явно)
    
    // ✅ Default методы
    default void defaultMethod1() {}      // public default (неявно)
    public default void defaultMethod2() {} // public default (явно)
    
    // ✅ Static методы (Java 8+)
    static void staticMethod() {}         // public static (неявно)
    public static void staticMethod2() {} // public static (явно)
    
    // ✅ Private методы (Java 9+)
    private void privateMethod() {}       // private (явно обязателен)
    
    // ❌ Это ОШИБКИ
    // private void abstractMethod();     // private abstract - противоречие
    // protected void method();           // protected - только public в интерфейсах
}

Практический пример: миграция с Java 7 на Java 8+

Java 7 (старый способ):

public interface Logger {
    void info(String message);
    void error(String message);
    void debug(String message);
}

public abstract class AbstractLogger implements Logger {
    @Override
    public void info(String message) {
        logWithLevel("INFO", message);
    }
    
    @Override
    public void error(String message) {
        logWithLevel("ERROR", message);
    }
    
    @Override
    public void debug(String message) {
        logWithLevel("DEBUG", message);
    }
    
    // Общая логика в абстрактном классе
    protected abstract void logWithLevel(String level, String message);
}

Java 8+ (новый способ):

public interface Logger {
    void logWithLevel(String level, String message);
    
    // Default методы вместо абстрактного класса
    default void info(String message) {
        logWithLevel("INFO", message);
    }
    
    default void error(String message) {
        logWithLevel("ERROR", message);
    }
    
    default void debug(String message) {
        logWithLevel("DEBUG", message);
    }
}

public class ConsoleLogger implements Logger {
    @Override
    public void logWithLevel(String level, String message) {
        System.out.println("[" + level + "] " + message);
    }
}

Почему убирать public abstract?

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

1. Скобривается код - меньше шума
2. Стандарт - все современные интерфейсы именно так пишут
3. Читаемость - явно показывает это интерфейс
4. Историчный контекст - явное указание осталось с Java 1.0

// ❌ Старый стиль (Java 1.0)
public interface OldStyle {
    public abstract void method();
}

// ✅ Современный стиль
public interface ModernStyle {
    void method();
}

Тип проверка

public interface Service {
    void execute();  // public abstract неявно
}

public class ServiceImpl implements Service {
    @Override
    public void execute() {  // ✅ public ОБЯЗАТЕЛЕН
        System.out.println("Executing...");
    }
}

// Проверка видимости
public class Main {
    public static void main(String[] args) {
        Service service = new ServiceImpl();
        service.execute();  // ✅ Работает (public)
        
        // Компилятор проверяет видимость
        // ServiceImpl.execute() должен быть как минимум public
    }
}

Таблица: Модификаторы в интерфейсах

Заключение

Да, вы можете (и должны) убирать public abstract из сигнатур методов интерфейса:

1. Они неявно добавляются компилятором
2. Это современный стиль кодирования
3. Реализующие классы ДОЛЖНЫ сделать методы public
4. В Java 8+ используйте default методы вместо абстрактных классов
5. В Java 9+ используйте private методы для общей логики

Писать public interface Service { void method(); } вместо public interface Service { public abstract void method(); } — это best practice.