Epic Cosmos 1: los objetos en el espacio

En resumen: Un juego con objetos: estrellas, planetas y satélites son clases, la regla de «qué orbita alrededor de qué» es una interfaz, y una órbita no válida lanza tu propia excepción.

Problema

La carrera espacial

La humanidad ya puede volar a planetas lejanos. Empresas y países compiten por sus recursos. Tú diriges una de las misiones y quieres convertirte en la mayor potencia del espacio.

Las reglas de Epic Cosmos:

• Ganas puntos al descubrir nuevos planetas y objetos, extraer recursos, construir edificios y naves, y hacer descubrimientos científicos.
• Los objetos son estrellas, planetas y satélites. Una estrella da energía. Algunos planetas tienen recursos raros, y su atmósfera decide qué se puede construir allí. Un satélite sirve para las comunicaciones y la exploración.
• Necesitas recursos para construir, investigar y mantener en marcha tus bases y naves.
• Los edificios extraen recursos, investigan tecnologías, defienden la base y fabrican naves.
• Las tecnologías desbloquean nuevos edificios, naves y habilidades.
• Conflictos: en el espacio no estás solo. Hay piratas y otros jugadores.
• El final: el juego termina cuando alguien alcanza un número fijo de puntos o después de un número fijo de turnos. Gana el jugador con más puntos.

Antes de los edificios y las naves necesitas el mundo mismo: qué objetos hay, dónde están y qué puede orbitar alrededor de qué. De eso trata esta lección. Los recursos, los edificios y las naves están en la siguiente.

La idea

Todo en el espacio es un SpaceObject

Una estrella, un planeta y un satélite tienen algo en común: un nombre, las coordenadas x, y, z y una masa. Lo común va a una clase abstracta:

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), masa %.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}), masa {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}), masa {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} debe escribir getKind()`);
  }

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

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

• Las coordenadas están en millones de kilómetros desde el Sol, y la masa está en masas terrestres: la Tierra es 1, el Sol es 333 000.
• DisplayInfo() es común a todos. El tipo (GetKind()) es abstracto: cada subclase dice por sí misma qué es.
• MoveTo es protected: los objetos no se mueven desde fuera, pero una nave, que es una subclase, sí podrá moverse.

La estrella es la subclase más simple:

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

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

Python

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

JavaScript

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

Los tres tipos de objetos van en un array de SpaceObject. El bucle no sabe cuál es cuál, y cada uno dice su propio tipo:

Java

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

Salida

Estrella Sol: (0.0, 0.0, 0.0), masa 333000.00
Planeta Tierra: (149.6, 0.0, 0.0), masa 1.00
Satélite Luna: (150.0, 0.0, 0.0), masa 0.01

C#

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

Salida

Estrella Sol: (0.0, 0.0, 0.0), masa 333000.00
Planeta Tierra: (149.6, 0.0, 0.0), masa 1.00
Satélite Luna: (150.0, 0.0, 0.0), masa 0.01

Python

objects = [
    Star("Sol", 0, 0, 0, 333000),
    Planet("Tierra", 149.6, 0, 0, 1),
    Satellite("Luna", 150, 0, 0, 0.012),
]
for space_object in objects:
    space_object.display_info()

Salida

Estrella Sol: (0.0, 0.0, 0.0), masa 333000.00
Planeta Tierra: (149.6, 0.0, 0.0), masa 1.00
Satélite Luna: (150.0, 0.0, 0.0), masa 0.01

JavaScript

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

Salida

Estrella Sol: (0.0, 0.0, 0.0), masa 333000.00
Planeta Tierra: (149.6, 0.0, 0.0), masa 1.00
Satélite Luna: (150.0, 0.0, 0.0), masa 0.01

La idea

Objetos alrededor de los que se orbita

Los planetas orbitan alrededor de una estrella, y los satélites orbitan alrededor de un planeta. Tanto la estrella como el planeta tienen que recordar qué orbita a su alrededor. Eso es OrbitableSpaceObject: una clase abstracta entre SpaceObject y ellos.

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("Alrededor de " + getName() + " ya orbitan " + orbiters.length + " objetos");
        }
        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("Alrededor de " + Name + " ya orbitan " + orbiters.Length + " objetos");
        }
        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"Alrededor de {self.name} ya orbitan {self.CAPACITY} objetos")
        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(`Alrededor de ${this.name} ya orbitan ${OrbitableSpaceObject.CAPACITY} objetos`);
    }
    this.#orbiters.push(orbiter);
  }

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

• Los objetos que orbitan están en un array con lugar para 10 y un contador de los lugares ocupados. Uno nuevo va al lugar cuyo número es el contador, y después el contador crece.
• El array no puede crecer. Si se llena, AddOrbiter lanza la excepción integrada para «el momento equivocado».
• GetOrbiters() devuelve un array nuevo con exactamente los lugares ocupados, sin los vacíos.

Una lista que crece sola es más cómoda. Viene en «Web y escritorio», y entonces el array y el contador se vuelven una sola línea.

Más precisamente, para curiosos

• GetOrbiters() devuelve una copia, no el array mismo. Si no, el código de fuera podría escribir en el array, y el contador mentiría.
• Star extiende OrbitableSpaceObject, no SpaceObject directamente. Así la estrella recibe tanto los objetos que orbitan como todo lo de SpaceObject.

La idea

La regla de las órbitas

Un planeta orbita alrededor de una estrella. Un satélite orbita alrededor de un planeta. Todo lo demás no es válido. Los objetos que pueden orbitar comparten un contrato:

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

// El contrato Orbiter: el objeto tiene un método orbit(target) que lo hace orbitar
// alrededor de target o lanza NotValidSpaceObjectError.
// JavaScript no tiene interface: Planet y Satellite simplemente tienen ese método.

Si se rompe la regla, Orbit lanza una excepción propia. El nombre dice exactamente qué pasó:

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

Así hace cumplir la regla el planeta:

Java

@Override
public void orbit(SpaceObject target) throws NotValidSpaceObjectException {
    if (target instanceof Star star) {
        star.addOrbiter(this);
        System.out.println(getName() + " orbita alrededor de " + star.getName());
    } else {
        throw new NotValidSpaceObjectException(getName() + " no puede orbitar alrededor de " + target.getName() + ": un planeta orbita solo una estrella");
    }
}

C#

public void Orbit(SpaceObject target)
{
    if (target is Star star)
    {
        star.AddOrbiter(this);
        Console.WriteLine(Name + " orbita alrededor de " + star.Name);
    }
    else
    {
        throw new NotValidSpaceObjectException(Name + " no puede orbitar alrededor de " + target.Name + ": un planeta orbita solo una estrella");
    }
}

Python

def orbit(self, target):
    if isinstance(target, Star):
        target.add_orbiter(self)
        print(f"{self.name} orbita alrededor de {target.name}")
    else:
        raise NotValidSpaceObjectError(f"{self.name} no puede orbitar alrededor de {target.name}: un planeta orbita solo una estrella")

JavaScript

orbit(target) {
  if (target instanceof Star) {
    target.addOrbiter(this);
    console.log(`${this.name} orbita alrededor de ${target.name}`);
  } else {
    throw new NotValidSpaceObjectError(`${this.name} no puede orbitar alrededor de ${target.name}: un planeta orbita solo una estrella`);
  }
}

• target is Star star comprueba el tipo y enseguida te da una variable de tipo Star.
• Si la comprobación falla, la excepción detiene el método. El planeta no se añade a ningún lado.
• Satellite tiene el mismo Orbit, solo que comprueba Planet.

Más precisamente, para curiosos

C# no tiene excepciones comprobadas. La interfaz no dice que Orbit puede lanzar una excepción, y el compilador no obliga a quien llama a capturarla. El programa se detendrá si nadie la captura, así que en el juego siempre la capturamos.

Míralo

Qué orbita alrededor de qué

Star sun = new Star("Sol", 0, 0, 0, 333000);
Planet earth = new Planet("Tierra", 149.6, 0, 0, 1);
Satellite moon = new Satellite("Luna", 150, 0, 0, 0.012);
TryOrbit(earth, sun);
TryOrbit(moon, earth);
TryOrbit(moon, sun);

Paso a paso, en palabras

1. Tres objetos: una estrella, un planeta y un satélite, cada uno con sus coordenadas y su masa.
2. Un planeta alrededor de una estrella: la regla lo permite, y la Tierra se pone en órbita.
3. Un satélite alrededor de un planeta: permitido. La Luna orbita alrededor de la Tierra y se mueve con ella.
4. Un satélite alrededor de una estrella: Orbit lanza NotValidSpaceObjectException, y el catch de TryOrbit imprime el motivo.

La Tierra pasa la comprobación de la estrella y se añade a los objetos que orbitan a su alrededor. La Luna pasa la comprobación de la Tierra. Cuando la Luna intenta orbitar alrededor del Sol, la comprobación de Planet falla. Orbit lanza la excepción, y la Luna sigue alrededor de la Tierra.

La excepción se captura en un pequeño método auxiliar. Este prueba la órbita y, si la rechazan, dice por qué:

Java

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

C#

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

Python

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

JavaScript

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

Pruébalo

¿Cuántos orbitan?

Marte intenta orbitar alrededor de la Tierra.

¿Qué imprimirá el programa?

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

Star sun = new Star("Sol", 0, 0, 0, 333000);
Planet earth = new Planet("Tierra", 149.6, 0, 0, 1);
Planet mars = new Planet("Marte", 227.9, 0, 0, 0.11);
Satellite moon = new Satellite("Luna", 150, 0, 0, 0.012);
TryOrbit(earth, sun);
TryOrbit(mars, earth);
TryOrbit(moon, earth);
Console.WriteLine("Alrededor de Sol: " + sun.GetOrbiters().Length);
Console.WriteLine("Alrededor de Tierra: " + earth.GetOrbiters().Length);

Respuesta

Tierra orbita alrededor de Sol
Marte orbita alrededor de Tierra
Luna orbita alrededor de Tierra
Alrededor de Sol: 1
Alrededor de Tierra: 2

Tierra orbita alrededor de Sol
Rechazado: Marte no puede orbitar alrededor de Tierra: un planeta orbita solo una estrella
Luna orbita alrededor de Tierra
Alrededor de Sol: 1
Alrededor de Tierra: 1

Tierra orbita alrededor de Sol
Rechazado: Marte no puede orbitar alrededor de Tierra: un planeta orbita solo una estrella
Luna orbita alrededor de Tierra
Alrededor de Sol: 2
Alrededor de Tierra: 1

Tierra orbita alrededor de Sol
Rechazado: Marte no puede orbitar alrededor de Tierra: un planeta orbita solo una estrella
Alrededor de Sol: 1
Alrededor de Tierra: 0

Comprobar

La idea

Una nave que vuela

Las naves no orbitan. Vuelan de un objeto a otro. Eso es un contrato distinto:

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

// El contrato Fly: el objeto tiene un método flyTo(destination) que lo mueve hasta destination
// o lanza NotValidSpaceObjectError.

SpaceShip extiende SpaceObject y implementa Fly. No puede volar a una estrella. Vuela a cualquier otra cosa y toma las coordenadas del destino:

Java

@Override
public void flyTo(SpaceObject destination) throws NotValidSpaceObjectException {
    if (destination instanceof Star) {
        throw new NotValidSpaceObjectException(getName() + " no puede volar a " + destination.getName() + ": la estrella la quemaría");
    }
    moveTo(destination.getCoordinateX(), destination.getCoordinateY(), destination.getCoordinateZ());
    System.out.println(getName() + " llegó a " + destination.getName());
}

C#

public void FlyTo(SpaceObject destination)
{
    if (destination is Star)
    {
        throw new NotValidSpaceObjectException(Name + " no puede volar a " + destination.Name + ": la estrella la quemaría");
    }
    MoveTo(destination.CoordinateX, destination.CoordinateY, destination.CoordinateZ);
    Console.WriteLine(Name + " llegó a " + destination.Name);
}

Python

def fly_to(self, destination):
    if isinstance(destination, Star):
        raise NotValidSpaceObjectError(f"{self.name} no puede volar a {destination.name}: la estrella la quemaría")
    self._move_to(destination.coordinate_x, destination.coordinate_y, destination.coordinate_z)
    print(f"{self.name} llegó a {destination.name}")

JavaScript

flyTo(destination) {
  if (destination instanceof Star) {
    throw new NotValidSpaceObjectError(`${this.name} no puede volar a ${destination.name}: la estrella la quemaría`);
  }
  this._moveTo(destination.coordinateX, destination.coordinateY, destination.coordinateZ);
  console.log(`${this.name} llegó a ${destination.name}`);
}

Java

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

Salida

Errante llegó a Marte
Nave Errante: (227.9, 0.0, 0.0), masa 0.00
Rechazado: Errante no puede volar a Sol: la estrella la quemaría

C#

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

Salida

Errante llegó a Marte
Nave Errante: (227.9, 0.0, 0.0), masa 0.00
Rechazado: Errante no puede volar a Sol: la estrella la quemaría

Python

ship = SpaceShip("Errante", 149.6, 0, 0, 0)
mars = Planet("Marte", 227.9, 0, 0, 0.11)
sun = Star("Sol", 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"Rechazado: {e}")

Salida

Errante llegó a Marte
Nave Errante: (227.9, 0.0, 0.0), masa 0.00
Rechazado: Errante no puede volar a Sol: la estrella la quemaría

JavaScript

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

Salida

Errante llegó a Marte
Nave Errante: (227.9, 0.0, 0.0), masa 0.00
Rechazado: Errante no puede volar a Sol: la estrella la quemaría

El segundo DisplayInfo() no se ejecuta: la excepción salta al catch.

Más precisamente, para curiosos

Una clase puede implementar varias interfaces. Un satélite explorador que también pueda volar sería class Probe : SpaceObject, Orbiter, Fly.

Pruébalo

Encuentra el error

La Luna orbita alrededor del Sol, y no debería. ¿En qué línea del Orbit del satélite está el error?

Elige la línea con el error.

1public void Orbit(SpaceObject target)2{3 if (target is OrbitableSpaceObject planet)4 {5 planet.AddOrbiter(this);6 Console.WriteLine(Name + " orbita alrededor de " + planet.Name);7 }8 else9 {10 throw new NotValidSpaceObjectException(Name + " no puede orbitar alrededor de " + target.Name + ": un satélite orbita solo un planeta");11 }12}

Comprobar

Ejercicio

El espacio en código

Resuelve las tareas en tu editor, con las clases de la lección.

1. El sistema solar. Describe los ocho planetas con tres arrays: nombres, distancias al Sol (millones de km) y masas (masas terrestres). En un bucle, crea cada planeta con x = su distancia y haz que orbite alrededor del Sol. Después muestra todos los objetos que orbitan a su alrededor.

Planeta	Distancia	Masa
Mercurio	57,9	0,06
Venus	108,2	0,82
Tierra	149,6	1
Marte	227,9	0,11
Júpiter	778,5	317,8
Saturno	1432	95,2
Urano	2867	14,5
Neptuno	4515	17,1

Salida

Mercurio orbita alrededor de Sol
Venus orbita alrededor de Sol
Tierra orbita alrededor de Sol
Marte orbita alrededor de Sol
Júpiter orbita alrededor de Sol
Saturno orbita alrededor de Sol
Urano orbita alrededor de Sol
Neptuno orbita alrededor de Sol
Alrededor de Sol orbitan 8 planetas:
Planeta Mercurio: (57.9, 0.0, 0.0), masa 0.06
Planeta Venus: (108.2, 0.0, 0.0), masa 0.82
Planeta Tierra: (149.6, 0.0, 0.0), masa 1.00
Planeta Marte: (227.9, 0.0, 0.0), masa 0.11
Planeta Júpiter: (778.5, 0.0, 0.0), masa 317.80
Planeta Saturno: (1432.0, 0.0, 0.0), masa 95.20
Planeta Urano: (2867.0, 0.0, 0.0), masa 14.50
Planeta Neptuno: (4515.0, 0.0, 0.0), masa 17.10

2. Distancia. Escribe static double Distance(SpaceObject a, SpaceObject b) con el teorema de Pitágoras en tres dimensiones: la raíz cuadrada de la suma de los cuadrados de las diferencias en x, y y z. La Tierra está en (149,6; 0; 0), Marte está en (0; 227,9; 0), la Luna está en (149,6; 0,4; 0) y el Sol está en el origen.

Salida

Tierra – Marte: 272.6 millones de km
Tierra – Luna: 0.4 millones de km
Sol – Marte: 227.9 millones de km

3. El árbol completo. Cambia DisplayInfo para que la estrella muestre también sus planetas y cada planeta muestre sus satélites, con una sangría de dos espacios por nivel. Pista: un método con un parámetro para la sangría, que OrbitableSpaceObject sobrescribe (virtual en SpaceObject). La Tierra y Marte orbitan alrededor del Sol, la Luna orbita alrededor de la Tierra y Fobos orbita alrededor de Marte.

Salida

Tierra orbita alrededor de Sol
Marte orbita alrededor de Sol
Luna orbita alrededor de Tierra
Fobos orbita alrededor de Marte
Estrella Sol: (0.0, 0.0, 0.0), masa 333000.00
  Planeta Tierra: (149.6, 0.0, 0.0), masa 1.00
    Satélite Luna: (150.0, 0.0, 0.0), masa 0.01
  Planeta Marte: (227.9, 0.0, 0.0), masa 0.11
    Satélite Fobos: (227.9, 0.0, 0.0), masa 0.00

Más tareas

• Añadida dos veces. Ahora mismo la Tierra se puede añadir dos veces a los objetos que orbitan alrededor del Sol. Haz que un segundo intento lance NotValidSpaceObjectException.
• Una estrella llena. Añade 11 planetas a una estrella y captura la excepción en el undécimo.
• Una sonda. Haz una Probe que orbite y también vuele (mira «Más precisamente, para curiosos» en la parte de las naves).

Test

Ponte a prueba

1. ¿Por qué GetKind() es un método abstracto y DisplayInfo() no?

Los métodos abstractos son más rápidosEl tipo es distinto en cada clase, pero la forma de mostrar un objeto es común: se escribe una sola vez en el padredisplayInfo no puede ser abstracto porque imprime

2. ¿Por qué OrbitableSpaceObject guarda un contador además del array?

El contador guarda la masa de los objetos que orbitanEl array tiene un tamaño fijo (10) y los lugares ocupados son menos. El contador dice cuántos hay y dónde está el siguiente lugar libreSin contador el array no compila

3. Un satélite intenta moon.Orbit(sun). ¿Qué pasa?

El satélite empieza a orbitar alrededor de la estrellaEl programa se detiene enseguida, sin importar el catchOrbit lanza NotValidSpaceObjectException y el satélite no se añade a ningún lado

4. En C#, Orbit puede lanzar NotValidSpaceObjectException. ¿Qué tiene que decir la interfaz Orbiter al respecto?

Nada: C# no tiene excepciones comprobadas, y los métodos no declaran lo que lanzanthrows NotValidSpaceObjectException[Throws] encima del método

Comprobar

Empezar la lección de nuevo

Lecciones relacionadas

• Se basa en: Comprobaciones de tipo · Excepciones · try, catch y finally · Lanzar excepciones y crear las tuyas
• Ejercicios sobre el tema: Hagamos un juego