ООП: классы, инкапсуляция, наследование и композиция

npm init -y
npm pkg set type=module
npm install --save-dev typescript@7.0.2 @types/node@24
npx tsc --noEmit
node order-demo.ts

{
  "compilerOptions": {
    "target": "esnext",
    "module": "nodenext",
    "strict": true,
    "noEmit": true,
    "erasableSyntaxOnly": true,
    "verbatimModuleSyntax": true,
    "allowImportingTsExtensions": true,
    "noImplicitOverride": true,
    "types": ["node"]
  }
}

export type OrderStatus = "new" | "paid" | "cancelled";
export type LineItem = { name: string; price: number; qty: number };

export class Order {
  readonly id: string;
  #items: LineItem[] = [];
  #status: OrderStatus = "new";

  constructor(id: string) {
    this.id = id;
  }

  addItem(name: string, price: number, qty = 1): void {
    this.#assertEditable();
    if (!Number.isInteger(qty) || qty <= 0) {
      throw new RangeError("Количество — целое число больше нуля");
    }
    if (price < 0) throw new RangeError("Цена не может быть отрицательной");
    this.#items.push({ name, price, qty });
  }

  pay(): void {
    this.#assertEditable();
    if (this.#items.length === 0) throw new Error("Нельзя оплатить пустой заказ");
    this.#status = "paid";
  }

  // Геттеры: снаружи можно прочитать, но нельзя присвоить
  get status(): OrderStatus {
    return this.#status;
  }

  get total(): number {
    return this.#items.reduce((sum, item) => sum + item.price * item.qty, 0);
  }

  // Отдаём копии, чтобы состав нельзя было изменить в обход addItem
  get items(): LineItem[] {
    return this.#items.map((item) => ({ ...item }));
  }

  #assertEditable(): void {
    if (this.#status !== "new") {
      throw new Error(`Заказ ${this.id} в статусе ${this.#status}, менять его нельзя`);
    }
  }
}

import { Order } from "./order.ts";

const order = new Order("A-1001");
order.addItem("Латте", 1800, 2);
order.addItem("Чизкейк", 2400);
console.log(order.total); // 6000
console.log(order.status); // new

// Инвариант: количество — целое положительное число
try {
  order.addItem("Капучино", 1700, 0);
} catch (error) {
  console.log((error as Error).message); // Количество — целое число больше нуля
}

// Копия состава не влияет на сам заказ
order.items[0].qty = 100;
console.log(order.total); // 6000

order.pay();
console.log(order.status); // paid

// После оплаты состав менять нельзя
try {
  order.addItem("Круассан", 1500);
} catch (error) {
  console.log((error as Error).message); // Заказ A-1001 в статусе paid, менять его нельзя
}

// Приватные поля недоступны снаружи даже во время выполнения
console.log(Object.keys(order)); // [ 'id' ]
console.log(JSON.stringify(order)); // {"id":"A-1001"}

// private из TypeScript — проверка только при компиляции
class SoftPrivate {
  private token = "YOUR_API_KEY";
}

// # из JavaScript — приватность обеспечивает сам язык во время выполнения
class HardPrivate {
  #token = "YOUR_API_KEY";

  hasToken(): boolean {
    return this.#token.length > 0;
  }
}

const soft = new SoftPrivate();
console.log(soft["token"]); // YOUR_API_KEY — TypeScript разрешает доступ через квадратные скобки
console.log(JSON.stringify(soft)); // {"token":"YOUR_API_KEY"}

const hard = new HardPrivate();
console.log(JSON.stringify(hard)); // {}
console.log(Object.keys(hard)); // []
console.log(hard.hasToken()); // true

// Контракт: всё, что умеет назвать себя и посчитать комиссию, — способ оплаты
export interface PaymentMethod {
  readonly title: string;
  fee(amount: number): number;
}

// Общая логика процентной комиссии — в базовом классе
abstract class PercentFeePayment implements PaymentMethod {
  abstract readonly title: string;
  readonly #percent: number;

  constructor(percent: number) {
    if (percent < 0) throw new RangeError("Комиссия не может быть отрицательной");
    this.#percent = percent;
  }

  fee(amount: number): number {
    return Math.round((amount * this.#percent) / 100);
  }
}

export class CardPayment extends PercentFeePayment {
  readonly title = "Банковская карта";

  constructor() {
    super(2); // вызвать конструктор родителя до обращения к this
  }
}

export class InstallmentPayment extends PercentFeePayment {
  readonly title: string;

  constructor(months: number) {
    super(months); // условно: 1% за каждый месяц
    this.title = `Рассрочка на ${months} мес.`;
  }

  // Переопределяем метод и дополняем результат родителя
  override fee(amount: number): number {
    return super.fee(amount) + 500; // плюс плата за оформление
  }
}

// Не наследует ничего: достаточно выполнить контракт интерфейса
export class CashOnDelivery implements PaymentMethod {
  readonly title = "Наличные курьеру";

  fee(): number {
    return 300;
  }
}

import { CardPayment, CashOnDelivery, InstallmentPayment } from "./payments.ts";
import type { PaymentMethod } from "./payments.ts";

// Функция знает только контракт PaymentMethod, а не конкретные классы
function checkout(total: number, method: PaymentMethod): string {
  const fee = method.fee(total);
  return `${method.title}: ${total} + ${fee} = ${total + fee} ₸`;
}

const card = new CardPayment();
const installment = new InstallmentPayment(6);
const cash = new CashOnDelivery();

console.log(checkout(20000, card)); // Банковская карта: 20000 + 400 = 20400 ₸
console.log(checkout(20000, installment)); // Рассрочка на 6 мес.: 20000 + 1700 = 21700 ₸
console.log(checkout(20000, cash)); // Наличные курьеру: 20000 + 300 = 20300 ₸

console.log(installment instanceof CardPayment); // false
console.log(Object.getPrototypeOf(InstallmentPayment) === Object.getPrototypeOf(CardPayment)); // true — общий родитель

// Правило цены — маленький объект с одной обязанностью
export interface PriceRule {
  readonly label: string;
  apply(amount: number): number;
}

export class PercentDiscount implements PriceRule {
  readonly label: string;
  readonly #percent: number;

  constructor(percent: number) {
    if (percent < 0 || percent > 100) throw new RangeError("Скидка — от 0 до 100%");
    this.#percent = percent;
    this.label = `Скидка ${percent}%`;
  }

  apply(amount: number): number {
    return Math.round(amount * (1 - this.#percent / 100));
  }
}

export class ExpressDelivery implements PriceRule {
  readonly label = "Экспресс-доставка";

  apply(amount: number): number {
    return amount + 1500;
  }
}

// Ценообразование СОДЕРЖИТ правила, а не наследует их
export class Pricing {
  readonly #rules: PriceRule[];

  constructor(rules: PriceRule[]) {
    this.#rules = [...rules];
  }

  total(subtotal: number): number {
    return this.#rules.reduce((amount, rule) => rule.apply(amount), subtotal);
  }

  describe(): string {
    return this.#rules.map((rule) => rule.label).join(" → ") || "без правил";
  }
}

import { ExpressDelivery, PercentDiscount, Pricing } from "./pricing.ts";
import type { PriceRule } from "./pricing.ts";

// Любая комбинация собирается без новых классов
const regular = new Pricing([]);
const promo = new Pricing([new PercentDiscount(10)]);
const promoExpress = new Pricing([new PercentDiscount(10), new ExpressDelivery()]);

console.log(regular.total(20000), regular.describe()); // 20000 без правил
console.log(promo.total(20000), promo.describe()); // 18000 Скидка 10%
console.log(promoExpress.total(20000), promoExpress.describe()); // 19500 Скидка 10% → Экспресс-доставка

// Подойдёт и обычный объект: TypeScript сверяет форму, а не родословную
const roundDown: PriceRule = { label: "Округление до 100", apply: (amount) => Math.floor(amount / 100) * 100 };
console.log(new Pricing([new PercentDiscount(7), roundDown]).total(20250)); // 18800

import java.util.ArrayList;
import java.util.List;

record LineItem(String name, int price, int qty) {}

enum OrderStatus { NEW, PAID }

class Order {
    private final String id;
    private final List<LineItem> items = new ArrayList<>();
    private OrderStatus status = OrderStatus.NEW;

    Order(String id) {
        this.id = id;
    }

    void addItem(String name, int price, int qty) {
        assertEditable();
        if (qty <= 0) throw new IllegalArgumentException("Количество — целое число больше нуля");
        if (price < 0) throw new IllegalArgumentException("Цена не может быть отрицательной");
        items.add(new LineItem(name, price, qty));
    }

    void pay() {
        assertEditable();
        if (items.isEmpty()) throw new IllegalStateException("Нельзя оплатить пустой заказ");
        status = OrderStatus.PAID;
    }

    OrderStatus getStatus() { return status; }

    int getTotal() {
        return items.stream().mapToInt(item -> item.price() * item.qty()).sum();
    }

    List<LineItem> getItems() { return List.copyOf(items); } // неизменяемая копия

    private void assertEditable() {
        if (status != OrderStatus.NEW) {
            throw new IllegalStateException("Заказ " + id + " в статусе " + status + ", менять его нельзя");
        }
    }
}

interface PaymentMethod {
    String title();
    int fee(int amount);
}

class CardPayment implements PaymentMethod {
    public String title() { return "Банковская карта"; }
    public int fee(int amount) { return Math.round(amount * 0.02f); }
}

class CashOnDelivery implements PaymentMethod {
    public String title() { return "Наличные курьеру"; }
    public int fee(int amount) { return 300; }
}

public class Shop {
    static String checkout(int total, PaymentMethod method) {
        int fee = method.fee(total);
        return method.title() + ": " + total + " + " + fee + " = " + (total + fee) + " ₸";
    }

    public static void main(String[] args) {
        Order order = new Order("A-1001");
        order.addItem("Латте", 1800, 2);
        order.addItem("Чизкейк", 2400, 1);
        System.out.println(order.getTotal()); // 6000

        order.pay();
        System.out.println(order.getStatus()); // PAID

        try {
            order.addItem("Круассан", 1500, 1);
        } catch (IllegalStateException error) {
            System.out.println(error.getMessage()); // Заказ A-1001 в статусе PAID, менять его нельзя
        }

        System.out.println(checkout(20000, new CardPayment())); // Банковская карта: 20000 + 400 = 20400 ₸
        System.out.println(checkout(20000, new CashOnDelivery())); // Наличные курьеру: 20000 + 300 = 20300 ₸
    }
}