Epic Cosmos 1: обектите в космоса

Проблем

Космическа надпревара

Човечеството вече може да лети до далечни планети. Корпорации и държави се надпреварват за ресурсите им. Ти управляваш една от мисиите и искаш да станеш най-силната сила в космоса.

Правилата на Epic Cosmos:

• Точки се трупат с откриване на нови планети и обекти, добив на ресурси, строеж на сгради и кораби, научни открития.
• Обектите са звезди, планети и спътници. Звездата дава енергия. Някои планети имат редки ресурси, а атмосферата им решава какво може да се строи. Спътникът е за връзка и разузнаване.
• Ресурсите са нужни за строеж, проучвания и поддръжка на базите и корабите.
• Сградите добиват ресурси, проучват технологии, пазят базата и правят кораби.
• Технологиите отключват нови сгради, кораби и умения.
• Конфликти: в космоса не си сам. Има пирати и други играчи.
• Край: играта свършва, когато някой стигне определен брой точки или след определен брой ходове. Печели този с най-много точки.

Преди сградите и корабите ти трябва самият свят: какви обекти има, къде са и кой около кого може да обикаля. Това е урокът. Ресурсите, сградите и корабите са в следващия.

Идеята

Всичко в космоса е SpaceObject

Звездата, планетата и спътникът имат общо: име, координати x, y, z и маса. Общото отива в абстрактен клас:

Java

abstract class SpaceObject {
    private String name;
    private double coordinateX;
    private double coordinateY;
    private double coordinateZ;
    private double mass;

    public SpaceObject(String name, double coordinateX, double coordinateY, double coordinateZ, double mass) {
        this.name = name;
        this.coordinateX = coordinateX;
        this.coordinateY = coordinateY;
        this.coordinateZ = coordinateZ;
        this.mass = mass;
    }

    public String getName() {
        return name;
    }

    public double getCoordinateX() {
        return coordinateX;
    }

    public double getCoordinateY() {
        return coordinateY;
    }

    public double getCoordinateZ() {
        return coordinateZ;
    }

    public double getMass() {
        return mass;
    }

    public abstract String getKind();

    public void displayInfo() {
        System.out.printf("%s %s: (%.1f, %.1f, %.1f), маса %.2f%n", getKind(), name, coordinateX, coordinateY, coordinateZ, mass);
    }

    protected void moveTo(double x, double y, double z) {
        coordinateX = x;
        coordinateY = y;
        coordinateZ = z;
    }
}

C#

abstract class SpaceObject
{
    public string Name { get; }
    public double CoordinateX { get; private set; }
    public double CoordinateY { get; private set; }
    public double CoordinateZ { get; private set; }
    public double Mass { get; }

    public SpaceObject(string name, double coordinateX, double coordinateY, double coordinateZ, double mass)
    {
        Name = name;
        CoordinateX = coordinateX;
        CoordinateY = coordinateY;
        CoordinateZ = coordinateZ;
        Mass = mass;
    }

    public abstract string GetKind();

    public void DisplayInfo()
    {
        Console.WriteLine($"{GetKind()} {Name}: ({CoordinateX:F1}, {CoordinateY:F1}, {CoordinateZ:F1}), маса {Mass:F2}");
    }

    protected void MoveTo(double x, double y, double z)
    {
        CoordinateX = x;
        CoordinateY = y;
        CoordinateZ = z;
    }
}

Python

class SpaceObject(ABC):
    def __init__(self, name, coordinate_x, coordinate_y, coordinate_z, mass):
        self._name = name
        self._coordinate_x = coordinate_x
        self._coordinate_y = coordinate_y
        self._coordinate_z = coordinate_z
        self._mass = mass

    @property
    def name(self):
        return self._name

    @property
    def coordinate_x(self):
        return self._coordinate_x

    @property
    def coordinate_y(self):
        return self._coordinate_y

    @property
    def coordinate_z(self):
        return self._coordinate_z

    @property
    def mass(self):
        return self._mass

    @abstractmethod
    def get_kind(self):
        pass

    def display_info(self):
        print(f"{self.get_kind()} {self._name}: ({self._coordinate_x:.1f}, {self._coordinate_y:.1f}, {self._coordinate_z:.1f}), маса {self._mass:.2f}")

    def _move_to(self, x, y, z):
        self._coordinate_x = x
        self._coordinate_y = y
        self._coordinate_z = z

JavaScript

class SpaceObject {
  #name;
  #coordinateX;
  #coordinateY;
  #coordinateZ;
  #mass;

  constructor(name, coordinateX, coordinateY, coordinateZ, mass) {
    this.#name = name;
    this.#coordinateX = coordinateX;
    this.#coordinateY = coordinateY;
    this.#coordinateZ = coordinateZ;
    this.#mass = mass;
  }

  get name() {
    return this.#name;
  }

  get coordinateX() {
    return this.#coordinateX;
  }

  get coordinateY() {
    return this.#coordinateY;
  }

  get coordinateZ() {
    return this.#coordinateZ;
  }

  get mass() {
    return this.#mass;
  }

  getKind() {
    throw new Error(`${this.constructor.name} трябва да напише getKind()`);
  }

  displayInfo() {
    console.log(`${this.getKind()} ${this.#name}: (${this.#coordinateX.toFixed(1)}, ${this.#coordinateY.toFixed(1)}, ${this.#coordinateZ.toFixed(1)}), маса ${this.#mass.toFixed(2)}`);
  }

  _moveTo(x, y, z) {
    this.#coordinateX = x;
    this.#coordinateY = y;
    this.#coordinateZ = z;
  }
}

• Координатите са в милиони километри от Слънцето, а масата е в земни маси: Земята е 1, Слънцето е 333 000.
• displayInfo() е общ за всички. Видът (getKind()) е абстрактен: всеки наследник казва сам какъв е.
• #name и другите полета с # са наистина скрити: отвън не се стига до тях, а се четат през get name(). Само че # не се вижда и в наследниците, а protected в JavaScript няма. Затова _moveTo е с долна черта: уговорка за „само за наследниците“, която JavaScript не пази.

JavaScript няма абстрактни класове и методи. Най-близкото е getKind() в родителя да хвърля грешка: наследникът, който не го напише, ще разбере при първото извикване. Обект от такъв клас се създава без проблем:

class Comet extends SpaceObject {}

const comet = new Comet("Халей", 0, 0, 0, 0);
try {
  comet.displayInfo();
} catch (e) {
  console.log(e.message);
}

Изход

Comet трябва да напише getKind()

Звездата е най-простият наследник:

Java

class Star extends OrbitableSpaceObject {
    public Star(String name, double coordinateX, double coordinateY, double coordinateZ, double mass) {
        super(name, coordinateX, coordinateY, coordinateZ, mass);
    }

    @Override
    public String getKind() {
        return "Звезда";
    }
}

C#

class Star : OrbitableSpaceObject
{
    public Star(string name, double coordinateX, double coordinateY, double coordinateZ, double mass)
        : base(name, coordinateX, coordinateY, coordinateZ, mass)
    {
    }

    public override string GetKind()
    {
        return "Звезда";
    }
}

Python

class Star(OrbitableSpaceObject):
    def get_kind(self):
        return "Звезда"

JavaScript

class Star extends OrbitableSpaceObject {
  getKind() {
    return "Звезда";
  }
}

Конструкторът се наследява: new Star(...) вика този на родителя със същите аргументи. Затова Star пише само вида си.

Трите вида обекти в един масив от SpaceObject. Цикълът не знае кой какъв е, а всеки казва вида си:

Java

SpaceObject[] objects = {
    new Star("Слънце", 0, 0, 0, 333000),
    new Planet("Земя", 149.6, 0, 0, 1),
    new Satellite("Луна", 150, 0, 0, 0.012),
};
for (SpaceObject object : objects) {
    object.displayInfo();
}

Изход

Звезда Слънце: (0.0, 0.0, 0.0), маса 333000.00
Планета Земя: (149.6, 0.0, 0.0), маса 1.00
Спътник Луна: (150.0, 0.0, 0.0), маса 0.01

C#

SpaceObject[] objects =
{
    new Star("Слънце", 0, 0, 0, 333000),
    new Planet("Земя", 149.6, 0, 0, 1),
    new Satellite("Луна", 150, 0, 0, 0.012),
};
foreach (SpaceObject spaceObject in objects)
{
    spaceObject.DisplayInfo();
}

Изход

Звезда Слънце: (0.0, 0.0, 0.0), маса 333000.00
Планета Земя: (149.6, 0.0, 0.0), маса 1.00
Спътник Луна: (150.0, 0.0, 0.0), маса 0.01

Python

objects = [
    Star("Слънце", 0, 0, 0, 333000),
    Planet("Земя", 149.6, 0, 0, 1),
    Satellite("Луна", 150, 0, 0, 0.012),
]
for space_object in objects:
    space_object.display_info()

Изход

Звезда Слънце: (0.0, 0.0, 0.0), маса 333000.00
Планета Земя: (149.6, 0.0, 0.0), маса 1.00
Спътник Луна: (150.0, 0.0, 0.0), маса 0.01

JavaScript

const objects = [
  new Star("Слънце", 0, 0, 0, 333000),
  new Planet("Земя", 149.6, 0, 0, 1),
  new Satellite("Луна", 150, 0, 0, 0.012),
];
for (const spaceObject of objects) {
  spaceObject.displayInfo();
}

Изход

Звезда Слънце: (0.0, 0.0, 0.0), маса 333000.00
Планета Земя: (149.6, 0.0, 0.0), маса 1.00
Спътник Луна: (150.0, 0.0, 0.0), маса 0.01

Идеята

Около кого се обикаля

Около звездата обикалят планети, около планетата обикалят спътници. И звездата, и планетата трябва да помнят кой обикаля около тях. Това е OrbitableSpaceObject: абстрактен клас между SpaceObject и тях.

Java

abstract class OrbitableSpaceObject extends SpaceObject {
    private SpaceObject[] orbiters = new SpaceObject[10];
    private int orbiterCount = 0;

    public OrbitableSpaceObject(String name, double coordinateX, double coordinateY, double coordinateZ, double mass) {
        super(name, coordinateX, coordinateY, coordinateZ, mass);
    }

    public void addOrbiter(SpaceObject orbiter) {
        if (orbiterCount == orbiters.length) {
            throw new IllegalStateException("Около " + getName() + " вече обикалят " + orbiters.length + " обекта");
        }
        orbiters[orbiterCount] = orbiter;
        orbiterCount++;
    }

    public SpaceObject[] getOrbiters() {
        SpaceObject[] result = new SpaceObject[orbiterCount];
        for (int i = 0; i < orbiterCount; i++) {
            result[i] = orbiters[i];
        }
        return result;
    }
}

C#

abstract class OrbitableSpaceObject : SpaceObject
{
    private SpaceObject[] orbiters = new SpaceObject[10];
    private int orbiterCount = 0;

    public OrbitableSpaceObject(string name, double coordinateX, double coordinateY, double coordinateZ, double mass)
        : base(name, coordinateX, coordinateY, coordinateZ, mass)
    {
    }

    public void AddOrbiter(SpaceObject orbiter)
    {
        if (orbiterCount == orbiters.Length)
        {
            throw new InvalidOperationException("Около " + Name + " вече обикалят " + orbiters.Length + " обекта");
        }
        orbiters[orbiterCount] = orbiter;
        orbiterCount++;
    }

    public SpaceObject[] GetOrbiters()
    {
        SpaceObject[] result = new SpaceObject[orbiterCount];
        for (int i = 0; i < orbiterCount; i++)
        {
            result[i] = orbiters[i];
        }
        return result;
    }
}

Python

class OrbitableSpaceObject(SpaceObject):
    CAPACITY = 10

    def __init__(self, name, coordinate_x, coordinate_y, coordinate_z, mass):
        super().__init__(name, coordinate_x, coordinate_y, coordinate_z, mass)
        self._orbiters = []

    def add_orbiter(self, orbiter):
        if len(self._orbiters) == self.CAPACITY:
            raise RuntimeError(f"Около {self.name} вече обикалят {self.CAPACITY} обекта")
        self._orbiters.append(orbiter)

    def get_orbiters(self):
        return list(self._orbiters)

JavaScript

class OrbitableSpaceObject extends SpaceObject {
  static CAPACITY = 10;
  #orbiters = [];

  addOrbiter(orbiter) {
    if (this.#orbiters.length === OrbitableSpaceObject.CAPACITY) {
      throw new Error(`Около ${this.name} вече обикалят ${OrbitableSpaceObject.CAPACITY} обекта`);
    }
    this.#orbiters.push(orbiter);
  }

  getOrbiters() {
    return [...this.#orbiters];
  }
}

• Обикалящите са в масив, който расте сам. Брояч не трябва: this.#orbiters.length казва колко са.
• Около една звезда има място за 10 обекта: CAPACITY е на класа, общ за всички обекти от него. Ако мястото се запълни, addOrbiter хвърля обикновен Error: отделно изключение за неподходящ момент в JavaScript няма.
• getOrbiters() връща копие на масива.

По-точно, за любопитните

• getOrbiters() връща копие, а не самия масив. Иначе код отвън може да добави с push и да заобиколи проверката за място.
• Star наследява OrbitableSpaceObject, а не направо SpaceObject. Така звездата получава и обикалящите, и всичко от SpaceObject.

Копието се вижда в изхода: добавеното в него не стига до звездата.

const sun = new Star("Слънце", 0, 0, 0, 333000);
new Planet("Земя", 149.6, 0, 0, 1).orbit(sun);
const copy = sun.getOrbiters();
copy.push(new Planet("Марс", 227.9, 0, 0, 0.11));
console.log(copy.length, sun.getOrbiters().length);

Изход

Земя обикаля около Слънце
2 1

Идеята

Правилото за орбитите

Планета обикаля около звезда. Спътник обикаля около планета. Всичко друго е невалидно. Обектите, които могат да обикалят, имат общ договор:

Java

interface Orbiter {
    void orbit(SpaceObject target) throws NotValidSpaceObjectException;
}

C#

interface Orbiter
{
    void Orbit(SpaceObject target);
}

Python

class Orbiter(ABC):
    @abstractmethod
    def orbit(self, target):
        pass

JavaScript

// Договорът Orbiter: обектът има метод orbit(target), който го пуска да обикаля
// около target или хвърля NotValidSpaceObjectError.
// JavaScript няма interface: Planet и Satellite просто имат такъв метод.

JavaScript няма интерфейси. Договорът е уговорка: всеки обект, който може да обикаля, има метод orbit(target). Кодът, който го ползва, просто го вика, без да пита какъв е обектът. Това се казва duck typing: „ако ходи като патица и кряка като патица, е патица“.

Ако правилото е нарушено, orbit хвърля свое изключение. Името казва точно какво е станало:

Java

class NotValidSpaceObjectException extends Exception {
    public NotValidSpaceObjectException(String message) {
        super(message);
    }
}

C#

class NotValidSpaceObjectException : Exception
{
    public NotValidSpaceObjectException(string message) : base(message)
    {
    }
}

Python

class NotValidSpaceObjectError(Exception):
    pass

JavaScript

class NotValidSpaceObjectError extends Error {
  constructor(message) {
    super(message);
    this.name = "NotValidSpaceObjectError";
  }
}

Ето как го пази планетата:

Java

@Override
public void orbit(SpaceObject target) throws NotValidSpaceObjectException {
    if (target instanceof Star star) {
        star.addOrbiter(this);
        System.out.println(getName() + " обикаля около " + star.getName());
    } else {
        throw new NotValidSpaceObjectException(getName() + " не може да обикаля около " + target.getName() + ": планета обикаля само звезда");
    }
}

C#

public void Orbit(SpaceObject target)
{
    if (target is Star star)
    {
        star.AddOrbiter(this);
        Console.WriteLine(Name + " обикаля около " + star.Name);
    }
    else
    {
        throw new NotValidSpaceObjectException(Name + " не може да обикаля около " + target.Name + ": планета обикаля само звезда");
    }
}

Python

def orbit(self, target):
    if isinstance(target, Star):
        target.add_orbiter(self)
        print(f"{self.name} обикаля около {target.name}")
    else:
        raise NotValidSpaceObjectError(f"{self.name} не може да обикаля около {target.name}: планета обикаля само звезда")

JavaScript

orbit(target) {
  if (target instanceof Star) {
    target.addOrbiter(this);
    console.log(`${this.name} обикаля около ${target.name}`);
  } else {
    throw new NotValidSpaceObjectError(`${this.name} не може да обикаля около ${target.name}: планета обикаля само звезда`);
  }
}

• target instanceof Star проверява типа. След проверката target се ползва като звезда: нова променлива не трябва.
• Ако проверката не мине, изключението спира метода. Планетата не се добавя никъде.
• Satellite има същия orbit, само че проверява за Planet.

По-точно, за любопитните

В JavaScript никой не следи кой какво хвърля. Нито договорът, нито orbit казват, че може да хвърли, и никой не кара викащия да го хване. Програмата ще спре, ако никой не го хване, затова в играта винаги го хващаме. Името на изключението завършва на Error, както при вградените (TypeError).

Виж го

Кой около кого

const sun = new Star("Слънце", 0, 0, 0, 333000);
const earth = new Planet("Земя", 149.6, 0, 0, 1);
const moon = new Satellite("Луна", 150, 0, 0, 0.012);
tryOrbit(earth, sun);
tryOrbit(moon, earth);
tryOrbit(moon, sun);

Стъпка по стъпка, с думи

1. Три обекта: звезда, планета и спътник, всеки със свои координати и маса.
2. Планета около звезда: правилото го позволява, Земята тръгва по орбитата.
3. Спътник около планета: позволено. Луната обикаля Земята и се движи с нея.
4. Спътник около звезда: orbit хвърля NotValidSpaceObjectError, а catch в tryOrbit печата защо.

Земята минава проверката на звездата и се добавя към обикалящите я. Луната минава проверката на Земята. Когато Луната опита да обикаля около Слънцето, проверката за Planet не минава. orbit хвърля и Луната остава около Земята.

Изключението се хваща в малка помощна функция. Тя пробва орбитата и при отказ казва защо:

Java

static void tryOrbit(Orbiter orbiter, SpaceObject target) {
    try {
        orbiter.orbit(target);
    } catch (NotValidSpaceObjectException e) {
        System.out.println("Отказано: " + e.getMessage());
    }
}

C#

static void TryOrbit(Orbiter orbiter, SpaceObject target)
{
    try
    {
        orbiter.Orbit(target);
    }
    catch (NotValidSpaceObjectException e)
    {
        Console.WriteLine("Отказано: " + e.Message);
    }
}

Python

def try_orbit(orbiter, target):
    try:
        orbiter.orbit(target)
    except NotValidSpaceObjectError as e:
        print(f"Отказано: {e}")

JavaScript

function tryOrbit(orbiter, target) {
  try {
    orbiter.orbit(target);
  } catch (e) {
    if (!(e instanceof NotValidSpaceObjectError)) {
      throw e;
    }
    console.log(`Отказано: ${e.message}`);
  }
}

catch в JavaScript няма вид в скобите: хваща всяка грешка, и тази от опечатка в кода. Затова tryOrbit проверява с instanceof. Отказът на орбитата го печата, а всяка друга грешка хвърля нататък с throw e.

Пробвай

Колко обикалят?

Марс опитва да обикаля около Земята.

Какво ще отпечата програмата?

function tryOrbit(orbiter, target) {
  try {
    orbiter.orbit(target);
  } catch (e) {
    if (!(e instanceof NotValidSpaceObjectError)) {
      throw e;
    }
    console.log(`Отказано: ${e.message}`);
  }
}

const sun = new Star("Слънце", 0, 0, 0, 333000);
const earth = new Planet("Земя", 149.6, 0, 0, 1);
const mars = new Planet("Марс", 227.9, 0, 0, 0.11);
const moon = new Satellite("Луна", 150, 0, 0, 0.012);
tryOrbit(earth, sun);
tryOrbit(mars, earth);
tryOrbit(moon, earth);
console.log(`Около Слънце: ${sun.getOrbiters().length}`);
console.log(`Около Земя: ${earth.getOrbiters().length}`);

Отговор

Земя обикаля около Слънце
Отказано: Марс не може да обикаля около Земя: планета обикаля само звезда
Луна обикаля около Земя
Около Слънце: 1
Около Земя: 1

Земя обикаля около Слънце
Отказано: Марс не може да обикаля около Земя: планета обикаля само звезда
Около Слънце: 1
Около Земя: 0

Земя обикаля около Слънце
Отказано: Марс не може да обикаля около Земя: планета обикаля само звезда
Луна обикаля около Земя
Около Слънце: 2
Около Земя: 1

Земя обикаля около Слънце
Марс обикаля около Земя
Луна обикаля около Земя
Около Слънце: 1
Около Земя: 2

Провери

Идеята

Кораб, който лети

Корабите не обикалят, а летят от обект до обект. Това е друг договор:

Java

interface Fly {
    void flyTo(SpaceObject destination) throws NotValidSpaceObjectException;
}

C#

interface Fly
{
    void FlyTo(SpaceObject destination);
}

Python

class Fly(ABC):
    @abstractmethod
    def fly_to(self, destination):
        pass

JavaScript

// Договорът Fly: обектът има метод flyTo(destination), който го мести при destination
// или хвърля NotValidSpaceObjectError.

SpaceShip наследява SpaceObject и има метод flyTo. До звезда не може да лети. До всичко друго лети и взима координатите на целта:

Java

@Override
public void flyTo(SpaceObject destination) throws NotValidSpaceObjectException {
    if (destination instanceof Star) {
        throw new NotValidSpaceObjectException(getName() + " не може да лети до " + destination.getName() + ": звездата ще го изгори");
    }
    moveTo(destination.getCoordinateX(), destination.getCoordinateY(), destination.getCoordinateZ());
    System.out.println(getName() + " пристигна при " + destination.getName());
}

C#

public void FlyTo(SpaceObject destination)
{
    if (destination is Star)
    {
        throw new NotValidSpaceObjectException(Name + " не може да лети до " + destination.Name + ": звездата ще го изгори");
    }
    MoveTo(destination.CoordinateX, destination.CoordinateY, destination.CoordinateZ);
    Console.WriteLine(Name + " пристигна при " + destination.Name);
}

Python

def fly_to(self, destination):
    if isinstance(destination, Star):
        raise NotValidSpaceObjectError(f"{self.name} не може да лети до {destination.name}: звездата ще го изгори")
    self._move_to(destination.coordinate_x, destination.coordinate_y, destination.coordinate_z)
    print(f"{self.name} пристигна при {destination.name}")

JavaScript

flyTo(destination) {
  if (destination instanceof Star) {
    throw new NotValidSpaceObjectError(`${this.name} не може да лети до ${destination.name}: звездата ще го изгори`);
  }
  this._moveTo(destination.coordinateX, destination.coordinateY, destination.coordinateZ);
  console.log(`${this.name} пристигна при ${destination.name}`);
}

Java

SpaceShip ship = new SpaceShip("Скиталец", 149.6, 0, 0, 0);
Planet mars = new Planet("Марс", 227.9, 0, 0, 0.11);
Star sun = new Star("Слънце", 0, 0, 0, 333000);
try {
    ship.flyTo(mars);
    ship.displayInfo();
    ship.flyTo(sun);
    ship.displayInfo();
} catch (NotValidSpaceObjectException e) {
    System.out.println("Отказано: " + e.getMessage());
}

Изход

Скиталец пристигна при Марс
Кораб Скиталец: (227.9, 0.0, 0.0), маса 0.00
Отказано: Скиталец не може да лети до Слънце: звездата ще го изгори

C#

SpaceShip ship = new SpaceShip("Скиталец", 149.6, 0, 0, 0);
Planet mars = new Planet("Марс", 227.9, 0, 0, 0.11);
Star sun = new Star("Слънце", 0, 0, 0, 333000);
try
{
    ship.FlyTo(mars);
    ship.DisplayInfo();
    ship.FlyTo(sun);
    ship.DisplayInfo();
}
catch (NotValidSpaceObjectException e)
{
    Console.WriteLine("Отказано: " + e.Message);
}

Изход

Скиталец пристигна при Марс
Кораб Скиталец: (227.9, 0.0, 0.0), маса 0.00
Отказано: Скиталец не може да лети до Слънце: звездата ще го изгори

Python

ship = SpaceShip("Скиталец", 149.6, 0, 0, 0)
mars = Planet("Марс", 227.9, 0, 0, 0.11)
sun = Star("Слънце", 0, 0, 0, 333000)
try:
    ship.fly_to(mars)
    ship.display_info()
    ship.fly_to(sun)
    ship.display_info()
except NotValidSpaceObjectError as e:
    print(f"Отказано: {e}")

Изход

Скиталец пристигна при Марс
Кораб Скиталец: (227.9, 0.0, 0.0), маса 0.00
Отказано: Скиталец не може да лети до Слънце: звездата ще го изгори

JavaScript

const ship = new SpaceShip("Скиталец", 149.6, 0, 0, 0);
const mars = new Planet("Марс", 227.9, 0, 0, 0.11);
const sun = new Star("Слънце", 0, 0, 0, 333000);
try {
  ship.flyTo(mars);
  ship.displayInfo();
  ship.flyTo(sun);
  ship.displayInfo();
} catch (e) {
  if (!(e instanceof NotValidSpaceObjectError)) {
    throw e;
  }
  console.log(`Отказано: ${e.message}`);
}

Изход

Скиталец пристигна при Марс
Кораб Скиталец: (227.9, 0.0, 0.0), маса 0.00
Отказано: Скиталец не може да лети до Слънце: звездата ще го изгори

Вторият displayInfo() не се изпълнява: изключението прескача до catch.

По-точно, за любопитните

extends приема само един родител. Спътник за разузнаване, който може и да лети, е class Probe extends SpaceObject с двата метода, orbit и flyTo: за duck typing това стига.

Пробвай

Намери грешката

Луната обикаля около Слънцето, а не трябва. На кой ред в orbit на спътника е грешката?

Избери реда с грешката.

1orbit(target) {2 if (target instanceof OrbitableSpaceObject) {3 target.addOrbiter(this);4 console.log(`${this.name} обикаля около ${target.name}`);5 } else {6 throw new NotValidSpaceObjectError(`${this.name} не може да обикаля около ${target.name}: спътник обикаля само планета`);7 }8}

Провери

Упражнение

Космосът в код

Реши задачите в редактора си, с класовете от урока.

1. Слънчевата система. Опиши осемте планети с три масива: имена, разстояния от Слънцето (милиони км) и маси (земни маси). В цикъл създай всяка планета на x = разстоянието и я накарай да обикаля около Слънцето. После покажи всички обикалящи.

Планета	Разстояние	Маса
Меркурий	57,9	0,06
Венера	108,2	0,82
Земя	149,6	1
Марс	227,9	0,11
Юпитер	778,5	317,8
Сатурн	1432	95,2
Уран	2867	14,5
Нептун	4515	17,1

Изход

Меркурий обикаля около Слънце
Венера обикаля около Слънце
Земя обикаля около Слънце
Марс обикаля около Слънце
Юпитер обикаля около Слънце
Сатурн обикаля около Слънце
Уран обикаля около Слънце
Нептун обикаля около Слънце
Около Слънце обикалят 8 планети:
Планета Меркурий: (57.9, 0.0, 0.0), маса 0.06
Планета Венера: (108.2, 0.0, 0.0), маса 0.82
Планета Земя: (149.6, 0.0, 0.0), маса 1.00
Планета Марс: (227.9, 0.0, 0.0), маса 0.11
Планета Юпитер: (778.5, 0.0, 0.0), маса 317.80
Планета Сатурн: (1432.0, 0.0, 0.0), маса 95.20
Планета Уран: (2867.0, 0.0, 0.0), маса 14.50
Планета Нептун: (4515.0, 0.0, 0.0), маса 17.10

2. Разстояние. Напиши function distance(a, b) с теоремата на Питагор в три измерения: корен от сбора на квадратите на разликите по x, y и z. Земята е в (149,6; 0; 0), Марс е в (0; 227,9; 0), Луната е в (149,6; 0,4; 0), а Слънцето е в началото.

Изход

Земя – Марс: 272.6 млн. км
Земя – Луна: 0.4 млн. км
Слънце – Марс: 227.9 млн. км

3. Цялото дърво. Промени displayInfo така, че звездата да показва и планетите си, а всяка планета и спътниците си, с два интервала отстъп на ниво. Подсказка: параметър за отстъпа със стойност по подразбиране, indent = "", за да става и извикването без аргумент. OrbitableSpaceObject презаписва метода и вика родителя. Земята и Марс обикалят Слънцето, Луната обикаля Земята, Фобос обикаля Марс.

Изход

Земя обикаля около Слънце
Марс обикаля около Слънце
Луна обикаля около Земя
Фобос обикаля около Марс
Звезда Слънце: (0.0, 0.0, 0.0), маса 333000.00
  Планета Земя: (149.6, 0.0, 0.0), маса 1.00
    Спътник Луна: (150.0, 0.0, 0.0), маса 0.01
  Планета Марс: (227.9, 0.0, 0.0), маса 0.11
    Спътник Фобос: (227.9, 0.0, 0.0), маса 0.00

Още задачи

• Двоен опит. Сега Земята може да се добави два пъти към обикалящите Слънцето. Направи така, че втори опит да хвърля NotValidSpaceObjectError.
• Пълна звезда. Добави 11 планети към една звезда и хвани изключението при единадесетата.
• Сонда. Направи Probe, която и обикаля, и лети (виж „По-точно“ при корабите).

Тест

Провери се

1. Comet наследява SpaceObject, но не пише getKind. Кога ще разбереш?

Никога: getKind връща undefinedПри new Comet(...): JavaScript не позволява такъв обектЧак когато някой извика displayInfo: getKind на родителя хвърля Error

2. Защо getOrbiters() връща копие на списъка, а не самия списък?

Копието е по-бързоИначе код отвън може да добави обект с push и да заобиколи проверката за място за 10Списъкът не може да се връща от метод

3. Спътник опитва moon.orbit(sun). Какво става?

Програмата спира веднага, независимо от catchСпътникът започва да обикаля звездатаorbit хвърля NotValidSpaceObjectError и спътникът не се добавя никъде

4. В JavaScript няма interface. Какво позволява на tryOrbit да работи и с Planet, и със Satellite?

И двата имат метод orbit(target): tryOrbit само го вика, без да пита какъв е обектътДвата класа наследяват OrbitertryOrbit проверява с instanceof Planet

Провери

Започни урока отначало