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.
Qué hace falta para programar
- Elegir la plataforma. Java SE (la estándar, la de clase), Java EE (empresas y servidores) o Java ME (móviles y dispositivos).
- 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.
- Un IDE (opcional pero muy recomendable): NetBeans, que es el de clase, Eclipse, JDeveloper…
| Herramienta del JDK | Para qué sirve |
|---|---|
javac | El compilador: pasa el .java a bytecode |
java | La máquina virtual: ejecuta el programa |
javadoc | Genera la documentación a partir de los comentarios |
jdb | El depurador |
javap | Desensambla clases |
appletviewer | Visor 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
maines 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.
| Etiqueta | Qué indica | Dónde |
|---|---|---|
@author | El autor | Clase |
@version | La versión | Clase |
@param | Un parámetro del método (una etiqueta por parámetro) | Método |
@return | Lo que devuelve el método | Método |
@throws | Las excepciones que puede lanzar | Método |
@see | Referencia a otro código relacionado | Clase y método |
@since | Desde cuándo existe | Todos |
@deprecated | Que está obsoleto | Todos |
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
| Tipo | Guarda | Tamaño | Ejemplo |
|---|---|---|---|
byte | Entero pequeño (−128 a 127) | 8 bits | byte edad = 23; |
short | Entero (−32.768 a 32.767) | 16 bits | short iva = 21; |
int | Entero normal (unos ±2.100 millones) | 32 bits | int total = 88932; |
long | Entero muy grande | 64 bits | long luz = 299792458L; |
float | Decimal de precisión simple | 32 bits | float precio = 4.99f; |
double | Decimal de doble precisión | 64 bits | double pi = 3.1416; |
char | Un solo carácter, entre comillas simples | 16 bits | char letra = 'a'; |
boolean | Verdadero o falso | — | boolean ok = true; |
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:
edadyEdadson 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
| Tipo | Operadores | Ojo 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.langse importa solo; por esoSystem,MathyStringfuncionan sinimport.- 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 leer | Método |
|---|---|
int | entrada.nextInt() |
double | entrada.nextDouble() (en español se escribe con coma: 3,5) |
long, float, byte, short, boolean | nextLong(), nextFloat(), nextByte(), nextShort(), nextBoolean() |
| Una línea de texto | entrada.nextLine() |
Un char | entrada.nextLine().charAt(0) |
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,intochar(en Java moderno tambiénString). breaksale del switch. Si lo olvidas, sigue ejecutando los case de abajo.defaultse ejecuta si ningún case coincide.
Bucles
| Bucle | Cuándo usarlo | Veces que se ejecuta |
|---|---|---|
while | No sabes cuántas vueltas; puede que ninguna | 0 o más (mira la condición antes) |
do … while | Tiene que ejecutarse al menos una vez (pedir hasta que valga) | 1 o más (mira la condición al final) |
for | Sabes cuántas vueltas | Un 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);
}
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ón | Cuándo salta |
|---|---|
ArithmeticException | Dividir un entero entre 0 |
InputMismatchException | Scanner espera un número y escribes otra cosa |
NumberFormatException | Convertir a número un texto que no lo es |
StringIndexOutOfBoundsException | Pedir una posición que no existe en un String |
NullPointerException | Usar algo que vale null |
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 escribirpaquete.Clase.metodo()). - Para llamarlo desde otra clase tiene que ser
public; si esprivate, 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 llevareturn valor;.- Con tipo (
int,double,boolean,String…): devuelven un valor de ese tipo conreturn, 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.
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étodo | Qué hace | Ejemplo |
|---|---|---|
Math.sqrt(x) | Raíz cuadrada | Math.sqrt(81) → 9.0 |
Math.pow(b, e) | Potencia | Math.pow(8, 3) → 512.0 |
Math.abs(x) | Valor absoluto | Math.abs(-4.5) → 4.5 |
Math.max(a, b) / Math.min(a, b) | Mayor / menor de dos | Math.min(2, 3) → 2 |
Math.round(x) | Redondea al entero más cercano | Math.round(2.5) → 3; Math.round(-4.5) → -4 |
Math.ceil(x) / Math.floor(x) | Entero por arriba / por abajo | Math.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.tan | Exponencial, logaritmo neperiano y trigonometría (en radianes) | Math.sin(Math.toRadians(45)) |
Math.PI, Math.E | Las constantes π y e | 2 * Math.PI * r |
La clase String
- Una cadena de texto. Se crea normalmente con comillas dobles:
String nombre = "Pepe";(también connew String("Pepe")). - Para comparar textos se usa
equals, nunca==.==mira si es el mismo objeto, no si el texto es igual. equalsIgnoreCasecompara 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
Mascotapuedes 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 hacesnew, la variable no apunta a nada (valenull).
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
privatey métodospublic. 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 elmainen otra clase, por ejemploTest.java, del mismo paquete. - Quién puede ver cada cosa (Hija fuera = una subclase que está en otro paquete):
| Acceso | Su clase | Paquete | Hija fuera | Todos |
|---|---|---|---|---|
private | Sí | No | No | No |
| nada (friendly) | Sí | Sí | No | No |
protected | Sí | Sí | Sí | No |
public | Sí | Sí | Sí | Sí |
static: lo que es de la clase, no de cada objeto
- Un atributo
statices 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
staticse 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,
falseonull. - 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
thises 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.colores el atributo ycolora secas es el parámetro. this(...), como primera línea de un constructor, llama a otro constructor de la misma clase.
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 existedelete: 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
Stringno se pueden cambiar (son inmutables); al hacers = 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 ponesuper()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
privatedel padre existen en el hijo, pero el hijo no puede tocarlos directamente: usa los métodos del padre (o hazlosprotected). - 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@Overrideencima 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)
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 / 2es 3,7 % 2es 1,7.0 / 2es 3.5.=asigna,==compara números,equalscompara textos.charcon comillas simples'a';Stringcon 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
mainsolo se llaman métodosstatic. - Un método con tipo necesita
returnen todos los casos; unovoid, no. finalhace que la variable sea constante; su nombre va en MAYÚSCULAS.- Sin
break, elswitchsigue por los case de abajo. - El archivo se llama igual que la clase pública.
- Objeto:
Clase obj = new Clase(datos);y luegoobj.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/setpublic.this.x = x;cuando se llaman igual. static: uno para toda la clase (contadores). Se llama conClase.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.
extendspara heredar;super(...)la primera línea del constructor hijo.- Recursivo: caso base + llamada más pequeña.