ООП в программировании: от теории к практическим примерам кода

// Базовый класс для всех типов банковских счетов
public abstract class Account {
protected double balance;
protected String owner;

public Account(String owner, double initialBalance) {
this.owner = owner;
this.balance = initialBalance;
}

// Абстрактный метод, который должны реализовать подклассы
public abstract void calculateInterest();

public void deposit(double amount) {
if (amount > 0) {
balance += amount;
System.out.println(amount + " добавлено на счет");
}
}

public boolean withdraw(double amount) {
if (amount > 0 && balance >= amount) {
balance -= amount;
System.out.println(amount + " снято со счета");
return true;
}
return false;
}
}

public class Product {
private String id;
private String name;
private double price;
private int stockQuantity;

// Конструктор
public Product(String id, String name, double price, int stockQuantity) {
this.id = id;
this.name = name;
this.price = price;
this.stockQuantity = stockQuantity;
}

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

public String getName() { return name; }
public void setName(String name) { this.name = name; }

public double getPrice() { return price; }
public void setPrice(double price) {
if (price < 0) throw new IllegalArgumentException("Цена не может быть отрицательной");
this.price = price;
}

public int getStockQuantity() { return stockQuantity; }
public void setStockQuantity(int stockQuantity) {
if (stockQuantity < 0) throw new IllegalArgumentException("Количество не может быть отрицательным");
this.stockQuantity = stockQuantity;
}

// Бизнес-логика
public boolean isInStock() {
return stockQuantity > 0;
}

public void decreaseStock(int quantity) {
if (quantity > stockQuantity) {
throw new IllegalArgumentException("Недостаточно товара на складе");
}
stockQuantity -= quantity;
}
}

public class Order {
private String orderId;
private Customer customer;
private List<OrderItem> items;
private LocalDateTime orderDate;
private OrderStatus status;

public Order(String orderId, Customer customer) {
this.orderId = orderId;
this.customer = customer;
this.items = new ArrayList<>();
this.orderDate = LocalDateTime.now();
this.status = OrderStatus.PENDING;
}

// Бизнес-методы
public void addItem(Product product, int quantity) {
if (status != OrderStatus.PENDING) {
throw new IllegalStateException("Нельзя добавить товар к обработанному заказу");
}

// Проверяем наличие товара
if (!product.isInStock() || product.getStockQuantity() < quantity) {
throw new IllegalArgumentException("Товар недоступен в требуемом количестве");
}

// Добавляем позицию в заказ
OrderItem item = new OrderItem(product, quantity);
items.add(item);

// Уменьшаем количество на складе
product.decreaseStock(quantity);
}

public double calculateTotal() {
return items.stream()
.mapToDouble(OrderItem::getSubtotal)
.sum();
}

public void processOrder() {
if (items.isEmpty()) {
throw new IllegalStateException("Невозможно обработать пустой заказ");
}

// Логика обработки заказа...
status = OrderStatus.PROCESSING;
}

// Геттеры, вложенный класс OrderItem и перечисление OrderStatus...
}

public class BankAccount {
private String accountNumber;
private double balance;
private List<Transaction> transactionHistory;
private static final double DAILY_WITHDRAWAL_LIMIT = 1000.0;

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

public double getBalance() {
return balance;
}

// Нет прямого сеттера для баланса!

public boolean withdraw(double amount) {
// Проверяем лимит снятия
if (amount > DAILY_WITHDRAWAL_LIMIT) {
return false;
}

// Проверяем достаточность средств
if (amount > balance) {
return false;
}

// Выполняем снятие и записываем транзакцию
balance -= amount;
transactionHistory.add(new Transaction("withdrawal", amount));
return true;
}

public void deposit(double amount) {
if (amount <= 0) {
throw new IllegalArgumentException("Сумма депозита должна быть положительной");
}

balance += amount;
transactionHistory.add(new Transaction("deposit", amount));
}

public List<Transaction> getTransactions() {
// Возвращаем копию списка, чтобы защитить оригинал от изменений
return new ArrayList<>(transactionHistory);
}

// Другие методы...
}

public abstract class Employee {
protected String id;
protected String name;
protected double baseSalary;

public Employee(String id, String name, double baseSalary) {
this.id = id;
this.name = name;
this.baseSalary = baseSalary;
}

// Общие методы для всех сотрудников
public String getId() { return id; }
public String getName() { return name; }

// Абстрактный метод, который должен быть реализован подклассами
public abstract double calculateSalary();
}

public class HourlyEmployee extends Employee {
private double hourlyRate;
private int hoursWorked;

public HourlyEmployee(String id, String name, double baseSalary, double hourlyRate) {
super(id, name, baseSalary);
this.hourlyRate = hourlyRate;
}

public void setHoursWorked(int hours) {
if (hours < 0) {
throw new IllegalArgumentException("Часы работы не могут быть отрицательными");
}
this.hoursWorked = hours;
}

@Override
public double calculateSalary() {
return baseSalary + (hourlyRate * hoursWorked);
}
}

public class SalariedEmployee extends Employee {
private double bonus;

public SalariedEmployee(String id, String name, double baseSalary) {
super(id, name, baseSalary);
this.bonus = 0;
}

public void setBonus(double bonus) {
if (bonus < 0) {
throw new IllegalArgumentException("Бонус не может быть отрицательным");
}
this.bonus = bonus;
}

@Override
public double calculateSalary() {
return baseSalary + bonus;
}
}

// Базовый интерфейс для всех графических элементов
public interface Shape {
void draw(Canvas canvas);
double calculateArea();
boolean containsPoint(Point point);
}

// Конкретные реализации
public class Circle implements Shape {
private Point center;
private double radius;

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

@Override
public void draw(Canvas canvas) {
// Специфическая для круга логика рисования
canvas.drawCircle(center.getX(), center.getY(), radius);
}

@Override
public double calculateArea() {
return Math.PI * radius * radius;
}

@Override
public boolean containsPoint(Point point) {
double distance = Math.sqrt(
Math.pow(point.getX() – center.getX(), 2) + 
Math.pow(point.getY() – center.getY(), 2)
);
return distance <= radius;
}
}

public class Rectangle implements Shape {
private Point topLeft;
private double width;
private double height;

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

@Override
public void draw(Canvas canvas) {
// Специфическая для прямоугольника логика рисования
canvas.drawRect(topLeft.getX(), topLeft.getY(), width, height);
}

@Override
public double calculateArea() {
return width * height;
}

@Override
public boolean containsPoint(Point point) {
return point.getX() >= topLeft.getX() && 
point.getX() <= topLeft.getX() + width &&
point.getY() >= topLeft.getY() &&
point.getY() <= topLeft.getY() + height;
}
}

// Использование полиморфизма
public class DrawingApplication {
private List<Shape> shapes = new ArrayList<>();

public void addShape(Shape shape) {
shapes.add(shape);
}

public void drawAllShapes(Canvas canvas) {
for (Shape shape : shapes) {
// Полиморфный вызов – разные классы реагируют по-разному
shape.draw(canvas);
}
}

public Shape findShapeAt(Point point) {
// Итерируем в обратном порядке, чтобы найти верхнюю фигуру
for (int i = shapes.size() – 1; i >= 0; i--) {
Shape shape = shapes.get(i);
if (shape.containsPoint(point)) {
return shape;
}
}
return null;
}
}

public class ShapeFactory {
public static Shape createShape(String className, Map<String, Object> parameters) {
try {
// Получаем класс по имени
Class<?> shapeClass = Class.forName(className);

// Находим подходящий конструктор
Constructor<?>[] constructors = shapeClass.getConstructors();
for (Constructor<?> constructor : constructors) {
Class<?>[] paramTypes = constructor.getParameterTypes();
Object[] args = new Object[paramTypes.length];

boolean canUseConstructor = true;
for (int i = 0; i < paramTypes.length; i++) {
String paramName = "param" + i; // Упрощенная схема именования
if (parameters.containsKey(paramName) &&
paramTypes[i].isAssignableFrom(parameters.get(paramName).getClass())) {
args[i] = parameters.get(paramName);
} else {
canUseConstructor = false;
break;
}
}

if (canUseConstructor) {
// Создаем экземпляр объекта через найденный конструктор
return (Shape) constructor.newInstance(args);
}
}

throw new IllegalArgumentException("Не найден подходящий конструктор");

} catch (ClassNotFoundException | InstantiationException | 
IllegalAccessException | InvocationTargetException e) {
throw new RuntimeException("Не удалось создать фигуру", e);
}
}
}

// Паттерн Singleton – гарантирует, что класс имеет только один экземпляр
public class OrderDatabase {
private static OrderDatabase instance;
private List<Order> orders = new ArrayList<>();

private OrderDatabase() {
// Приватный конструктор предотвращает создание через new
}

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

public void addOrder(Order order) {
orders.add(order);
// Логика сохранения в БД...
}

public List<Order> getOrdersByCustomer(Customer customer) {
return orders.stream()
.filter(order -> order.getCustomer().equals(customer))
.collect(Collectors.toList());
}

// Другие методы...
}

// Паттерн Factory Method – предоставляет интерфейс для создания объектов
public abstract class PaymentProcessor {
public final void processPayment(Order order) {
// Шаблонный метод определяет алгоритм
validateOrder(order);
double amount = calculateAmount(order);
doProcessPayment(order, amount);
notifyPaymentComplete(order);
}

// Этот метод должен быть реализован подклассами
protected abstract void doProcessPayment(Order order, double amount);

private void validateOrder(Order order) {
// Общая логика проверки заказа...
}

private double calculateAmount(Order order) {
return order.calculateTotal();
}

private void notifyPaymentComplete(Order order) {
// Отправка уведомлений...
}
}

// Конкретные процессоры платежей
public class CreditCardProcessor extends PaymentProcessor {
@Override
protected void doProcessPayment(Order order, double amount) {
// Логика обработки платежа кредитной картой...
}
}

public class PayPalProcessor extends PaymentProcessor {
@Override
protected void doProcessPayment(Order order, double amount) {
// Логика обработки платежа через PayPal...
}
}

// Паттерн Factory – создает процессоры платежей
public class PaymentProcessorFactory {
public static PaymentProcessor createProcessor(String type) {
switch (type.toLowerCase()) {
case "creditcard":
return new CreditCardProcessor();
case "paypal":
return new PayPalProcessor();
// Другие типы...
default:
throw new IllegalArgumentException("Неизвестный тип процессора: " + type);
}
}
}

// Интерфейс наблюдателя
public interface OrderObserver {
void onOrderStatusChanged(Order order, OrderStatus oldStatus, OrderStatus newStatus);
}

// Класс заказа поддерживает наблюдателей
public class Order {
private String orderId;
private Customer customer;
private List<OrderItem> items;
private OrderStatus status;
private List<OrderObserver> observers = new ArrayList<>();

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

public void addObserver(OrderObserver observer) {
observers.add(observer);
}

public void removeObserver(OrderObserver observer) {
observers.remove(observer);
}

public void setStatus(OrderStatus newStatus) {
OrderStatus oldStatus = this.status;
this.status = newStatus;

// Уведомляем всех наблюдателей об изменении
for (OrderObserver observer : observers) {
observer.onOrderStatusChanged(this, oldStatus, newStatus);
}
}
}

// Конкретные наблюдатели
public class EmailNotifier implements OrderObserver {
@Override
public void onOrderStatusChanged(Order order, OrderStatus oldStatus, OrderStatus newStatus) {
if (newStatus == OrderStatus.SHIPPED) {
// Отправляем уведомление о доставке
sendShippingEmail(order.getCustomer().getEmail(), order);
}
}

private void sendShippingEmail(String email, Order order) {
// Логика отправки email...
}
}

public class InventoryManager implements OrderObserver {
@Override
public void onOrderStatusChanged(Order order, OrderStatus oldStatus, OrderStatus newStatus) {
if (newStatus == OrderStatus.COMPLETED) {
// Обновляем статистику по товарам
updateInventoryStatistics(order);
}
}

private void updateInventoryStatistics(Order order) {
// Логика обновления статистики...
}
}