Как часто использовал наследование

Как часто использовал наследование и его применение

Наследование в Java — мощный инструмент, но его нужно использовать осторожно и осознанно. За 10+ лет я выработал чёткое понимание, когда и как его применять правильно.

Частота использования наследования

В реальных проектах я использую наследование:

• В 20-30% случаев для иерархий сущностей
• В 10-15% случаев для абстрактных базовых классов
• В 5-10% случаев для конкретного переиспользования кода

В 50-60% случаев я предпочитаю:

• Композицию (composition)
• Интерфейсы (interfaces)
• Делегирование (delegation)

Это следует принципу "Composition over Inheritance".

Правильное использование наследования

Сценарий 1: Иерархия сущностей (отношение IS-A)

// Абстрактный базовый класс для сущностей
public abstract class Entity {
    protected Long id;
    protected LocalDateTime createdAt;
    protected LocalDateTime updatedAt;
    
    public abstract String getDisplayName();
}

public class User extends Entity {
    private String email;
    private String firstName;
    private String lastName;
    
    @Override
    public String getDisplayName() {
        return firstName + " " + lastName;
    }
}

public class Product extends Entity {
    private String title;
    private BigDecimal price;
    
    @Override
    public String getDisplayName() {
        return title;
    }
}

// Использование полиморфизма
public class EntityService {
    public void displayEntity(Entity entity) {
        System.out.println(entity.getDisplayName());
        System.out.println("Created: " + entity.createdAt);
    }
}

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

• Общая функциональность в базовом классе
• Полиморфное поведение
• Переиспользование кода

Сценарий 2: Абстрактный базовый класс для специализации

public abstract class AbstractRepository<T, ID> {
    protected final JpaRepository<T, ID> jpaRepository;
    
    public AbstractRepository(JpaRepository<T, ID> jpaRepository) {
        this.jpaRepository = jpaRepository;
    }
    
    public T save(T entity) {
        validate(entity);
        return jpaRepository.save(entity);
    }
    
    public Optional<T> findById(ID id) {
        return jpaRepository.findById(id);
    }
    
    protected abstract void validate(T entity);
}

public class UserRepository extends AbstractRepository<User, Long> {
    private final JpaRepository<User, Long> jpaRepository;
    
    public UserRepository(JpaRepository<User, Long> jpaRepository) {
        super(jpaRepository);
        this.jpaRepository = jpaRepository;
    }
    
    @Override
    protected void validate(User user) {
        if (!isValidEmail(user.getEmail())) {
            throw new ValidationException("Invalid email");
        }
    }
    
    private boolean isValidEmail(String email) {
        return email.matches("^[A-Za-z0-9+_.-]+@(.+)$");
    }
}

Когда НЕ использовать наследование

Плохой пример 1: Наследование для переиспользования кода (АНТИ-ПАТТЕРН)

// ❌ Плохо - нарушает иерархию и логику
public class Stack extends ArrayList {
    @Override
    public void add(Object item) {
        super.add(0, item);
    }
}

// ✅ Хорошо - использовать композицию
public class Stack<T> {
    private final List<T> items = new ArrayList<>();
    
    public void push(T item) {
        items.add(0, item);
    }
    
    public T pop() {
        if (items.isEmpty()) throw new EmptyStackException();
        return items.remove(0);
    }
}

Плохой пример 2: Глубокие иерархии (АНТИ-ПАТТЕРН)

// ❌ Плохо - 4 уровня наследования
public class Animal { }
public class Mammal extends Animal { }
public class Dog extends Mammal { }
public class Poodle extends Dog { }

// ✅ Хорошо - плоская иерархия + композиция
public class Animal {
    private AnimalType type;        // Composition
    private Size size;              // Composition
    private Behavior behavior;      // Composition
}

public enum AnimalType {
    MAMMAL, REPTILE, AMPHIBIAN
}

Плохой пример 3: Множественное наследование поведения (АНТИ-ПАТТЕРН)

// ❌ Java не позволяет, но намерение плохо
public class Employee extends Person { // Наследуем поля
    // Хотим взять методы из другого класса
}

// ✅ Хорошо - использовать интерфейсы и композицию
public class Employee {
    private Person person;          // Композиция
    private WorkBehavior workBehavior;  // Интерфейс
    private SalaryCalculator calculator;  // Интерфейс
}

public interface WorkBehavior {
    void work();
}

public interface SalaryCalculator {
    BigDecimal calculateSalary();
}

Практический пример из реальной архитектуры

Используемая архитектура в моих проектах:

// 1. Базовый класс для всех сущностей
@MappedSuperclass
public abstract class BaseEntity {
    @Id
    @GeneratedValue(strategy = GenerationType.UUID)
    private String id;
    
    @CreationTimestamp
    private LocalDateTime createdAt;
    
    @UpdateTimestamp
    private LocalDateTime updatedAt;
}

// 2. Конкретные сущности наследуют от базовой
@Entity
@Table(name = "users")
public class User extends BaseEntity {
    private String email;
    private String firstName;
    private String lastName;
}

// 3. Интерфейсы для поведения
public interface AuditableRepository<T> {
    void createAuditLog(T entity, String action);
}

public interface Cacheable {
    String getCacheKey();
    long getCacheTTL();
}

// 4. Конкретная реализация с интерфейсами
@Service
public class UserService implements AuditableRepository<User>, Cacheable {
    private final UserRepository userRepository;
    private final AuditService auditService;
    private final CacheService cacheService;
    
    public User createUser(CreateUserRequest dto) {
        User user = new User();
        user.setEmail(dto.getEmail());
        
        User saved = userRepository.save(user);
        createAuditLog(saved, "CREATE");
        
        return saved;
    }
    
    @Override
    public void createAuditLog(User entity, String action) {
        auditService.log(new AuditEntry(
            entity.getId(),
            "User",
            action,
            LocalDateTime.now()
        ));
    }
    
    @Override
    public String getCacheKey() {
        return "user";
    }
    
    @Override
    public long getCacheTTL() {
        return 3600;  // 1 hour
    }
}

Правила использования наследования

Вопрос для проверки: Использовать наследование?

1. Это отношение IS-A?

   • Собака IS-A животное ✓ (наследование подходит)
   • Собака IS-A переноска ✗ (нужна композиция)

2. Можно ли использовать интерфейс вместо наследования?

   • Да → используй интерфейс
   • Нет → рассмотри наследование

3. Требуется ли переиспользование полей и методов базового класса?

   • Только методы → интерфейс/делегирование
   • Поля и методы → возможно наследование

4. Может ли быть глубокая иерархия (>2 уровней)?

   • Да → переделай архитектуру
   • Нет → возможно наследование

Метрики качества кода

В моих проектах я мониторю:

// Максимальная глубина наследования: 2
public class DepthInheritanceChecker {
    public int getInheritanceDepth(Class<?> clazz) {
        int depth = 0;
        Class<?> current = clazz.getSuperclass();
        while (current != null && !current.equals(Object.class)) {
            depth++;
            current = current.getSuperclass();
        }
        return depth;
    }
}

// Количество абстрактных методов (их должно быть > 50%)
public class AbstractMethodsChecker {
    public double getAbstractMethodRatio(Class<?> clazz) {
        int total = clazz.getDeclaredMethods().length;
        long abstractCount = Arrays.stream(clazz.getDeclaredMethods())
            .filter(m -> Modifier.isAbstract(m.getModifiers()))
            .count();
        return (double) abstractCount / total;
    }
}

Вывод: Наследование — важный инструмент, но необходимо использовать его осознанно. Правило "Composition over Inheritance" в современной Java архитектуре работает лучше, чем глубокие иерархии классов. Применяю наследование только для отношений IS-A и абстрактных специализаций, в остальных случаях предпочитаю композицию и интерфейсы.