S.O.L.I.D Principles

Bad Example
```
class User {
  private username: string;
  private password: string;

  constructor(username: string, password: string) {
    this.username = username;
    this.password = password;
  }

  login(): void {
    // Logic to handle user login
  }

  save(): void {
    // Logic to save user to the database
  }

  sendEmail(): void {
    // Logic to send an email to the user
  }
}

Good Example
```
class User {
  private username: string;
  private password: string;

  constructor(username: string, password: string) {
    this.username = username;
    this.password = password;
  }

  login(): void {
    // Logic to handle user login
  }
}

class UserRepository {
  save(user: User): void {
    // Logic to save user to the database
  }
}

class EmailService {
  sendEmail(user: User): void {
    // Logic to send an email to the user
  }
}

Bad Eample
```
enum ShapeType {
  Circle,
  Rectangle,
  Triangle
}

class Shape {
  private type: ShapeType;

  constructor(type: ShapeType) {
    this.type = type;
  }

  calculateArea(): number {
    if (this.type === ShapeType.Circle) {
      // Calculation for circle area
    } else if (this.type === ShapeType.Rectangle) {
      // Calculation for rectangle area
    } else if (this.type === ShapeType.Triangle) {
      // Calculation for triangle area
    }
  }
}
```

Good Example
```
abstract class Shape {
  abstract calculateArea(): number;
}

class Circle extends Shape {
  private radius: number;

  constructor(radius: number) {
    super();
    this.radius = radius;
  }

  calculateArea(): number {
    return Math.PI * this.radius * this.radius;
  }
}

class Rectangle extends Shape {
  private width: number;
  private height: number;

  constructor(width: number, height: number) {
    super();
    this.width = width;
    this.height = height;
  }

  calculateArea(): number {
    return this.width * this.height;
  }
}

class Triangle extends Shape {
  private base: number;
  private height: number;

  constructor(base: number, height: number) {
    super();
    this.base = base;
    this.height = height;
  }

  calculateArea(): number {
    return (this.base * this.height) / 2;
  }
}

Example
```
class Shape {
  getArea(): number {
    throw new Error('Method not implemented');
  }
}

class Rectangle extends Shape {
  private width: number;
  private height: number;

  constructor(width: number, height: number) {
    super();
    this.width = width;
    this.height = height;
  }

  getWidth(): number {
    return this.width;
  }

  getHeight(): number {
    return this.height;
  }

  getArea(): number {
    return this.width * this.height;
  }
}

class Square extends Shape {
  private side: number;

  constructor(side: number) {
    super();
    this.side = side;
  }

  getSide(): number {
    return this.side;
  }

  getArea(): number {
    return this.side * this.side;
  }
}

Bad Example
```
interface IWorker {
  doWork(): void;
  takeBreak(): void;
  attendMeeting(): void;
}

class Employee implements IWorker {
  doWork(): void {
    // Implementation of work logic
  }

  takeBreak(): void {
    // Implementation of break logic
  }

  attendMeeting(): void {
    // Implementation of meeting logic
  }
}

class Robot implements IWorker {
  doWork(): void {
    // Implementation of work logic
  }

  takeBreak(): void {
    throw new Error("Robots don't take breaks.");
  }

  attendMeeting(): void {
    throw new Error("Robots don't attend meetings.");
  }
}

Good Example
```
interface IWorker {
  doWork(): void;
}

interface IBreakable {
  takeBreak(): void;
}

interface IMeetingAttendee {
  attendMeeting(): void;
}

class Employee implements IWorker, IBreakable, IMeetingAttendee {
  doWork(): void {
    // Implementation of work logic
  }

  takeBreak(): void {
    // Implementation of break logic
  }

  attendMeeting(): void {
    // Implementation of meeting logic
  }
}

class Robot implements IWorker {
  doWork(): void {
    // Implementation of work logic
  }
}

Bad Example
```
class Order {
  private paymentProcessor: PaymentProcessor;

  constructor() {
    this.paymentProcessor = new PaymentProcessor();
  }

  processPayment(amount: number): void {
    this.paymentProcessor.process(amount);
  }
}

class PaymentProcessor {
  process(amount: number): void {
    // Logic to process the payment
  }
}

Good Example
```
interface PaymentProcessor {
  process(amount: number): void;
}

class Order {
  private paymentProcessor: PaymentProcessor;

  constructor(paymentProcessor: PaymentProcessor) {
    this.paymentProcessor = paymentProcessor;
  }

  processPayment(amount: number): void {
    this.paymentProcessor.process(amount);
  }
}

class CreditCardPaymentProcessor implements PaymentProcessor {
  process(amount: number): void {
    // Logic to process the payment using a credit card
  }
}

class PayPalPaymentProcessor implements PaymentProcessor {
  process(amount: number): void {
    // Logic to process the payment using PayPal
  }
}