კლასი

class Warrior {
  constructor() {}
}

// ❌ არასწორი მიდგომა

class Warrior {
  constructor(name: string) {
    this.name = name;
  }
}

// ✅ სწორი მიდგომა

class Warrior {
  name: string;
  constructor(name: string) {
    this.name = name;
  }
}

class User {
  public name: string;
  protected email: string;
  private password: string;

  public details() {}
  protected sendEmail() {}
  private resetPassword() {}
}

class User {
  constructor(public name: string) {}
}

class User {
  public name: string;

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

class Animal {
  name: string;

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

  move(distance: number): void {
    console.log(`${this.name} moved ${distance} meters.`);
  }
}

class Dog extends Animal {
  breed: string;

  constructor(name: string, breed: string) {
    super(name);
    this.breed = breed;
  }

  bark(): void {
    console.log(`${this.name}, a ${this.breed}, says: Woof!`);
  }
}

class Bird extends Animal {
  override move(distance: number): void {
    console.log(`${this.name} is flying ${distance} meters.`);
  }

  oldMove(distance: number) {
    super.move(distance);
  }
}

const dog = new Dog('Buddy', 'Golden Retriever');
dog.bark(); // Buddy, a Golden Retriever, says: Woof!
dog.move(10); // Buddy moved 10 meters.

const bird = new Bird('Sky');
bird.move(10); // Sky is flying 10 meters.
bird.oldMove(10); // Sky moved 10 meters.

class Box<T> {
  contents: T;
  constructor(value: T) {
    this.contents = value;
  }
}

const box = new Box('გამარჯობა!');
const box2 = new Box<string>('გამარჯობა!');

class Box<T> {
  contents: T | null = null;

  setContent(content: T) {
    this.contents = content;
  }
}

const box = new Box<number>();
box.setContent(27);
box.setContent('22'); // Argument of type 'string' is not assignable to parameter of type 'number'.

const box1 = new Box<string>();
box1.setContent('educata');

class Box {
  private content: string;

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

  get boxContent() {
    return this.decipher(this.content);
  }

  set boxContent(newContent: string) {
    this.content = newContent;
  }

  get boxContentWithoutCipher() {
    return this.content;
  }

  private cipher(text: string): string {
    return text
      .split('')
      .map((char) => String.fromCharCode(char.charCodeAt(0) + 3))
      .join('');
  }

  private decipher(text: string): string {
    return text
      .split('')
      .map((char) => String.fromCharCode(char.charCodeAt(0) - 3))
      .join('');
  }
}

const box = new Box('Educata');
console.log(box.boxContent); // "Bar`^q^"
console.log(box.boxContentWithoutCipher); // "Educata"
box.boxContent = 'Iswavle';
console.log(box.boxContent); // "Fpt^sib"
console.log(box.boxContentWithoutCipher); // "Iswavle"

interface UserContactInfo {
  id: number;
  name: string;
  email: string;

  getDetails(): string;
  updateEmail(newEmail: string): void;
}

class User implements UserContactInfo {
  id: number;
  name: string;
  email: string;

  constructor(id: number, name: string, email: string) {
    this.id = id;
    this.name = name;
    this.email = email;
  }

  getDetails(): string {
    return `User: ${this.name} (ID: ${this.id}), Email: ${this.email}`;
  }

  updateEmail(newEmail: string): void {
    this.email = newEmail;
  }
}

class Book {
  readonly title: string;
  readonly author: string;

  constructor(title: string, author: string) {
    this.title = title;
    this.author = author;
  }

  displayInfo(): void {
    console.log(`${this.title}, ავტორი ${this.author}`);
  }
}

const book = new Book('ვეფხისტყაოსანი', 'შოთა რუსთაველი');
book.displayInfo(); // "ვეფხისტყაოსანი, ავტორი შოთა რუსთაველი"

book.author = 'ტარიელი'; // Error: Cannot assign to 'title' because it is a read-only property.

abstract class Vehicle {
  brand: string;
  model: string;
  year: number;

  constructor(brand: string, model: string, year: number) {
    this.brand = brand;
    this.model = model;
    this.year = year;
  }

  abstract startEngine(): void;

  displayInfo(): void {
    console.log(`${this.year} ${this.brand} ${this.model}`);
  }
}

class Car extends Vehicle {
  constructor(brand: string, model: string, year: number) {
    super(brand, model, year);
  }

  startEngine(): void {
    console.log(`The engine of the ${this.brand} ${this.model} car is now running.`);
  }
}

class Truck extends Vehicle {
  constructor(brand: string, model: string, year: number) {
    super(brand, model, year);
  }

  startEngine(): void {
    console.log(`The engine of the ${this.brand} ${this.model} truck is now running.`);
  }
}

const car = new Car('Toyota', 'Camry', 2020);
car.displayInfo(); // 2020 Toyota Camry
car.startEngine(); // The engine of the Toyota Camry car is now running.

const truck = new Truck('Ford', 'F-150', 2022);
truck.displayInfo(); // 2022 Ford F-150
truck.startEngine(); // The engine of the Ford F-150 truck is now running.