ООП в Java: как абстрактные концепции превращаются в прибыль

public abstract class Account {
protected String accountNumber;
protected double balance;
protected Customer owner;

public abstract boolean withdraw(double amount);

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

// Геттеры и сеттеры с проверкой прав доступа
}

public class SavingsAccount extends Account {
private double interestRate;

@Override
public boolean withdraw(double amount) {
// Проверка минимального остатка для сберегательного счета
if (balance – amount >= 100) {
balance -= amount;
return true;
}
return false;
}

public void applyInterest() {
balance += balance * interestRate;
}
}

public class Transaction {
private final String id;
private final LocalDateTime timestamp;
private final TransactionType type;
private final double amount;
private final Account sourceAccount;
private final Account destinationAccount;
private TransactionStatus status;

// Конструктор, валидирующий входные данные

// Только чтение для большинства полей
public String getId() {
return id;
}

// Статус может меняться через контролируемые методы
public void markAsCompleted() {
if (this.status == TransactionStatus.PENDING) {
this.status = TransactionStatus.COMPLETED;
}
}

// Бизнес-логика транзакции
public boolean execute() {
// Логика выполнения в зависимости от типа
}
}

public interface PaymentProcessor {
PaymentResult process(Order order, PaymentDetails details);
boolean supportsPaymentMethod(PaymentMethod method);
void refund(Payment payment, double amount);
}

public class CreditCardProcessor implements PaymentProcessor {
@Override
public PaymentResult process(Order order, PaymentDetails details) {
// Реализация обработки оплаты кредитной картой
// Подключение к шлюзу, авторизация, списание средств
}

@Override
public boolean supportsPaymentMethod(PaymentMethod method) {
return method == PaymentMethod.CREDIT_CARD;
}

@Override
public void refund(Payment payment, double amount) {
// Реализация возврата средств на карту
}
}

public class PayPalProcessor implements PaymentProcessor {
@Override
public PaymentResult process(Order order, PaymentDetails details) {
// Реализация обработки оплаты через PayPal
// OAuth, API calls, обработка колбэков
}

@Override
public boolean supportsPaymentMethod(PaymentMethod method) {
return method == PaymentMethod.PAYPAL;
}

@Override
public void refund(Payment payment, double amount) {
// Реализация возврата средств через PayPal API
}
}

public class PaymentService {
private List<PaymentProcessor> processors;

public PaymentResult processPayment(Order order, PaymentDetails details) {
PaymentProcessor processor = processors.stream()
.filter(p -> p.supportsPaymentMethod(details.getMethod()))
.findFirst()
.orElseThrow(() -> new UnsupportedPaymentMethodException());

return processor.process(order, details);
}
}

public abstract class Product {
private String id;
private String name;
private double basePrice;
private Category category;

public abstract double calculatePrice();
public abstract boolean isAvailable();
public abstract int getDeliveryTimeInDays();

// Общие методы для всех типов товаров
}

public class PhysicalProduct extends Product {
private int weightInGrams;
private Dimensions dimensions;
private int stockQuantity;

@Override
public double calculatePrice() {
// Расчет с учетом веса, габаритов, акций и т.д.
}

@Override
public boolean isAvailable() {
return stockQuantity > 0;
}

@Override
public int getDeliveryTimeInDays() {
// Расчет времени доставки на основе местоположения склада
}
}

public class DigitalProduct extends Product {
private String downloadUrl;
private long fileSizeBytes;

@Override
public double calculatePrice() {
// Расчет с учетом лицензирования, объема и т.д.
}

@Override
public boolean isAvailable() {
// Цифровые товары всегда доступны
return true;
}

@Override
public int getDeliveryTimeInDays() {
// Мгновенная доставка
return 0;
}
}

public interface DiscountStrategy {
double applyDiscount(Order order);
}

public class PercentageDiscount implements DiscountStrategy {
private double percentage;

@Override
public double applyDiscount(Order order) {
return order.getTotal() * (percentage / 100);
}
}

public class BuyOneGetOneFree implements DiscountStrategy {
private String productId;

@Override
public double applyDiscount(Order order) {
// Поиск товаров, подходящих под акцию, и расчет скидки
}
}

public abstract class GameObject {
protected Vector2D position;
protected Vector2D velocity;
protected float rotation;
protected boolean active;

public abstract void update(float deltaTime);
public abstract void render(Graphics g);
public abstract void handleCollision(GameObject other);

// Общие методы для всех игровых объектов
public boolean isColliding(GameObject other) {
// Базовая проверка коллизий
}
}

public abstract class Character extends GameObject {
protected int health;
protected int maxHealth;
protected float movementSpeed;

public abstract void attack();
public abstract void takeDamage(int amount);

@Override
public void update(float deltaTime) {
// Базовое обновление для всех персонажей
position.add(velocity.multiply(deltaTime));

// Дополнительные проверки общие для всех персонажей
}
}

public class Player extends Character {
private Inventory inventory;
private List<Ability> abilities;

@Override
public void attack() {
// Реализация атаки игрока
}

@Override
public void takeDamage(int amount) {
health -= amount;
if (health <= 0) {
gameOver();
}
}

@Override
public void render(Graphics g) {
// Отрисовка игрока
}

@Override
public void handleCollision(GameObject other) {
if (other instanceof Item) {
inventory.addItem((Item) other);
} else if (other instanceof Enemy) {
takeDamage(((Enemy) other).getDamage());
}
}

// Специфичные для игрока методы
}

public class Enemy extends Character {
private AI ai;
private int damageAmount;

@Override
public void update(float deltaTime) {
super.update(deltaTime);
ai.makeDecision(this, deltaTime);
}

@Override
public void attack() {
// Реализация атаки противника
}

@Override
public void takeDamage(int amount) {
health -= amount;
if (health <= 0) {
die();
}
}

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

public class GameWorld {
private List<GameObject> gameObjects = new ArrayList<>();

public void update(float deltaTime) {
// Полиморфный вызов update для всех игровых объектов
gameObjects.forEach(obj -> obj.update(deltaTime));

// Обработка коллизий
for (int i = 0; i < gameObjects.size(); i++) {
GameObject obj1 = gameObjects.get(i);
for (int j = i + 1; j < gameObjects.size(); j++) {
GameObject obj2 = gameObjects.get(j);
if (obj1.isColliding(obj2)) {
obj1.handleCollision(obj2);
obj2.handleCollision(obj1);
}
}
}
}

public void render(Graphics g) {
// Полиморфный вызов render для всех игровых объектов
gameObjects.forEach(obj -> obj.render(g));
}
}

public class GameObject {
private List<Component> components = new ArrayList<>();

public void update(float deltaTime) {
components.forEach(component -> component.update(deltaTime));
}

public void render(Graphics g) {
components.stream()
.filter(c -> c instanceof RenderComponent)
.forEach(c -> ((RenderComponent) c).render(g));
}

public <T extends Component> T getComponent(Class<T> type) {
return components.stream()
.filter(c -> type.isAssignableFrom(c.getClass()))
.map(c -> (T) c)
.findFirst()
.orElse(null);
}
}

public abstract class Component {
protected GameObject gameObject;

public abstract void update(float deltaTime);
}

public class PhysicsComponent extends Component {
private Vector2D velocity;

@Override
public void update(float deltaTime) {
// Обновление физики объекта
gameObject.position.add(velocity.multiply(deltaTime));
}
}

public class HealthComponent extends Component {
private int health;
private int maxHealth;

@Override
public void update(float deltaTime) {
// Логика регенерации и т.п.
}

public void takeDamage(int amount) {
health -= amount;
if (health <= 0) {
// Обработка смерти
}
}
}

// Spring Core – IoC контейнер
public interface ApplicationContext extends BeanFactory, MessageSource, 
ApplicationEventPublisher, ResourcePatternResolver {
String getId();
String getApplicationName();
String getDisplayName();
long getStartupDate();
ApplicationContext getParent();
AutowireCapableBeanFactory getAutowireCapableBeanFactory();
}

// Spring MVC – контроллеры
@Controller
public class UserController {
private final UserService userService;

@Autowired
public UserController(UserService userService) {
this.userService = userService;
}

@GetMapping("/users/{id}")
public ResponseEntity<User> getUser(@PathVariable Long id) {
return ResponseEntity.ok(userService.findById(id));
}
}

// Spring Data – репозитории
public interface UserRepository extends JpaRepository<User, Long> {
List<User> findByLastName(String lastName);

@Query("SELECT u FROM User u WHERE u.email = :email")
Optional<User> findByEmail(@Param("email") String email);
}

@Entity
@Table(name = "products")
public class Product {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;

private String name;
private BigDecimal price;

@ManyToOne
@JoinColumn(name = "category_id")
private Category category;

@OneToMany(mappedBy = "product", cascade = CascadeType.ALL)
private List<Review> reviews = new ArrayList<>();

// Геттеры и сеттеры
}

// Использование Hibernate Session
Session session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();

Product product = new Product();
product.setName("Smartphone");
product.setPrice(new BigDecimal("999.99"));
product.setCategory(session.get(Category.class, 1L));

session.save(product);
tx.commit();
session.close();

// Определение Producer
Properties props = new Properties();
props.put("bootstrap.servers", "localhost:9092");
props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");

Producer<String, String> producer = new KafkaProducer<>(props);
producer.send(new ProducerRecord<>("my-topic", "key", "value"));

// Определение Consumer
Properties consumerProps = new Properties();
consumerProps.put("bootstrap.servers", "localhost:9092");
consumerProps.put("group.id", "my-group");
consumerProps.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
consumerProps.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");

Consumer<String, String> consumer = new KafkaConsumer<>(consumerProps);
consumer.subscribe(Arrays.asList("my-topic"));

while (true) {
ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100));
for (ConsumerRecord<String, String> record : records) {
System.out.println(record.value());
}
}