Epic Cosmos 1: die Objekte im All

Kurz gesagt: Ein Spiel mit Objekten: Sterne, Planeten und Satelliten sind Klassen, die Regel „wer wen umkreist“ ist ein Interface, und eine ungültige Umlaufbahn wirft eine eigene Exception.

Problem

Das Wettrennen im All

Die Menschheit kann jetzt zu fernen Planeten fliegen. Konzerne und Staaten wetteifern um ihre Ressourcen. Du leitest eine der Missionen und willst die stärkste Macht im All werden.

Die Regeln von Epic Cosmos:

• Punkte bekommst du für das Entdecken neuer Planeten und Objekte, den Abbau von Ressourcen, den Bau von Gebäuden und Schiffen und wissenschaftliche Entdeckungen.
• Die Objekte sind Sterne, Planeten und Satelliten. Ein Stern liefert Energie. Manche Planeten haben seltene Ressourcen, und ihre Atmosphäre entscheidet, was man dort bauen kann. Ein Satellit dient der Kommunikation und der Aufklärung.
• Ressourcen brauchst du zum Bauen, für die Forschung und um deine Basen und Schiffe zu unterhalten.
• Gebäude bauen Ressourcen ab, erforschen Technologien, schützen die Basis und bauen Schiffe.
• Technologien schalten neue Gebäude, Schiffe und Fähigkeiten frei.
• Konflikte: Im All bist du nicht allein. Es gibt Piraten und andere Spieler.
• Das Ende: Das Spiel ist vorbei, wenn jemand eine bestimmte Punktzahl erreicht oder nach einer bestimmten Anzahl von Zügen. Es gewinnt, wer die meisten Punkte hat.

Vor den Gebäuden und Schiffen brauchst du die Welt selbst: welche Objekte es gibt, wo sie sind und was wen umkreisen kann. Das ist diese Lektion. Ressourcen, Gebäude und Schiffe kommen in der nächsten.

Die Idee

Alles im All ist ein SpaceObject

Ein Stern, ein Planet und ein Satellit haben etwas gemeinsam: einen Namen, Koordinaten x, y, z und eine Masse. Das Gemeinsame kommt in eine abstrakte Klasse:

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), Masse %.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}), Masse {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}), Masse {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} muss getKind() schreiben`);
  }

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

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

• Die Koordinaten sind in Millionen Kilometern von der Sonne, und die Masse ist in Erdmassen: Die Erde ist 1, die Sonne 333.000.
• displayInfo() ist allen gemeinsam. Die Art (getKind()) ist abstrakt: Jede Unterklasse sagt selbst, was sie ist.
• moveTo ist protected: Objekte werden nicht von außen bewegt, aber ein Schiff, das eine Unterklasse ist, wird sich bewegen können.

Der Stern ist die einfachste Unterklasse:

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 "Stern";
    }
}

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 "Stern";
    }
}

Python

class Star(OrbitableSpaceObject):
    def get_kind(self):
        return "Stern"

JavaScript

class Star extends OrbitableSpaceObject {
  getKind() {
    return "Stern";
  }
}

Die drei Arten von Objekten liegen in einem Array von SpaceObject. Die Schleife weiß nicht, was was ist, und jedes Objekt sagt seine eigene Art:

Java

SpaceObject[] objects = {
    new Star("Sonne", 0, 0, 0, 333000),
    new Planet("Erde", 149.6, 0, 0, 1),
    new Satellite("Mond", 150, 0, 0, 0.012),
};
for (SpaceObject object : objects) {
    object.displayInfo();
}

Ausgabe

Stern Sonne: (0.0, 0.0, 0.0), Masse 333000.00
Planet Erde: (149.6, 0.0, 0.0), Masse 1.00
Satellit Mond: (150.0, 0.0, 0.0), Masse 0.01

C#

SpaceObject[] objects =
{
    new Star("Sonne", 0, 0, 0, 333000),
    new Planet("Erde", 149.6, 0, 0, 1),
    new Satellite("Mond", 150, 0, 0, 0.012),
};
foreach (SpaceObject spaceObject in objects)
{
    spaceObject.DisplayInfo();
}

Ausgabe

Stern Sonne: (0.0, 0.0, 0.0), Masse 333000.00
Planet Erde: (149.6, 0.0, 0.0), Masse 1.00
Satellit Mond: (150.0, 0.0, 0.0), Masse 0.01

Python

objects = [
    Star("Sonne", 0, 0, 0, 333000),
    Planet("Erde", 149.6, 0, 0, 1),
    Satellite("Mond", 150, 0, 0, 0.012),
]
for space_object in objects:
    space_object.display_info()

Ausgabe

Stern Sonne: (0.0, 0.0, 0.0), Masse 333000.00
Planet Erde: (149.6, 0.0, 0.0), Masse 1.00
Satellit Mond: (150.0, 0.0, 0.0), Masse 0.01

JavaScript

const objects = [
  new Star("Sonne", 0, 0, 0, 333000),
  new Planet("Erde", 149.6, 0, 0, 1),
  new Satellite("Mond", 150, 0, 0, 0.012),
];
for (const spaceObject of objects) {
  spaceObject.displayInfo();
}

Ausgabe

Stern Sonne: (0.0, 0.0, 0.0), Masse 333000.00
Planet Erde: (149.6, 0.0, 0.0), Masse 1.00
Satellit Mond: (150.0, 0.0, 0.0), Masse 0.01

Die Idee

Objekte, die umkreist werden

Planeten umkreisen einen Stern, und Satelliten umkreisen einen Planeten. Sowohl der Stern als auch der Planet müssen sich merken, was sie umkreist. Das ist OrbitableSpaceObject: eine abstrakte Klasse zwischen SpaceObject und ihnen.

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("Um " + getName() + " kreisen schon " + orbiters.length + " Objekte");
        }
        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("Um " + Name + " kreisen schon " + orbiters.Length + " Objekte");
        }
        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"Um {self.name} kreisen schon {self.CAPACITY} Objekte")
        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(`Um ${this.name} kreisen schon ${OrbitableSpaceObject.CAPACITY} Objekte`);
    }
    this.#orbiters.push(orbiter);
  }

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

• Die Umkreisenden liegen in einem Array mit Platz für 10 und einem Zähler der belegten Plätze. Ein neues Objekt kommt auf den Platz mit der Nummer des Zählers, danach wächst der Zähler.
• Das Array kann nicht wachsen. Wenn es voll ist, wirft addOrbiter die fertige Exception für „unpassender Moment“.
• getOrbiters() gibt ein neues Array mit genau den belegten Plätzen zurück, ohne die leeren.

Eine Liste, die von allein wächst, ist bequemer. Sie kommt in „Collections“, dann werden Array und Zähler zu einer Zeile.

Genauer, für Neugierige

• getOrbiters() gibt eine Kopie zurück, nicht das Array selbst. Sonst könnte Code von außen in das Array schreiben, und der Zähler würde lügen.
• Star erbt von OrbitableSpaceObject, nicht direkt von SpaceObject. So bekommt der Stern sowohl die Umkreisenden als auch alles von SpaceObject.

Die Idee

Die Regel für die Umlaufbahnen

Ein Planet umkreist einen Stern. Ein Satellit umkreist einen Planeten. Alles andere ist ungültig. Die Objekte, die umkreisen können, haben einen gemeinsamen Vertrag:

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

// Der Vertrag Orbiter: Das Objekt hat eine Methode orbit(target), mit der es um
// target kreist oder NotValidSpaceObjectError wirft.
// JavaScript hat kein interface: Planet und Satellite haben einfach so eine Methode.

Wenn die Regel verletzt wird, wirft orbit eine eigene Exception. Der Name sagt genau, was passiert ist:

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";
  }
}

So setzt der Planet sie durch:

Java

@Override
public void orbit(SpaceObject target) throws NotValidSpaceObjectException {
    if (target instanceof Star star) {
        star.addOrbiter(this);
        System.out.println(getName() + " umkreist " + star.getName());
    } else {
        throw new NotValidSpaceObjectException(getName() + " kann " + target.getName() + " nicht umkreisen: ein Planet umkreist nur einen Stern");
    }
}

C#

public void Orbit(SpaceObject target)
{
    if (target is Star star)
    {
        star.AddOrbiter(this);
        Console.WriteLine(Name + " umkreist " + star.Name);
    }
    else
    {
        throw new NotValidSpaceObjectException(Name + " kann " + target.Name + " nicht umkreisen: ein Planet umkreist nur einen Stern");
    }
}

Python

def orbit(self, target):
    if isinstance(target, Star):
        target.add_orbiter(self)
        print(f"{self.name} umkreist {target.name}")
    else:
        raise NotValidSpaceObjectError(f"{self.name} kann {target.name} nicht umkreisen: ein Planet umkreist nur einen Stern")

JavaScript

orbit(target) {
  if (target instanceof Star) {
    target.addOrbiter(this);
    console.log(`${this.name} umkreist ${target.name}`);
  } else {
    throw new NotValidSpaceObjectError(`${this.name} kann ${target.name} nicht umkreisen: ein Planet umkreist nur einen Stern`);
  }
}

• target instanceof Star star prüft den Typ und gibt dir gleich eine Variable vom Typ Star.
• Wenn die Prüfung fehlschlägt, stoppt die Exception die Methode. Der Planet wird nirgends hinzugefügt.
• Satellite hat dasselbe orbit, nur dass es auf Planet prüft.

Genauer, für Neugierige

NotValidSpaceObjectException erbt von Exception, ist also geprüft. Darum steht throws schon im Interface: Eine Implementierung darf keine geprüfte Exception werfen, die der Vertrag nicht erlaubt. Wer orbit aufruft, muss sie abfangen oder deklarieren.

Sieh es dir an

Wer wen umkreist

Star sun = new Star("Sonne", 0, 0, 0, 333000);
Planet earth = new Planet("Erde", 149.6, 0, 0, 1);
Satellite moon = new Satellite("Mond", 150, 0, 0, 0.012);
tryOrbit(earth, sun);
tryOrbit(moon, earth);
tryOrbit(moon, sun);

Schritt für Schritt, in Worten

1. Drei Objekte: ein Stern, ein Planet und ein Satellit, jedes mit eigenen Koordinaten und eigener Masse.
2. Ein Planet um einen Stern: Die Regel erlaubt es, und die Erde startet auf ihre Umlaufbahn.
3. Ein Satellit um einen Planeten: erlaubt. Der Mond umkreist die Erde und bewegt sich mit ihr.
4. Ein Satellit um einen Stern: orbit wirft NotValidSpaceObjectException, und das catch in tryOrbit gibt aus, warum.

Die Erde besteht die Prüfung des Sterns und wird zu den Objekten hinzugefügt, die ihn umkreisen. Der Mond besteht die Prüfung der Erde. Wenn der Mond versucht, die Sonne zu umkreisen, schlägt die Prüfung auf Planet fehl. orbit wirft, und der Mond bleibt bei der Erde.

Die Exception wird in einer kleinen Hilfsmethode abgefangen. Sie probiert die Umlaufbahn aus und sagt bei einer Ablehnung, warum:

Java

static void tryOrbit(Orbiter orbiter, SpaceObject target) {
    try {
        orbiter.orbit(target);
    } catch (NotValidSpaceObjectException e) {
        System.out.println("Abgelehnt: " + e.getMessage());
    }
}

C#

static void TryOrbit(Orbiter orbiter, SpaceObject target)
{
    try
    {
        orbiter.Orbit(target);
    }
    catch (NotValidSpaceObjectException e)
    {
        Console.WriteLine("Abgelehnt: " + e.Message);
    }
}

Python

def try_orbit(orbiter, target):
    try:
        orbiter.orbit(target)
    except NotValidSpaceObjectError as e:
        print(f"Abgelehnt: {e}")

JavaScript

function tryOrbit(orbiter, target) {
  try {
    orbiter.orbit(target);
  } catch (e) {
    if (!(e instanceof NotValidSpaceObjectError)) {
      throw e;
    }
    console.log(`Abgelehnt: ${e.message}`);
  }
}

Probier es aus

Wie viele umkreisen?

Der Mars versucht, die Erde zu umkreisen.

Was gibt das Programm aus?

static void tryOrbit(Orbiter orbiter, SpaceObject target) {
    try {
        orbiter.orbit(target);
    } catch (NotValidSpaceObjectException e) {
        System.out.println("Abgelehnt: " + e.getMessage());
    }
}

Star sun = new Star("Sonne", 0, 0, 0, 333000);
Planet earth = new Planet("Erde", 149.6, 0, 0, 1);
Planet mars = new Planet("Mars", 227.9, 0, 0, 0.11);
Satellite moon = new Satellite("Mond", 150, 0, 0, 0.012);
tryOrbit(earth, sun);
tryOrbit(mars, earth);
tryOrbit(moon, earth);
System.out.println("Um die Sonne: " + sun.getOrbiters().length);
System.out.println("Um die Erde: " + earth.getOrbiters().length);

Antwort

Erde umkreist Sonne
Abgelehnt: Mars kann Erde nicht umkreisen: ein Planet umkreist nur einen Stern
Um die Sonne: 1
Um die Erde: 0

Erde umkreist Sonne
Abgelehnt: Mars kann Erde nicht umkreisen: ein Planet umkreist nur einen Stern
Mond umkreist Erde
Um die Sonne: 1
Um die Erde: 1

Erde umkreist Sonne
Abgelehnt: Mars kann Erde nicht umkreisen: ein Planet umkreist nur einen Stern
Mond umkreist Erde
Um die Sonne: 2
Um die Erde: 1

Erde umkreist Sonne
Mars umkreist Erde
Mond umkreist Erde
Um die Sonne: 1
Um die Erde: 2

Prüfen

Die Idee

Ein Schiff, das fliegt

Schiffe umkreisen nichts, sie fliegen von Objekt zu Objekt. Das ist ein anderer Vertrag:

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

// Der Vertrag Fly: Das Objekt hat eine Methode flyTo(destination), die es zu destination
// bringt oder NotValidSpaceObjectError wirft.

SpaceShip erbt von SpaceObject und implementiert Fly. Zu einem Stern kann es nicht fliegen. Zu allem anderen fliegt es und übernimmt die Koordinaten des Ziels:

Java

@Override
public void flyTo(SpaceObject destination) throws NotValidSpaceObjectException {
    if (destination instanceof Star) {
        throw new NotValidSpaceObjectException(getName() + " kann nicht zu " + destination.getName() + " fliegen: Der Stern würde das Schiff verbrennen");
    }
    moveTo(destination.getCoordinateX(), destination.getCoordinateY(), destination.getCoordinateZ());
    System.out.println(getName() + " ist bei " + destination.getName() + " angekommen");
}

C#

public void FlyTo(SpaceObject destination)
{
    if (destination is Star)
    {
        throw new NotValidSpaceObjectException(Name + " kann nicht zu " + destination.Name + " fliegen: Der Stern würde das Schiff verbrennen");
    }
    MoveTo(destination.CoordinateX, destination.CoordinateY, destination.CoordinateZ);
    Console.WriteLine(Name + " ist bei " + destination.Name + " angekommen");
}

Python

def fly_to(self, destination):
    if isinstance(destination, Star):
        raise NotValidSpaceObjectError(f"{self.name} kann nicht zu {destination.name} fliegen: Der Stern würde das Schiff verbrennen")
    self._move_to(destination.coordinate_x, destination.coordinate_y, destination.coordinate_z)
    print(f"{self.name} ist bei {destination.name} angekommen")

JavaScript

flyTo(destination) {
  if (destination instanceof Star) {
    throw new NotValidSpaceObjectError(`${this.name} kann nicht zu ${destination.name} fliegen: Der Stern würde das Schiff verbrennen`);
  }
  this._moveTo(destination.coordinateX, destination.coordinateY, destination.coordinateZ);
  console.log(`${this.name} ist bei ${destination.name} angekommen`);
}

Java

SpaceShip ship = new SpaceShip("Wanderer", 149.6, 0, 0, 0);
Planet mars = new Planet("Mars", 227.9, 0, 0, 0.11);
Star sun = new Star("Sonne", 0, 0, 0, 333000);
try {
    ship.flyTo(mars);
    ship.displayInfo();
    ship.flyTo(sun);
    ship.displayInfo();
} catch (NotValidSpaceObjectException e) {
    System.out.println("Abgelehnt: " + e.getMessage());
}

Ausgabe

Wanderer ist bei Mars angekommen
Schiff Wanderer: (227.9, 0.0, 0.0), Masse 0.00
Abgelehnt: Wanderer kann nicht zu Sonne fliegen: Der Stern würde das Schiff verbrennen

C#

SpaceShip ship = new SpaceShip("Wanderer", 149.6, 0, 0, 0);
Planet mars = new Planet("Mars", 227.9, 0, 0, 0.11);
Star sun = new Star("Sonne", 0, 0, 0, 333000);
try
{
    ship.FlyTo(mars);
    ship.DisplayInfo();
    ship.FlyTo(sun);
    ship.DisplayInfo();
}
catch (NotValidSpaceObjectException e)
{
    Console.WriteLine("Abgelehnt: " + e.Message);
}

Ausgabe

Wanderer ist bei Mars angekommen
Schiff Wanderer: (227.9, 0.0, 0.0), Masse 0.00
Abgelehnt: Wanderer kann nicht zu Sonne fliegen: Der Stern würde das Schiff verbrennen

Python

ship = SpaceShip("Wanderer", 149.6, 0, 0, 0)
mars = Planet("Mars", 227.9, 0, 0, 0.11)
sun = Star("Sonne", 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"Abgelehnt: {e}")

Ausgabe

Wanderer ist bei Mars angekommen
Schiff Wanderer: (227.9, 0.0, 0.0), Masse 0.00
Abgelehnt: Wanderer kann nicht zu Sonne fliegen: Der Stern würde das Schiff verbrennen

JavaScript

const ship = new SpaceShip("Wanderer", 149.6, 0, 0, 0);
const mars = new Planet("Mars", 227.9, 0, 0, 0.11);
const sun = new Star("Sonne", 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(`Abgelehnt: ${e.message}`);
}

Ausgabe

Wanderer ist bei Mars angekommen
Schiff Wanderer: (227.9, 0.0, 0.0), Masse 0.00
Abgelehnt: Wanderer kann nicht zu Sonne fliegen: Der Stern würde das Schiff verbrennen

Das zweite displayInfo() läuft nicht: Die Exception springt zu catch.

Genauer, für Neugierige

Eine Klasse kann mehrere Interfaces implementieren. Ein Aufklärungssatellit, der auch fliegen kann, wäre class Probe extends SpaceObject implements Orbiter, Fly.

Probier es aus

Finde den Fehler

Der Mond umkreist die Sonne, und das soll er nicht. In welcher Zeile im orbit des Satelliten steckt der Fehler?

Wähle die Zeile mit dem Fehler.

1@Override2public void orbit(SpaceObject target) throws NotValidSpaceObjectException {3 if (target instanceof OrbitableSpaceObject planet) {4 planet.addOrbiter(this);5 System.out.println(getName() + " umkreist " + planet.getName());6 } else {7 throw new NotValidSpaceObjectException(getName() + " kann " + target.getName() + " nicht umkreisen: ein Satellit umkreist nur einen Planeten");8 }9}

Prüfen

Übung

Das All im Code

Löse die Aufgaben in deinem Editor, mit den Klassen aus der Lektion.

1. Das Sonnensystem. Beschreibe die acht Planeten mit drei Arrays: Namen, Abstände von der Sonne (Millionen km) und Massen (Erdmassen). Erzeuge in einer Schleife jeden Planeten bei x = Abstand und lass ihn die Sonne umkreisen. Zeige danach alle Umkreisenden.

Planet	Abstand	Masse
Merkur	57,9	0,06
Venus	108,2	0,82
Erde	149,6	1
Mars	227,9	0,11
Jupiter	778,5	317,8
Saturn	1.432	95,2
Uranus	2.867	14,5
Neptun	4.515	17,1

Ausgabe

Merkur umkreist Sonne
Venus umkreist Sonne
Erde umkreist Sonne
Mars umkreist Sonne
Jupiter umkreist Sonne
Saturn umkreist Sonne
Uranus umkreist Sonne
Neptun umkreist Sonne
Um Sonne kreisen 8 Planeten:
Planet Merkur: (57.9, 0.0, 0.0), Masse 0.06
Planet Venus: (108.2, 0.0, 0.0), Masse 0.82
Planet Erde: (149.6, 0.0, 0.0), Masse 1.00
Planet Mars: (227.9, 0.0, 0.0), Masse 0.11
Planet Jupiter: (778.5, 0.0, 0.0), Masse 317.80
Planet Saturn: (1432.0, 0.0, 0.0), Masse 95.20
Planet Uranus: (2867.0, 0.0, 0.0), Masse 14.50
Planet Neptun: (4515.0, 0.0, 0.0), Masse 17.10

2. Abstand. Schreibe static double distance(SpaceObject a, SpaceObject b) mit dem Satz des Pythagoras in drei Dimensionen: die Wurzel aus der Summe der Quadrate der Unterschiede in x, y und z. Die Erde liegt bei (149,6; 0; 0), der Mars bei (0; 227,9; 0), der Mond bei (149,6; 0,4; 0), und die Sonne liegt im Ursprung.

Ausgabe

Erde bis Mars: 272.6 Mio. km
Erde bis Mond: 0.4 Mio. km
Sonne bis Mars: 227.9 Mio. km

3. Der ganze Baum. Ändere displayInfo so, dass der Stern auch seine Planeten zeigt und jeder Planet seine Satelliten, mit zwei Leerzeichen Einrückung pro Ebene. Tipp: eine Methode mit einem Parameter für die Einrückung, die OrbitableSpaceObject überschreibt. Erde und Mars umkreisen die Sonne, der Mond umkreist die Erde, und Phobos umkreist den Mars.

Ausgabe

Erde umkreist Sonne
Mars umkreist Sonne
Mond umkreist Erde
Phobos umkreist Mars
Stern Sonne: (0.0, 0.0, 0.0), Masse 333000.00
  Planet Erde: (149.6, 0.0, 0.0), Masse 1.00
    Satellit Mond: (150.0, 0.0, 0.0), Masse 0.01
  Planet Mars: (227.9, 0.0, 0.0), Masse 0.11
    Satellit Phobos: (227.9, 0.0, 0.0), Masse 0.00

Weitere Aufgaben

• Doppelter Versuch. Im Moment kann die Erde zweimal zu den Objekten hinzugefügt werden, die die Sonne umkreisen. Sorge dafür, dass ein zweiter Versuch NotValidSpaceObjectException wirft.
• Ein voller Stern. Füge einem Stern 11 Planeten hinzu und fange die Exception beim elften ab.
• Eine Sonde. Baue eine Probe, die sowohl umkreist als auch fliegt (siehe „Genauer“ bei den Schiffen).

Test

Teste dich

1. Warum ist getKind() eine abstrakte Methode, displayInfo() aber nicht?

displayInfo kann nicht abstrakt sein, weil es ausgibtAbstrakte Methoden sind schnellerDie Art ist in jeder Klasse anders, aber die Art, ein Objekt anzuzeigen, ist gemeinsam: Du schreibst sie einmal in der Basisklasse

2. Warum hält OrbitableSpaceObject neben dem Array auch einen Zähler?

Der Zähler hält die Masse der umkreisenden ObjekteOhne Zähler lässt sich das Array nicht kompilierenDas Array hat eine feste Größe (10), und weniger Plätze sind belegt. Der Zähler sagt, wie viele es sind und wo der nächste freie Platz ist

3. Ein Satellit versucht moon.orbit(sun). Was passiert?

orbit wirft NotValidSpaceObjectException, und der Satellit wird nirgends hinzugefügtDer Satellit beginnt, den Stern zu umkreisenDas Programm bricht sofort ab, egal was im catch steht

4. NotValidSpaceObjectException erbt von Exception. Warum steht im Interface Orbiter throws NotValidSpaceObjectException?

Damit orbit einen Wert zurückgeben kannDas ist nicht nötig, es ist nur fürs AugeDie Exception ist geprüft: Wenn orbit sie werfen kann, muss der Vertrag es sagen, und jeder Aufrufer muss sie abfangen oder deklarieren

Prüfen

Lektion von vorn beginnen

Verwandte Lektionen

• Baut auf: Typprüfungen · Exceptions · try, catch und finally · Werfen und eigene Exceptions
• Aufgaben zum Thema: Wir bauen ein Spiel