Инкапсуляция в Java: защита данных и чистый код для надежности

public class BankAccount {
private double balance; // Скрытое внутреннее состояние

public double getBalance() {
return balance;
}

public void deposit(double amount) {
if (amount > 0) {
balance += amount;
}
}

public boolean withdraw(double amount) {
if (amount > 0 && balance >= amount) {
balance -= amount;
return true;
}
return false;
}
}

public class Person {
private String name; // Доступно только внутри класса
private int age; // Доступно только внутри класса
protected String address; // Доступно в классе, пакете и подклассах
public String email; // Доступно всем

// Конструктор и методы...
}

public class Student {
private String name;
private int age;

// Геттер для name
public String getName() {
return name;
}

// Сеттер для name с валидацией
public void setName(String name) {
if (name != null && !name.trim().isEmpty()) {
this.name = name;
} else {
throw new IllegalArgumentException("Name cannot be empty");
}
}

// Геттер для age
public int getAge() {
return age;
}

// Сеттер для age с валидацией
public void setAge(int age) {
if (age > 0 && age < 150) {
this.age = age;
} else {
throw new IllegalArgumentException("Age must be between 1 and 150");
}
}
}

public final class ImmutablePerson {
private final String name;
private final int birthYear;

public ImmutablePerson(String name, int birthYear) {
this.name = name;
this.birthYear = birthYear;
}

public String getName() {
return name;
}

public int getBirthYear() {
return birthYear;
}

// Нет сеттеров!

// Вместо изменения создаем новый объект
public ImmutablePerson withName(String newName) {
return new ImmutablePerson(newName, this.birthYear);
}
}

public class Employee {
private String email;

public String getEmail() {
return email;
}

public void setEmail(String email) {
// Проверка формата email
if (email != null && email.matches("^[\\w-\\.]+@([\\w-]+\\.)+[\\w-]{2,4}$")) {
this.email = email;
} else {
throw new IllegalArgumentException("Invalid email format");
}
}
}

public class DatabaseConnection {
private Connection connection = null;

// Геттер с ленивой инициализацией
public Connection getConnection() {
if (connection == null) {
// Инициализируем подключение только при первом вызове
connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/mydb", "user", "password");
}
return connection;
}
}

public class Rectangle {
private double length;
private double width;
private double area;

public double getLength() {
return length;
}

public void setLength(double length) {
if (length <= 0) {
throw new IllegalArgumentException("Length must be positive");
}
this.length = length;
// Пересчитываем зависимое поле
this.area = this.length * this.width;
}

public double getWidth() {
return width;
}

public void setWidth(double width) {
if (width <= 0) {
throw new IllegalArgumentException("Width must be positive");
}
this.width = width;
// Пересчитываем зависимое поле
this.area = this.length * this.width;
}

public double getArea() {
return area;
}

// Нет сеттера для area, оно вычисляется автоматически
}

public class UserAuthentication {
private AuthenticationStrategy strategy;

public UserAuthentication() {
// По умолчанию используем базовую стратегию
this.strategy = new BasicAuthStrategy();
}

// Интерфейс остается стабильным
public boolean authenticate(String username, String password) {
// Внутренняя реализация может меняться
return strategy.performAuthentication(username, password);
}

// Метод для изменения стратегии
public void setStrategy(AuthenticationStrategy strategy) {
this.strategy = strategy;
}
}

public class ThreadSafeCounter {
private volatile int count = 0;

public synchronized void increment() {
count++;
}

public synchronized void decrement() {
count--;
}

public synchronized int getCount() {
return count;
}
}

public class Order {
private final String orderId;
private final List<OrderItem> items;
private OrderStatus status;
private LocalDateTime creationDate;
private LocalDateTime lastModified;
private double totalAmount;

public Order(String orderId) {
this.orderId = orderId;
this.items = new ArrayList<>();
this.status = OrderStatus.NEW;
this.creationDate = LocalDateTime.now();
this.lastModified = this.creationDate;
this.totalAmount = 0.0;
}

// Геттеры
public String getOrderId() {
return orderId;
}

public List<OrderItem> getItems() {
// Возвращаем копию списка для защиты от внешних изменений
return Collections.unmodifiableList(items);
}

public OrderStatus getStatus() {
return status;
}

public LocalDateTime getCreationDate() {
return creationDate;
}

public LocalDateTime getLastModified() {
return lastModified;
}

public double getTotalAmount() {
return totalAmount;
}

// Бизнес-методы
public void addItem(Product product, int quantity) {
if (status != OrderStatus.NEW) {
throw new IllegalStateException("Cannot modify items in " + status + " status");
}

OrderItem item = new OrderItem(product, quantity);
items.add(item);
recalculateTotalAmount();
updateLastModified();
}

public void removeItem(OrderItem item) {
if (status != OrderStatus.NEW) {
throw new IllegalStateException("Cannot modify items in " + status + " status");
}

if (items.remove(item)) {
recalculateTotalAmount();
updateLastModified();
}
}

public void placeOrder() {
if (status != OrderStatus.NEW) {
throw new IllegalStateException("Order can be placed only when in NEW status");
}

if (items.isEmpty()) {
throw new IllegalStateException("Cannot place order with no items");
}

status = OrderStatus.PLACED;
updateLastModified();
}

public void cancelOrder() {
if (status == OrderStatus.DELIVERED || status == OrderStatus.CANCELLED) {
throw new IllegalStateException("Cannot cancel order in " + status + " status");
}

status = OrderStatus.CANCELLED;
updateLastModified();
}

public void markAsDelivered() {
if (status != OrderStatus.SHIPPED) {
throw new IllegalStateException("Only shipped orders can be marked as delivered");
}

status = OrderStatus.DELIVERED;
updateLastModified();
}

// Вспомогательные приватные методы
private void recalculateTotalAmount() {
totalAmount = items.stream()
.mapToDouble(item -> item.getProduct().getPrice() * item.getQuantity())
.sum();
}

private void updateLastModified() {
lastModified = LocalDateTime.now();
}
}

enum OrderStatus {
NEW, PLACED, SHIPPED, DELIVERED, CANCELLED
}

class OrderItem {
private final Product product;
private final int quantity;

public OrderItem(Product product, int quantity) {
if (product == null) {
throw new IllegalArgumentException("Product cannot be null");
}
if (quantity <= 0) {
throw new IllegalArgumentException("Quantity must be positive");
}

this.product = product;
this.quantity = quantity;
}

public Product getProduct() {
return product;
}

public int getQuantity() {
return quantity;
}
}

class Product {
private final String id;
private String name;
private double price;

public Product(String id, String name, double price) {
this.id = id;
this.name = name;
this.price = price;
}

public String getId() {
return id;
}

public String getName() {
return name;
}

public void setName(String name) {
if (name == null || name.trim().isEmpty()) {
throw new IllegalArgumentException("Product name cannot be empty");
}
this.name = name;
}

public double getPrice() {
return price;
}

public void setPrice(double price) {
if (price < 0) {
throw new IllegalArgumentException("Price cannot be negative");
}
this.price = price;
}
}

public interface UserDAO {
User findById(Long id);
List<User> findAll();
void save(User user);
void delete(User user);
}

public class UserDAOImpl implements UserDAO {
// Скрытие деталей подключения к БД
private final Connection connection;

public UserDAOImpl(DataSource dataSource) throws SQLException {
this.connection = dataSource.getConnection();
}

@Override
public User findById(Long id) {
try {
PreparedStatement stmt = connection.prepareStatement(
"SELECT * FROM users WHERE id = ?"
);
stmt.setLong(1, id);
ResultSet rs = stmt.executeQuery();

if (rs.next()) {
return mapResultSetToUser(rs);
}
return null;
} catch (SQLException e) {
throw new DAOException("Error finding user by id: " + id, e);
}
}

@Override
public List<User> findAll() {
try {
Statement stmt = connection.createStatement();
ResultSet rs = stmt.executeQuery("SELECT * FROM users");

List<User> users = new ArrayList<>();
while (rs.next()) {
users.add(mapResultSetToUser(rs));
}
return users;
} catch (SQLException e) {
throw new DAOException("Error retrieving all users", e);
}
}

@Override
public void save(User user) {
try {
if (user.getId() == null) {
// Вставка нового пользователя
PreparedStatement stmt = connection.prepareStatement(
"INSERT INTO users (username, email, password_hash) VALUES (?, ?, ?)",
Statement.RETURN_GENERATED_KEYS
);

stmt.setString(1, user.getUsername());
stmt.setString(2, user.getEmail());
stmt.setString(3, user.getPasswordHash());

stmt.executeUpdate();

// Получаем сгенерированный ID
ResultSet generatedKeys = stmt.getGeneratedKeys();
if (generatedKeys.next()) {
user.setId(generatedKeys.getLong(1));
}
} else {
// Обновление существующего пользователя
PreparedStatement stmt = connection.prepareStatement(
"UPDATE users SET username = ?, email = ?, password_hash = ? WHERE id = ?"
);

stmt.setString(1, user.getUsername());
stmt.setString(2, user.getEmail());
stmt.setString(3, user.getPasswordHash());
stmt.setLong(4, user.getId());

stmt.executeUpdate();
}
} catch (SQLException e) {
throw new DAOException("Error saving user: " + user.getUsername(), e);
}
}

@Override
public void delete(User user) {
try {
PreparedStatement stmt = connection.prepareStatement(
"DELETE FROM users WHERE id = ?"
);

stmt.setLong(1, user.getId());
stmt.executeUpdate();
} catch (SQLException e) {
throw new DAOException("Error deleting user: " + user.getUsername(), e);
}
}

// Приватный метод для конвертации ResultSet в объект User
private User mapResultSetToUser(ResultSet rs) throws SQLException {
User user = new User();
user.setId(rs.getLong("id"));
user.setUsername(rs.getString("username"));
user.setEmail(rs.getString("email"));
user.setPasswordHash(rs.getString("password_hash"));
return user;
}

// Внутренний класс для инкапсуляции исключений
public class DAOException extends RuntimeException {
public DAOException(String message, Throwable cause) {
super(message, cause);
}
}
}

public class User {
private Long id;
private String username;
private String email;
private String passwordHash;

// Геттеры и сеттеры
public Long getId() {
return id;
}

public void setId(Long id) {
this.id = id;
}

public String getUsername() {
return username;
}

public void setUsername(String username) {
if (username == null || username.trim().length() < 3) {
throw new IllegalArgumentException("Username must be at least 3 characters");
}
this.username = username;
}

public String getEmail() {
return email;
}

public void setEmail(String email) {
if (email == null || !email.matches("^[\\w-\\.]+@([\\w-]+\\.)+[\\w-]{2,4}$")) {
throw new IllegalArgumentException("Invalid email format");
}
this.email = email;
}

public String getPasswordHash() {
return passwordHash;
}

// Скрыть прямую установку хеша пароля
// Вместо этого предоставить метод для установки пароля с хешированием
public void setPassword(String password) {
if (password == null || password.length() < 8) {
throw new IllegalArgumentException("Password must be at least 8 characters");
}

// Простое хеширование для примера
// В реальности использовали бы bcrypt или другой надежный алгоритм
this.passwordHash = String.valueOf(password.hashCode());
}

void setPasswordHash(String passwordHash) {
// package-private для использования в DAO
this.passwordHash = passwordHash;
}
}

// Неправильно:
public class User {
private List<String> permissions;

public List<String> getPermissions() {
return permissions; // Возвращает ссылку на внутреннее состояние!
}
}

// Правильно:
public class User {
private List<String> permissions;

public List<String> getPermissions() {
return Collections.unmodifiableList(permissions); // Возвращает неизменяемое представление
}

// Или возвращаем копию
public List<String> getPermissionsAsCopy() {
return new ArrayList<>(permissions);
}
}

// Неправильно: сеттер для поля, которое не должно изменяться
public class Transaction {
private final String id;

public Transaction(String id) {
this.id = id;
}

public String getId() {
return id;
}

public void setId(String id) { // Бессмысленный сеттер для финального поля
this.id = id; // Ошибка компиляции!
}
}

// Правильно: только необходимые методы
public class Transaction {
private final String id;

public Transaction(String id) {
this.id = id;
}

public String getId() {
return id;
}
// Сеттер не нужен для неизменяемого поля
}

// Неправильно:
public class Person {
public String name; // Публичное поле нарушает инкапсуляцию
protected int age; // Слишком широкий доступ без необходимости
}

// Правильно:
public class Person {
private String name; // Приватное поле
private int age; // Приватное поле

// Геттеры и сеттеры по необходимости
}

// Неправильно:
public class Vehicle {
protected int speed; // Подклассы имеют прямой доступ
}

public class Car extends Vehicle {
public void accelerate() {
speed += 10; // Прямой доступ к полю суперкласса
}
}

// Правильно:
public class Vehicle {
private int speed;

protected void setSpeed(int speed) {
if (speed >= 0) {
this.speed = speed;
}
}

protected int getSpeed() {
return speed;
}
}

public class Car extends Vehicle {
public void accelerate() {
setSpeed(getSpeed() + 10); // Использование методов суперкласса
}
}

// Использование фабричных методов для лучшей инкапсуляции
public class ConnectionFactory {
private static ConnectionFactory instance;

private ConnectionFactory() {
// Приватный конструктор предотвращает создание экземпляров
}

public static ConnectionFactory getInstance() {
if (instance == null) {
instance = new ConnectionFactory();
}
return instance;
}

public Connection createConnection(String type) {
switch (type) {
case "mysql":
return new MySQLConnection();
case "postgres":
return new PostgreSQLConnection();
case "oracle":
return new OracleConnection();
default:
throw new IllegalArgumentException("Unknown connection type: " + type);
}
}
}

// Использование билдера для сложных объектов
public class Computer {
// Обязательные параметры
private final String processor;
private final String memory;

// Опциональные параметры
private final String storage;
private final String graphicsCard;
private final String operatingSystem;

private Computer(Builder builder) {
this.processor = builder.processor;
this.memory = builder.memory;
this.storage = builder.storage;
this.graphicsCard = builder.graphicsCard;
this.operatingSystem = builder.operatingSystem;
}

// Геттеры, но нет сеттеров – иммутабельный класс

public static class Builder {
// Обязательные параметры
private final String processor;
private final String memory;

// Опциональные параметры с дефолтными значениями
private String storage = "Default SSD";
private String graphicsCard = "Integrated";
private String operatingSystem = "Linux";

public Builder(String processor, String memory) {
this.processor = processor;
this.memory = memory;
}

public Builder storage(String storage) {
this.storage = storage;
return this;
}

public Builder graphicsCard(String graphicsCard) {
this.graphicsCard = graphicsCard;
return this;
}

public Builder operatingSystem(String os) {
this.operatingSystem = os;
return this;
}

public Computer build() {
return new Computer(this);
}
}
}

// Использование:
Computer computer = new Computer.Builder("Intel Core i7", "16GB")
.storage("1TB SSD")
.graphicsCard("NVIDIA RTX 3080")
.operatingSystem("Windows 11")
.build();