Apuntes de Programación

Resumen de los temas 1 a 5: qué es Java, tipos y variables, condiciones y bucles, métodos con Math y String, y programación orientada a objetos. Al final, la chuleta para el examen.

Lee un tema y luego practícalo. Lo que lees y practicas el mismo día se queda mucho mejor.

Tema 1

Introducción a Java

Qué es Java

  • Lenguaje de alto nivel para hacer programas de escritorio y para Internet.
  • Su gran ventaja: es independiente de la plataforma. El mismo programa funciona en cualquier sistema que tenga instalada la máquina virtual de Java (JVM).
  • Cómo lo consigue: el código fuente (.java) se compila a bytecode (archivos .class), que no es ejecutable directamente. La JVM interpreta ese bytecode.
Ojo, cae en el test: Java y JavaScript no tienen nada que ver. Java lo creó Sun y sirve para todo tipo de aplicaciones. JavaScript lo creó Netscape y va dentro de las páginas web.

Qué hace falta para programar

  1. Elegir la plataforma. Java SE (la estándar, la de clase), Java EE (empresas y servidores) o Java ME (móviles y dispositivos).
  2. Instalar el JDK (Java Development Kit, de Oracle y gratis). Trae la máquina virtual, las librerías y herramientas de consola, pero ninguna herramienta gráfica.
  3. Un IDE (opcional pero muy recomendable): NetBeans, que es el de clase, Eclipse, JDeveloper…
Herramienta del JDKPara qué sirve
javacEl compilador: pasa el .java a bytecode
javaLa máquina virtual: ejecuta el programa
javadocGenera la documentación a partir de los comentarios
jdbEl depurador
javapDesensambla clases
appletviewerVisor de applets

El primer programa

/* Mi primer programa */
public class HolaMundo {
    public static void main(String[] args) {
        System.out.println("Hola mundo");
    }
}
  • Todo programa Java es una clase. Su cuerpo va entre { }.
  • El archivo se tiene que llamar igual que la clase pública: HolaMundo.java.
  • El método main es imprescindible: es donde empieza la ejecución.
  • Lo que va entre /* */ o detrás de // son comentarios: el compilador los ignora.

Documentar con Javadoc

  • Documentar sirve para que otros (y tú dentro de un tiempo) entiendan el código.
  • Los comentarios Javadoc empiezan por /** y acaban en */. Cada línea empieza con *.
  • Se colocan en tres sitios: antes de la clase, antes de cada método y antes de cada atributo.
  • En NetBeans: clic derecho en el proyecto → Generate Javadoc. Sale en dist/javadoc/index.html.
EtiquetaQué indicaDónde
@authorEl autorClase
@versionLa versiónClase
@paramUn parámetro del método (una etiqueta por parámetro)Método
@returnLo que devuelve el métodoMétodo
@throwsLas excepciones que puede lanzarMétodo
@seeReferencia a otro código relacionadoClase y método
@sinceDesde cuándo existeTodos
@deprecatedQue está obsoletoTodos

Tema 2

Estructura y sintaxis de un programa

Estructura

  • Un programa tiene una o más clases, y cada clase uno o más métodos.
  • La clase principal tiene el método main. Todo empieza por ahí.
  • Cada sentencia acaba en punto y coma ; y se ejecutan en orden, una detrás de otra.

Tipos de datos simples

TipoGuardaTamañoEjemplo
byteEntero pequeño (−128 a 127)8 bitsbyte edad = 23;
shortEntero (−32.768 a 32.767)16 bitsshort iva = 21;
intEntero normal (unos ±2.100 millones)32 bitsint total = 88932;
longEntero muy grande64 bitslong luz = 299792458L;
floatDecimal de precisión simple32 bitsfloat precio = 4.99f;
doubleDecimal de doble precisión64 bitsdouble pi = 3.1416;
charUn solo carácter, entre comillas simples16 bitschar letra = 'a';
booleanVerdadero o falso—boolean ok = true;
Ojo: String no es un tipo simple, es una clase (se escribe con mayúscula y va entre comillas dobles). Un float lleva una f al final: 4.99f. Sin ella, 4.99 es un double y no cabe en un float.

Variables

  • Guardan un dato con un nombre. Antes de usarla hay que declararla: tipo y nombre. Al declararla se le reserva espacio en la memoria RAM.
  • Se puede declarar y dar valor a la vez, y declarar varias en una línea.
int edad;                  // declarar
edad = 24;                 // asignar
float precio = 4.99f;      // declarar y asignar
int peso = 80, altura = 182;

Reglas para los nombres (identificadores):

  • Sin espacios y sin empezar por un número. Admiten _ y $.
  • Distinguen mayúsculas y minúsculas: edad y Edad son distintas.
  • Mejor sin tildes ni ñ, y que el nombre diga lo que guarda.
  • Convenios: variables y métodos en minúscula y cada palabra nueva en mayúscula (precioCoche). Clases con mayúscula (Coche). Constantes todo en mayúsculas con guion bajo (DIAS_SEMANA).

Ámbito: una variable solo existe dentro del bloque { } donde se declara. Si la declaras dentro de un método, desde main no se puede usar.

Constantes

Datos que nunca cambian (IVA, PI…). Se declaran con final y su valor no se puede modificar.

final static double PI = 3.141592;
final static int CAPACIDAD_MAXIMA = 88932;

Operadores

TipoOperadoresOjo con
Aritméticos+ - * / %Entre dos int, / no tiene decimales: 7 / 2 da 3. % es el resto: 7 % 2 da 1.
Relacionales== != < > <= >=Comparar es ==; = es asignar.
Lógicos&& || !&&: las dos se cumplen. ||: basta con una. !: niega.
Unarios++ -- -x++ usa x y luego suma 1; ++x suma primero.
De bits& | ^ ~ << >>Trabajan bit a bit (casi no se usan en clase).
De asignación= += -= *= /= %=x += 5 es lo mismo que x = x + 5.

Prioridad, de más a menos: paréntesis → ++ -- ! → * / % → + - → relacionales < > <= >= → == != → && → || → asignación. Con la misma prioridad se va de izquierda a derecha.

int a = 2, b = 4;
System.out.println(5 + 3 % 7 * b);     // 3 % 7 = 3, 3 * 4 = 12, 5 + 12 = 17
System.out.println(20 * 10 / 2 - 20 / 5 * 3);  // 100 - 12 = 88

Conversión de tipos (cast)

  • Implícita: automática, de un tipo más pequeño a uno más grande (short → int, int → double).
  • Explícita (cast): la fuerzas tú, de grande a pequeño, poniendo el tipo entre paréntesis. Puedes perder datos (los decimales, por ejemplo).
short s = 88;
int i = s;               // implícita
double d = 7.9;
int entero = (int) d;    // explícita: entero vale 7 (se pierden los decimales)

Paquetes e import

  • Un paquete agrupa clases relacionadas (java.util, java.io…).
  • java.lang se importa solo; por eso System, Math y String funcionan sin import.
  • Se puede importar una clase (import java.util.Scanner;) o el paquete entero (import java.util.*;).

Leer datos del teclado: Scanner

import java.util.Scanner;

public class Circulo {
    public static void main(String[] args) {
        Scanner entrada = new Scanner(System.in);
        System.out.println("Introduce el radio:");
        double radio = entrada.nextDouble();
        System.out.println("Área: " + Math.PI * radio * radio);
    }
}
Quieres leerMétodo
intentrada.nextInt()
doubleentrada.nextDouble() (en español se escribe con coma: 3,5)
long, float, byte, short, booleannextLong(), nextFloat(), nextByte(), nextShort(), nextBoolean()
Una línea de textoentrada.nextLine()
Un charentrada.nextLine().charAt(0)
Ojo: Scanner está en java.util, así que sin import java.util.Scanner; sale cannot find symbol. Si escribes una letra donde se espera un número, salta InputMismatchException.

Tema 3

Estructuras de control de flujo

Condicionales

  • Simple (if): solo se ejecuta si se cumple la condición.
  • Doble (if … else): una cosa u otra.
  • Varias (if … else if …): entra solo en la primera que se cumple y salta al final.
  • Si dentro hay una sola sentencia, las llaves son opcionales.
if (nota < 0 || nota > 10) {
    System.out.println("Error: la nota va de 0 a 10");
} else if (nota <= 4) {
    System.out.println("Suspenso");
} else if (nota <= 6) {
    System.out.println("Bien");
} else {
    System.out.println("Sobresaliente o notable");
}

switch (menús)

switch (opcion) {
    case 1:
        System.out.println("Sumar");
        break;
    case 2:
        System.out.println("Restar");
        break;
    default:
        System.out.println("Opción no válida");
}
  • La variable puede ser byte, short, int o char (en Java moderno también String).
  • break sale del switch. Si lo olvidas, sigue ejecutando los case de abajo.
  • default se ejecuta si ningún case coincide.

Bucles

BucleCuándo usarloVeces que se ejecuta
whileNo sabes cuántas vueltas; puede que ninguna0 o más (mira la condición antes)
do … whileTiene que ejecutarse al menos una vez (pedir hasta que valga)1 o más (mira la condición al final)
forSabes cuántas vueltasUn número fijo
// while
int i = 12;
while (i <= 132) { System.out.println(i); i += 2; }

// do-while: pedir hasta que sea positivo
do {
    System.out.println("Número positivo:");
    n = entrada.nextInt();
} while (n <= 0);

// for: inicialización; condición; incremento
for (int x = 1; x <= 10; x++) {
    System.out.println(8 + " x " + x + " = " + 8 * x);
}
Ojo: el do … while lleva punto y coma después del while (…). Si dentro del bucle nunca cambia lo que mira la condición, el bucle no termina nunca (bucle infinito).

Saltos: break y continue

  • break: sale del bucle (o del switch) de golpe.
  • continue: se salta lo que queda de esa vuelta y pasa a la siguiente.
  • En clase se desaconsejan fuera del switch porque hacen el código más difícil de leer.

Excepciones: try / catch / finally

Sirven para que el programa no se pare de golpe cuando algo falla.

try {
    int resultado = a / b;
    System.out.println(resultado);
} catch (ArithmeticException e) {
    System.out.println("No se puede dividir entre cero");
} finally {
    System.out.println("Esto se ejecuta siempre");
}
ExcepciónCuándo salta
ArithmeticExceptionDividir un entero entre 0
InputMismatchExceptionScanner espera un número y escribes otra cosa
NumberFormatExceptionConvertir a número un texto que no lo es
StringIndexOutOfBoundsExceptionPedir una posición que no existe en un String
NullPointerExceptionUsar algo que vale null
Ojo: InputMismatchException está en java.util, así que necesita import. Y después de capturarla hay que limpiar lo escrito con entrada.nextLine(), o el bucle se repite sin parar.

Tema 4

Subprogramas (métodos) y clases de uso común

Métodos estáticos

  • En vez de meterlo todo en main, el programa se divide en métodos, cada uno con una tarea.
  • Los estáticos (static) pertenecen a la clase: no hace falta crear ningún objeto para usarlos.
  • Desde la misma clase se llaman por su nombre. Desde otra clase: NombreClase.metodo(). Si la otra clase está en otro paquete, hay que importarla (o escribir paquete.Clase.metodo()).
  • Para llamarlo desde otra clase tiene que ser public; si es private, no se puede.
public class Calculos {
    // void: no devuelve nada, solo hace algo
    public static void mostrar(int edad, double altura) {
        System.out.println("Edad: " + edad + ", altura: " + altura);
    }

    // int: devuelve un valor con return
    public static int multiplicar(int a, int b) {
        return a * b;
    }

    public static void main(String[] args) {
        mostrar(23, 1.82);
        int r = multiplicar(4, 5);     // el valor devuelto se guarda
        System.out.println(r);         // 20
    }
}

Tipos de métodos

  • void: no devuelve nada. No lleva return valor;.
  • Con tipo (int, double, boolean, String…): devuelven un valor de ese tipo con return, en todos los caminos posibles.
  • Los parámetros son los datos que recibe. Al llamarlo hay que pasar el mismo número, en el mismo orden y del mismo tipo.
  • Cambiar una variable dentro de un método no cambia la variable con el mismo nombre de otro método: cada una es local a su método.
Ojo, errores típicos: llamar desde main a un método sin static (non-static method cannot be referenced); un método int sin return en algún caso (missing return statement); llamar a un método que devuelve algo y no guardar el resultado (no da error, pero el valor se pierde).

La clase Math

Está en java.lang (no hace falta import) y todos sus métodos son estáticos: Math.metodo(...).

MétodoQué haceEjemplo
Math.sqrt(x)Raíz cuadradaMath.sqrt(81) → 9.0
Math.pow(b, e)PotenciaMath.pow(8, 3) → 512.0
Math.abs(x)Valor absolutoMath.abs(-4.5) → 4.5
Math.max(a, b) / Math.min(a, b)Mayor / menor de dosMath.min(2, 3) → 2
Math.round(x)Redondea al entero más cercanoMath.round(2.5) → 3; Math.round(-4.5) → -4
Math.ceil(x) / Math.floor(x)Entero por arriba / por abajoMath.ceil(2.1) → 3.0; Math.floor(2.9) → 2.0
Math.random()Número aleatorio entre 0 (incluido) y 1 (sin incluir)(int)(Math.random() * 10) + 1 → de 1 a 10
Math.exp, Math.log, Math.sin, Math.cos, Math.tanExponencial, logaritmo neperiano y trigonometría (en radianes)Math.sin(Math.toRadians(45))
Math.PI, Math.ELas constantes π y e2 * Math.PI * r

La clase String

  • Una cadena de texto. Se crea normalmente con comillas dobles: String nombre = "Pepe"; (también con new String("Pepe")).
  • Para comparar textos se usa equals, nunca ==. == mira si es el mismo objeto, no si el texto es igual.
  • equalsIgnoreCase compara sin importar mayúsculas y minúsculas.
  • texto.charAt(0) da el primer carácter; texto.length(), cuántos tiene.
String respuesta = entrada.nextLine();
if (respuesta.equalsIgnoreCase("Madrid")) {
    System.out.println("Correcto");
}

Tema 5

Programación orientada a objetos

Clases y objetos

  • Hasta ahora un programa era una lista de instrucciones. En la programación orientada a objetos (POO) el programa es un grupo de objetos que se piden cosas unos a otros. Un banco, por ejemplo: objetos cliente, objetos cuenta, objetos sucursal…
  • Una clase es el molde o la plantilla. Un objeto es cada cosa concreta hecha con ese molde. Con la clase Mascota puedes crear a Toby y a Luna: los dos tienen nombre y edad, pero cada uno los suyos.
  • Lo que tiene cada objeto son sus atributos (nombre, edad…). Lo que sabe hacer son sus métodos (comer, dormir, mostrarDatos…).
  • Un objeto se crea con new. Hasta que no haces new, la variable no apunta a nada (vale null).
Mascota toby;            // declaro la variable: todavía no hay objeto (null)
toby = new Mascota();    // ahora sí: new crea el objeto
Mascota luna = new Mascota();   // lo normal: las dos cosas en una línea
toby.comer();            // a un objeto se le piden cosas con un punto

Cómo se escribe una clase

public class Mascota {
    // atributos: private, para que solo los toque la propia clase
    private String nombre;
    private int edad;

    // métodos: public, para que se puedan usar desde fuera
    public void establecerNombre(String n) {   // "set": cambia un atributo
        nombre = n;
    }
    public String obtenerNombre() {            // "get": devuelve un atributo
        return nombre;
    }
    public void cumplirAnios() {
        edad++;
    }
}
  • Los atributos y métodos de objeto no llevan static: son de cada objeto.
  • Lo normal es atributos private y métodos public. Así nadie de fuera cambia un dato a lo loco: tiene que pasar por un método (eso se llama encapsulación). A esos métodos se les llama get (obtenerX) y set (establecerX).
  • En NetBeans cada clase pública va en su archivo (Mascota.java), y el main en otra clase, por ejemplo Test.java, del mismo paquete.
  • Quién puede ver cada cosa (Hija fuera = una subclase que está en otro paquete):
AccesoSu clasePaqueteHija fueraTodos
privateSíNoNoNo
nada (friendly)SíSíNoNo
protectedSíSíSíNo
publicSíSíSíSí

static: lo que es de la clase, no de cada objeto

  • Un atributo static es uno solo para toda la clase, compartido por todos los objetos. El ejemplo típico es un contador de cuántos objetos se han creado.
  • Un método static se llama con el nombre de la clase: Mascota.verTotal(). Dentro de él no hay "objeto actual", así que no puede usar atributos que no sean static.
public class Mascota {
    private static int total = 0;   // uno para todas las mascotas
    private String nombre;          // uno por cada mascota

    public Mascota(String nombre) {
        this.nombre = nombre;
        total++;                    // cada mascota nueva suma 1
    }
    public static int verTotal() {
        return total;
    }
}
// en main: new Mascota("Toby"); new Mascota("Luna");
// System.out.println(Mascota.verTotal());   → 2

Un atributo puede ser otro objeto

Una clase puede tener como atributo un objeto de otra clase. Un Alumno tiene una Direccion; un Coche tiene un Motor.

public class Direccion {
    private String calle;
    private String ciudad;
    public Direccion(String calle, String ciudad) { this.calle = calle; this.ciudad = ciudad; }
    public String obtenerCiudad() { return ciudad; }
}

public class Alumno {
    private String nombre;
    private Direccion direccion;     // un objeto dentro de otro
    public Alumno(String nombre, Direccion direccion) { this.nombre = nombre; this.direccion = direccion; }
    public Direccion obtenerDireccion() { return direccion; }
}
// en main: Alumno a = new Alumno("Eva", new Direccion("Sol 3", "Cáceres"));
//          a.obtenerDireccion().obtenerCiudad()   → "Cáceres"

Constructores

  • Un constructor es un método especial que se ejecuta solo al hacer new. Sirve para dar valores iniciales a los atributos.
  • Se llama exactamente igual que la clase y no lleva tipo, ni siquiera void.
  • Si no escribes ninguno, Java pone uno vacío (el constructor por defecto) y los atributos empiezan a 0, false o null.
  • Puedes escribir varios con distintos parámetros. Ojo: en cuanto escribes uno con parámetros, el vacío desaparece. Si también lo quieres, escríbelo tú.
  • Lo correcto es dar los valores iniciales en el constructor, no al declarar el atributo.
public class Lampara {
    private String color;
    private boolean encendida;

    public Lampara() {                 // constructor sin parámetros (el "por defecto", editado)
        color = "blanca";
        encendida = false;
    }
    public Lampara(String color) {     // otro constructor que recibe el color
        this.color = color;
        encendida = false;
    }
}
// Lampara a = new Lampara();          → usa el primero: blanca
// Lampara b = new Lampara("roja");    → usa el segundo: roja

this

  • this es el objeto con el que estás trabajando ahora mismo.
  • Se usa sobre todo cuando un parámetro se llama igual que un atributo: this.color es el atributo y color a secas es el parámetro.
  • this(...), como primera línea de un constructor, llama a otro constructor de la misma clase.
Ojo: si escribes color = color; no pasa nada: el parámetro se copia en sí mismo y el atributo se queda vacío. Con el mismo nombre, siempre this.color = color;.

Paso de parámetros: por valor y "por referencia"

  • Tipos básicos (int, double, char, boolean…): el método recibe una copia. Si la cambia dentro, la variable de fuera no cambia. Es el paso por valor.
  • Objetos y arrays: el método recibe la dirección del objeto (dónde está en memoria), así que trabaja con el mismo objeto. Si le cambia algo, el cambio se ve fuera. En clase lo llamamos paso por referencia.
public static void subir(int n) { n = n + 100; }                    // cambia la copia
public static void pintar(Lampara l) { l.establecerColor("azul"); }  // cambia EL objeto

// int x = 5;  subir(x);   → x sigue valiendo 5
// Lampara a = new Lampara("roja");  pintar(a);   → a ahora es azul

Sobrecarga de métodos

  • Varios métodos de la misma clase pueden llamarse igual si tienen distintos parámetros (distinto número o distinto tipo). Java elige cuál usar según lo que le pases.
  • Solo cambiar lo que devuelve no vale: tiene que cambiar la lista de parámetros.
  • Los constructores también se pueden sobrecargar (como los de Lampara).
public static int area(int lado) { return lado * lado; }               // cuadrado
public static int area(int base, int altura) { return base * altura; }  // rectángulo
public static double area(double radio) { return Math.PI * radio * radio; }  // círculo
// area(3) → 9;  area(3, 4) → 12;  area(1.0) → 3.14159...

Destructores y recolector de basura

  • En C++ los objetos se borran a mano con delete. En Java no existe delete: el recolector de basura (garbage collector) borra solo los objetos que ya nadie apunta.
  • Un objeto se queda sin referencia cuando ninguna variable apunta a él. Ejemplo: los String no se pueden cambiar (son inmutables); al hacer s = s + "!" se crea un texto nuevo y el viejo se queda suelto.
  • Antes de borrarlo, Java podía llamar al método finalize(). Hoy está obsoleto (deprecated), pero sale en los apuntes: protected void finalize() throws Throwable { ... }.

Métodos recursivos

  • Un método recursivo se llama a sí mismo con un problema más pequeño.
  • Siempre necesita un caso base: un caso que se resuelve sin volver a llamarse. Si no, se llama sin fin y salta StackOverflowError.
// 5! = 5 * 4 * 3 * 2 * 1   →   factorial(n) = n * factorial(n - 1)
public static int factorial(int n) {
    if (n == 0) {
        return 1;                       // caso base: se para aquí
    }
    return n * factorial(n - 1);        // llamada con un número más pequeño
}
// factorial(4) = 4 * factorial(3) = 4 * 3 * factorial(2) = ... = 24

Herencia

  • Una clase puede heredar de otra con extends: tiene todos sus atributos y métodos y además añade los suyos. Así no repites código.
  • La de arriba es la superclase (o clase padre, clase base). La de abajo, la subclase (clase hija). Animal → Perro, Gato.
  • Los constructores no se heredan. El constructor de la hija llama al del padre con super(...), y tiene que ser la primera línea. Si no lo pones, Java pone super() sin datos; si el padre no tiene constructor vacío, da error.
  • Al crear un objeto hijo se ejecuta primero el constructor del padre y después el del hijo.
  • Los atributos private del padre existen en el hijo, pero el hijo no puede tocarlos directamente: usa los métodos del padre (o hazlos protected).
  • Sobrescribir (override): la hija puede volver a escribir un método del padre con la misma cabecera para que haga otra cosa. Con super.metodo() llama a la versión del padre. La anotación @Override encima es opcional, pero ayuda.
public class Animal {
    private String nombre;
    public Animal(String nombre) { this.nombre = nombre; }
    public String obtenerNombre() { return nombre; }
    public void presentarse() { System.out.println("Soy " + nombre); }
}

public class Perro extends Animal {
    private String raza;
    public Perro(String nombre, String raza) {
        super(nombre);          // 1º: construye la parte de Animal
        this.raza = raza;       // 2º: lo suyo
    }
    @Override
    public void presentarse() {          // sobrescribe el del padre
        super.presentarse();             // hace lo del padre...
        System.out.println("Raza: " + raza);   // ...y añade lo suyo
    }
}
// Perro p = new Perro("Toby", "beagle");
// p.presentarse();      → Soy Toby / Raza: beagle
// p.obtenerNombre();    → "Toby" (heredado de Animal)
Ojo, errores típicos: constructor con tipo (public void Perro(...) ya no es un constructor); método sin tipo (invalid method declaration; return type required); tocar un atributo private desde otra clase (has private access); hacer new Clase() cuando solo hay constructores con parámetros (constructor ... cannot be applied to given types); llamar desde main a un método de objeto sin objeto (non-static method cannot be referenced from a static context); usar un objeto sin hacer new (NullPointerException).

Chuleta para el examen

  • 7 / 2 es 3, 7 % 2 es 1, 7.0 / 2 es 3.5.
  • = asigna, == compara números, equals compara textos.
  • char con comillas simples 'a'; String con dobles "a".
  • Cada sentencia acaba en ;. Las llaves van siempre en pareja.
  • do { } while (…); lleva punto y coma al final.
  • Scanner necesita import java.util.Scanner;.
  • Desde main solo se llaman métodos static.
  • Un método con tipo necesita return en todos los casos; uno void, no.
  • final hace que la variable sea constante; su nombre va en MAYÚSCULAS.
  • Sin break, el switch sigue por los case de abajo.
  • El archivo se llama igual que la clase pública.
  • Objeto: Clase obj = new Clase(datos); y luego obj.metodo();.
  • Constructor: mismo nombre que la clase y sin tipo. Si escribes uno con parámetros, el vacío desaparece.
  • Atributos private + métodos get/set public. this.x = x; cuando se llaman igual.
  • static: uno para toda la clase (contadores). Se llama con Clase.metodo().
  • Tipos básicos se pasan por valor (copia); los objetos, por referencia (el mismo objeto).
  • Sobrecarga: mismo nombre, distintos parámetros. Sobrescritura: la hija rehace un método del padre.
  • extends para heredar; super(...) la primera línea del constructor hijo.
  • Recursivo: caso base + llamada más pequeña.
{} ContinúaEditor de Java