Какие знаешь видимости методов?

Видимости методов в Java

Видимость (модификаторы доступа) — одна из фундаментальных концепций объектно-ориентированного программирования. Они контролируют, где и как можно использовать методы, переменные и классы. В Java существует четыре уровня видимости.

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

public — максимальная видимость. Метод доступен везде.

public class UserService {
    
    // Этот метод доступен везде: в пакете, вне пакета, везде
    public void createUser(String name, String email) {
        User user = new User(name, email);
        saveUser(user);
    }
    
    public User getUserById(Long id) {
        return userRepository.findById(id).orElse(null);
    }
    
    public List<User> getAllUsers() {
        return userRepository.findAll();
    }
}

// Использование из другого пакета
import com.example.service.UserService;

public class Application {
    public static void main(String[] args) {
        UserService service = new UserService();
        service.createUser("John", "john@example.com"); // OK
    }
}

Когда использовать: Для методов, которые являются частью публичного API вашего класса или модуля.

Характеристики:

• Доступен во всех классах, независимо от пакета
• Часть публичного контракта класса
• Должен быть хорошо документирован

2. protected (защищённый)

protected — видимость для подклассов и класса в том же пакете.

public class Animal {
    
    // Доступен в подклассах и в одном пакете
    protected void makeSound() {
        System.out.println("Some sound");
    }
    
    protected String getName() {
        return "Animal";
    }
}

// Подкласс в другом пакете
import com.example.animal.Animal;

public class Dog extends Animal {
    
    @Override
    protected void makeSound() { // OK — переопределение
        System.out.println("Woof!");
    }
    
    public void bark() {
        makeSound(); // OK — доступен в подклассе
        String name = getName(); // OK
    }
}

// Класс в одном пакете
public class AnimalTester {
    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.makeSound(); // OK — тот же пакет
    }
}

// Класс в другом пакете
public class OtherClass {
    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.makeSound(); // ERROR — другой пакет и не наследник
    }
}

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

Характеристики:

• Доступен в подклассах
• Доступен в классах одного пакета
• Не доступен в других пакетах для классов, которые не наследуют
• Часто используется в шаблонах Template Method

3. package-private (видимость пакета) — по умолчанию

package-private (без модификатора) — видимость только в пакете.

public class UserRepository {
    
    // Без модификатора = видимость пакета
    // Доступен только в этом пакете
    User findUserInCache(String email) {
        // реализация
    }
    
    void clearCache() {
        // реализация
    }
    
    // Публичный метод использует пакетный
    public User findByEmail(String email) {
        User cached = findUserInCache(email); // OK — тот же пакет
        if (cached != null) {
            return cached;
        }
        return userDatabase.findByEmail(email);
    }
}

// Другой класс в том же пакете
public class UserValidator {
    private UserRepository repo = new UserRepository();
    
    public void validateUser(String email) {
        User user = repo.findByEmail(email); // OK
        // repo.findUserInCache(email); // ERROR — пакетный метод не используется напрямую
    }
}

// Класс в другом пакете
public class ExternalService {
    private UserRepository repo = new UserRepository();
    
    public void process() {
        // repo.findUserInCache(email); // ERROR — другой пакет
        // repo.clearCache(); // ERROR — другой пакет
        User user = repo.findByEmail(email); // OK — публичный
    }
}

Когда использовать: Для методов вспомогательного назначения, которые используются только внутри пакета.

Характеристики:

• По умолчанию (если не указан модификатор)
• Доступен только в классах одного пакета
• Хороший способ скрыть реализационные детали

4. private (приватный)

private — минимальная видимость. Доступен только в самом классе.

public class BankAccount {
    
    private double balance; // приватное поле
    
    // Приватный метод — реализационная деталь
    private boolean validateAmount(double amount) {
        return amount > 0 && amount <= balance;
    }
    
    // Приватный метод для внутреннего использования
    private void logTransaction(String type, double amount) {
        System.out.println(type + ": " + amount + " at " + new Date());
    }
    
    // Публичный метод использует приватные методы
    public void withdraw(double amount) {
        if (!validateAmount(amount)) { // OK — приватный метод
            throw new IllegalArgumentException("Invalid amount");
        }
        balance -= amount;
        logTransaction("WITHDRAW", amount); // OK — приватный метод
    }
    
    public void deposit(double amount) {
        if (amount <= 0) {
            throw new IllegalArgumentException("Amount must be positive");
        }
        balance += amount;
        logTransaction("DEPOSIT", amount);
    }
    
    public double getBalance() {
        return balance;
    }
}

// Использование
public class BankTest {
    public static void main(String[] args) {
        BankAccount account = new BankAccount();
        account.deposit(1000);
        account.withdraw(200);
        System.out.println(account.getBalance());
        
        // account.balance = 5000; // ERROR — приватное
        // account.validateAmount(100); // ERROR — приватное
        // account.logTransaction("TEST", 50); // ERROR — приватное
    }
}

Когда использовать: Для методов и полей, которые являются реализационными деталями класса.

Характеристики:

• Доступны только в самом классе
• Лучший способ скрыть реализацию
• Позволяет менять реализацию без влияния на внешний код

Таблица видимостей

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

@RestController
@RequestMapping("/api/products")
public class ProductController {
    
    @Autowired
    private ProductService service; // private — внутреннее поле
    
    // Public API endpoint
    @GetMapping("/{id}")
    public ResponseEntity<ProductDTO> getProduct(@PathVariable Long id) {
        Product product = findProductOrThrow(id); // package-private метод
        return ResponseEntity.ok(new ProductDTO(product));
    }
    
    // Public API endpoint
    @PostMapping
    public ResponseEntity<ProductDTO> createProduct(
        @RequestBody CreateProductRequest request
    ) {
        validateProductName(request.getName()); // private метод
        Product product = service.create(request);
        return ResponseEntity.status(HttpStatus.CREATED)
            .body(new ProductDTO(product));
    }
    
    // Package-private для внутреннего использования
    Product findProductOrThrow(Long id) {
        return service.findById(id)
            .orElseThrow(() -> new ProductNotFoundException(id));
    }
    
    // Private — реализационная деталь
    private void validateProductName(String name) {
        if (name == null || name.trim().isEmpty()) {
            throw new IllegalArgumentException("Product name cannot be empty");
        }
    }
}

// Service layer
@Service
public class ProductService {
    
    @Autowired
    private ProductRepository repository; // private
    
    // Public — часть бизнес-API
    public Optional<Product> findById(Long id) {
        return repository.findById(id);
    }
    
    // Public — часть бизнес-API
    public Product create(CreateProductRequest request) {
        Product product = new Product(request.getName(), request.getPrice());
        enrichProductData(product); // private метод
        return repository.save(product);
    }
    
    // Private — реализационная деталь
    private void enrichProductData(Product product) {
        product.setCreatedAt(LocalDateTime.now());
        product.setStatus("ACTIVE");
    }
}

Инкапсуляция: принцип наименьших привилегий

// ❌ Плохо — слишком открыто
public class User {
    public String name;
    public String email;
    public int age;
    
    public void setName(String name) {
        this.name = name; // нет валидации
    }
}

// ✅ Хорошо — правильная инкапсуляция
public class User {
    private String name;    // приватные поля
    private String email;
    private int age;
    
    // Public getters
    public String getName() {
        return name;
    }
    
    public String getEmail() {
        return email;
    }
    
    public int getAge() {
        return age;
    }
    
    // Public setters с валидацией
    public void setName(String name) {
        if (name == null || name.trim().isEmpty()) {
            throw new IllegalArgumentException("Name cannot be empty");
        }
        this.name = name;
    }
    
    public void setEmail(String email) {
        if (!email.contains("@")) {
            throw new IllegalArgumentException("Invalid email");
        }
        this.email = email;
    }
    
    public void setAge(int age) {
        if (age < 0 || age > 150) {
            throw new IllegalArgumentException("Invalid age");
        }
        this.age = age;
    }
}

Заключение

Правильное использование модификаторов видимости — ключевой аспект написания хорошего кода. Следуй принципу инкапсуляции:

• Делай всё private по умолчанию
• Поднимай видимость только когда необходимо
• Используй public только для публичного API
• Используй protected для методов, которые должны переопределяться подклассами
• Используй package-private для вспомогательных методов

Этот подход делает код более надёжным, проще тестируемым и проще в поддержке.