Programación orientada a objetos Tema 1
Crear clases
Funciona en el IDE online. Todo lo de esta sección funciona en el IDE online: pulsa Pruébalo en cualquier ejemplo, o abre el IDE y escribe el tuyo. Sin instalar nada.
Hasta ahora, cada dato iba en su variable: un String para el nombre, un int para la edad… Pero si tu programa gestiona los alumnos de una academia, cada alumno tiene nombre, edad y nivel, y con 30 alumnos necesitarías tres arrays que tendrías que mantener a la par a mano.
La programación orientada a objetos (POO) te deja crear tu propio tipo de dato, Alumno, que junta todo lo de un alumno en un solo sitio. Igual que existe String, ahora existirá Alumno.
Clases y objetos#
| Concepto | Qué es | En el ejemplo |
|---|---|---|
| Clase | El molde: describe cómo es un alumno, pero no es ningún alumno concreto | Alumno |
| Objeto | Cada alumno concreto hecho con el molde. Puede haber tantos como quieras | Antonio, María, Juan… |
| Atributo | Cada dato que tiene un objeto | nombre, edad, nivel |
| Método | Lo que sabe hacer un objeto | presentarse() |
Los cuatro principios de la POO#
La programación orientada a objetos se apoya en cuatro ideas. Aquí empieza la primera, y las demás se ven a lo largo de esta sección:
| Principio | Qué es | Dónde se ve |
|---|---|---|
| Abstracción | Quedarse con lo que importa de algo para el programa, y olvidar lo demás. Un Alumno de una academia tiene nombre, edad y nivel; su color de pelo no hace falta | Al diseñar cada clase: qué atributos y qué métodos lleva |
| Encapsulación | Cada objeto guarda sus datos y decide cómo se cambian: desde fuera no se tocan directamente, se piden con sus métodos | En este mismo tema, con private, get y set |
| Herencia | Una clase puede partir de otra y heredar lo que tiene: un Profesor y un Alumno son, los dos, una Persona | En Herencia |
| Polimorfismo | Un mismo método hace cosas distintas según el objeto que lo ejecuta: «dibujar» un círculo no es lo mismo que «dibujar» un cuadrado | En Polimorfismo |
Consejo
Si has visto los apuntes de SQL, esto te sonará: una clase es como una tabla, cada objeto es una fila y cada atributo es una columna. Por eso, cuando un programa lee una base de datos, suele convertir cada fila en un objeto.
Crear una clase#
Cada clase va en su propio fichero, que se llama igual que la clase: la clase Alumno va en Alumno.java, en la misma carpeta que el programa principal.
public class Alumno {
// Atributos: los datos de cada alumno
String nombre;
int edad;
String nivel;
}El constructor#
Dar los datos uno a uno después de crear el objeto es largo, y es fácil olvidarse alguno. El constructor es un método especial que se ejecuta al hacer new y rellena los atributos de una vez. Se llama igual que la clase y no lleva tipo de retorno:
public class Alumno {
String nombre;
int edad;
String nivel;
public Alumno(String nombre, int edad, String nivel) {
this.nombre = nombre;
this.edad = edad;
this.nivel = nivel;
}
}this.nombre es el atributo del objeto; nombre a secas es el parámetro que llega. La línea this.nombre = nombre; se lee: «guarda en mi nombre el nombre que me han dado».
Cómo se usa al crear los objetos está en el tema siguiente.
Métodos: lo que sabe hacer un objeto#
Los métodos de una clase son funciones que trabajan con los datos de ese objeto. Se escriben dentro de la clase, sin static:
public class Alumno {
String nombre;
int edad;
String nivel;
public Alumno(String nombre, int edad, String nivel) {
this.nombre = nombre;
this.edad = edad;
this.nivel = nivel;
}
public void presentarse() {
System.out.println("Soy " + nombre + ", tengo " + edad + " años y estoy en " + nivel);
}
public boolean esMayorDeEdad() {
return edad >= 18;
}
}Ahora se entiende el static del tema de funciones:
Con static | Sin static | |
|---|---|---|
| ¿De quién es? | De la clase entera | De cada objeto |
| ¿Cómo se llama? | Sin crear objetos: doble(5), Math.random() | Sobre un objeto: a1.presentarse() |
| ¿Usa los atributos? | No puede: no sabe de qué objeto serían | Sí: los del objeto sobre el que se llama |
Encapsulación: private, get y set#
Tal y como está, cualquiera puede escribir a1.edad = -5; y el programa se lo traga. Para protegerlo, los atributos se hacen privados y se accede a ellos a través de métodos, que pueden comprobar los datos:
public class Alumno {
private String nombre;
private int edad;
private String nivel;
public Alumno(String nombre, int edad, String nivel) {
this.nombre = nombre;
this.edad = edad;
this.nivel = nivel;
}
public String getNombre() {
return nombre;
}
public int getEdad() {
return edad;
}
public void setEdad(int edad) {
if (edad > 0) {
this.edad = edad;
}
}
}| Palabra | Quién puede usarlo |
|---|---|
private | Solo el código de la propia clase |
public | Cualquier parte del programa |
| Método | Para qué | Ejemplo |
|---|---|---|
get… (getter) | Leer un atributo privado | a1.getEdad() |
set… (setter) | Cambiar un atributo privado, comprobando antes que el valor tiene sentido | a1.setEdad(18); |
Mostrar un objeto: toString#
Si haces System.out.println(a1), Java no sabe cómo mostrar un alumno y saca algo como Alumno@6d06d69c. Para decirle cómo, se añade a la clase el método toString:
@Override
public String toString() {
return nombre + " (" + nivel + ")";
}Con él, System.out.println(a1) imprime Antonio (Master) (lo verás en el tema siguiente). La línea @Override avisa a Java de que estás cambiando un método que ya existía; no es obligatoria, pero ayuda a detectar errores.
Documentar una clase: Javadoc#
Una clase que van a usar otros se documenta con comentarios Javadoc, que empiezan por /**: uno encima de la clase, que dice para qué sirve, y uno encima de cada método público, con @param para cada dato que recibe y @return para lo que devuelve (los mismos que en los métodos de los fundamentos):
/**
* Un alumno de la academia, con su nombre, su edad y el nivel en que está.
*/
public class Alumno {
// … los atributos y el constructor
/**
* Dice si el alumno ya tiene 18 años.
*
* @return true si es mayor de edad
*/
public boolean esMayorDeEdad() {
return edad >= 18;
}
}Lo que se documenta es qué hace cada cosa, no cómo: para eso está el código. Los atributos privados y los get y set evidentes no suelen llevarlo. Con la herramienta javadoc del JDK (o con la opción de generar la documentación del IDE), esos comentarios se convierten en unas páginas web como las de las clases de Java.
Errores frecuentes#
| Mensaje o síntoma | Qué significa | Cómo se arregla |
|---|---|---|
class Alumno is public, should be declared in a file named Alumno.java | El fichero no se llama como la clase | Renombra el fichero: la clase Alumno va en Alumno.java (mayúsculas incluidas) |
nombre has private access in Alumno | Intentas usar un atributo privado desde fuera de la clase | Usa su método: a1.getNombre() |
Se imprime algo como Alumno@6d06d69c | La clase no tiene toString | Añade el método toString a la clase |