Diferencias

Muestra las diferencias entre dos versiones de la página.

--- clase:daw:prog:2eval:clases_abstractas_interfaces [2022/07/20 10:24]
cesguiro [Utilidad de las interfaces]
+++ — (actual)
@@ Línea 1: / Línea 1: @@
-====== 11 - Clases y Métodos abstractos. Interfaces ======
-===== Métodos abstractos =====
-Vamos a seguir con nuestro ejemplo de los vehículos con herencia. Tenemos la clase //Vehiculo//, a la que vamos a añadir una nueva propiedad: //matricula//.
-<sxh java; highlight:[5]>
-public class Vehiculo {
-    private String marca, modelo;
-    private int velocidad;
-    private float[] presionRuedas;
-    private String matricula;
-    ...
-</sxh>
-Supongamos que el proceso de matriculación es diferente para los distintos vehículos (las motos de menos de 250cc no pagan impuesto de matriculación, por ejemplo), pero queremos que todos los vehículos implementen ese método obligatoriamente. Si dejamos las clases como están, es el programador el que tiene que acordarse de implementar ese método. Podría darse el caso de crear un vehículo sin la opción de matricular.
-Existe una forma de obligar a todas las clases descendientes a implementar un método: los **métodos abstractos**. Un método abstracto es aquel que tiene solo la definición de la cabecera, pero no su implementación. Por ejemplo, podemos crear el método abstracto //matricular()// en la clase //Vehiculo//:
-<sxh java; highlight:[9]>
-public class Vehiculo {
-    private String marca, modelo;
-    private int velocidad;
-    private float[] presionRuedas;
-    private String matricula;
-    ...
-    public abstract void matricular(String matricula);
-</sxh>
-Fíjate que el método //matricular// no tiene implementación. Tan solo hemos definido su cabecera (es un método público que no devuelve nada y recibe un parámetro de tipo String). Además, para indicar que es un método abstracto debemos usar la palabra **abstract**.
-Lo primero que pasa al crear un método abstracto es que Java nos da un error. ¿Por qué? Simplemente, porque si una clase tiene uno o más métodos abstractos, debemos declarar esa clase también como abstracta. Esto indica que no podemos crear objetos de dicha clase, cosa lógica, ya que no tiene implementado el método recién creado (//matricular//). Para declarar la clase como abstracta, lo único que tenemos que hacer es añadir **abstract** a la definición de la clase:
-<sxh java; highlight:[1]>
-public abstract class Vehiculo {
-    private String marca, modelo;
-    private int velocidad;
-    private float[] presionRuedas;
-    private String matricula;
-    ...
-    public abstract void matricular(String matricula);
-    ...
-</sxh>
-Vamos a aprovechar y a crear otro método que nos será útil más adelante. Será de tipo //protected// para que lo puedan usar solo las clases descendientes (aunque acuérdate que en Java los método protegidos también lo pueden usar las clases definidas en el mismo paquete, con lo que para hacerlo bien deberíamos cambiar el //package// de la clase //Vehiculo// y sus descendientes. Por simplificar, vamos a dejarlo como está) y será el setter del atributo //matricula//:
-<sxh java>
-public abstract class Vehiculo {
-    private String marca, modelo;
-    private int velocidad;
-    private float[] presionRuedas;
-    private String matricula;
-    ...
-    public abstract void matricular(String matricula);
-    protected void setMatricula(String matricula){
-        this.matricula = matricula;
-    }
-    ...
-</sxh>
-El método //setMatricula()// lo necesitaremos más adelante, ya que el atributo //matricula// es privado y no se puede acceder a él desde las clases descendientes. Además, lo hacemos //protected// para que no se pueda cambiar la matrícula de un vehículo desde fuera de las clases descendientes de //Vehiculo//.
-Al definir la clase como abstracta, vemos que nos desaparece el error anterior, pero ahora nos muestra errores en las clases //Coche// y //Moto//. Esos errores nos están indicando que ambas clases tienen que implementar **obligatoriamente** los métodos abstractos de sus clases antecesoras. Si creamos el método en la clase //Coche// vemos como desaparece el error:
-<sxh java>
-public class Coche extends Vehiculo{
-    private boolean ruedaRepuesto;
-    ...
-    @Override
-    public void matricular(String matricula) {
-        this.setMatricula(matricula);
-        System.out.println("Pagar impuesto de matriculación");
-    }
-</sxh>
-Lo único que hace el método es mostrar la frase "Pagar impuesto de matriculación". Para implementar el método en la clase //Moto//, primero debemos crear el atributo //cilindrada// y pasarlo al constructor. El método //matricular()// comprobará la cilindrada de la moto y mostrará por pantalla si se debe pagar matrícula o no:
-<sxh java>
-public class Moto extends Vehiculo{
-    private int cilindrada;
-    public Moto(String marca, String modelo, int velocidad, float[] presionRuedas, int cilindrada) {
-        super(marca, modelo, velocidad, presionRuedas);
-        this.cilindrada = cilindrada;
-    }
-    @Override
-    public void matricular(String matricula) {
-        if(this.cilindrada<250) {
-            System.out.println("No hace falta pagar impuesto matriculación");
-        } else {
-            System.out.println("Pagar impuesto matriculación");
-        }
-    }
-}
-</sxh>
-Vamos a crear un coche y un par de motos en nuestra clase principal para comprobar que todo funciona:
-<sxh java>
-public class Main {
-    public static void main(String[] args) {
-        Coche coche1 = new Coche(
-                            "Kia",
-                            "Niro",
-,
-                            new float[] {2.4f, 2.4f, 2.4f, 2.4f},
-                            true
-                        );
-        Moto moto1 = new Moto(
-                        "Honda",
-                        "NC 750",
-,
-                        new float[] {2.5f, 2.5f},
-        );
-        Moto moto2 = new Moto(
-                        "Yamaha",
-                        "XMAX",
-,
-                        new float[] {2.2f, 2.2f},
-        );
-        coche1.matricular("1111AAA");
-        moto1.matricular("2222BBB");
-        moto2.matricular("3333CCCC");
-    }
-}
-</sxh>
-<sxh base>
-Pagar impuesto de matriculación
-Pagar impuesto matriculación
-No hace falta pagar impuesto matriculación
-</sxh>
-==== Propiedades de los métodos abstractos ====
-  * Podemos declarar clases abstractas sin necesidad de tener algún método abstracto. Aunque no es lo habitual, puede ser útil si queremos definir métodos comunes de las clases descendientes pero no queremos que se puedan crear objetos de dicha clase.
-  * Un método abstracto solo se puede definir como //protected// o //public//. Esto es lógico, ya que si es //private// no puede ser accesible desde las clases descendientes y no podrían implementarlo.
-  * No podemos reducir la visibilidad de un método abstracto en las clases hijas. Es decir, si en la clase padre hemos declarado el método abstracto como //public//, en las clases hijas que implementen ese método no podemos definirlas con una accesibilidad más restrictiva (//private// o //protected//). Sin embargo, si declaramos el método abstracto como //protected// si que podemos declararlo en las clases hijas como //public//.</note>
-===== Interfaces =====
-Podríamos definir las **interfaces** como clases donde todos sus métodos son abstractos (no todos, como veremos a continuación). En realidad, tienen algunas características más:
-  * Las //interfaces// pueden ser públicas o sin modificador de acceso (accesible desde el paquete donde está definida).
-  * Una //interface// pueden definir métodos abstractos o métodos estáticos y ambos serán públicos (aunque no se indique).
-  * Podemos definir atributos en la //interface//, pero tienen que ser públicos, estáticos y finales (constantes), con lo que debemos darle un valor. No hace falta añadirles los modificadores (//public//, //static// y //final//), pero sí darles un valor.
-  * Una clase puede heredar (implementar) de una o varias //interfaces//.
-Para declarar una //interface// en Java, debemos usar la palabra reservada **interface**:
-<sxh java>
-public interface nombreInterface {
-...
-}
-</sxh>
-Si queremos que una clase //implemente// una //interface//, debemos usar la palabra reservada **implements**, en lugar de //extends// como en la herencia:
-<sxh java>
-public class miClase implements nombreInterface {
-...
-}
-</sxh>
-==== Utilidad de las interfaces ====
-Aunque en un principio pueda parecer que las //interfaces// son poco útiles, son uno de los mecanismos más importantes para crear una buena arquitectura de nuestra aplicación.
-Por ejemplo, supongamos que estamos haciendo un programa que permite leer documentos //pdf// donde tenemos almacenados nuestros clientes.  Para eso, creamos una clase //Cliente// y una clase //DocumentoPdf// un método para encontrar un cliente en el //pdf// con el //id// que le pasemos:
-<sxh java>
-public class Cliente {
-    int id;
-    String nombre, CIF;
-    ...
-}
-</sxh>
-<sxh java>
-public class DocumentoPdf {
-    String path;
-    ...
-    public Cliente getClienteFromPdf(int id){
-        Cliente cliente = new Cliente();
-        ...
-        return cliente;
-    }
-    ...
-}
-</sxh>
-En nuestra clase principal, usamos esas clases para buscar el cliente con //id// = 2:
-<sxh java>
-public class Main {
-    public static void main(String[] args) {
-        DocumentoPdf documento = new DocumentoPdf();
-        Cliente cliente = documento.getClienteFromPdf(2);
-    }
-}
-</sxh>
-La aplicación funciona como toca y nos busca clientes en los //pdf// sin ningún problema. Al cabo del tiempo, sustituimos los documentos //pdf// por //json//. Tenemos que crear una nueva clase (//DocumentoJson//) con el método //getClienteFromJson()//:
-<sxh java>
-public class DocumentoJson {
-    String path;
-    public Cliente getClienteFromJson(int id){
-        Cliente cliente = new Cliente();
-        ...
-        return cliente;
-    }
-}
-</sxh>
-Además, tenemos que sustituir la llamada al método desde todas las clases donde lo hemos utilizado (en nuestro caso, solo está en nuestra clase //Main//):
-<sxh java>
-public class Main {
-    public static void main(String[] args) {
-        DocumentoJson documento = new DocumentoJson();
-        Cliente cliente = documento.getClienteFromJson(2);
-    }
-}
-</sxh>
-Imagínate si tuviésemos varias referencias al método. Nos tocaría buscar donde lo hemos utilizado y sustituirlos. Si después cambiamos a otro tipo de documentos o base de datos o cualquier otro tipo de persistencia, nos tocaría volver a hacer lo mismo, con el costo que conlleva.
-Vamos a hacer lo mismo, pero usando //interfaces//. Para eso, creamos una //interface// //Documento// con el método //getCliente()//:
-<sxh java>
-public interface Documento {
-    public Cliente getCliente(int id);
-}
-</sxh>
-En principio (igual que antes) leemos los clientes de documentos //pdf//. Para eso, creamos la clase //DocumentoPdf// que implementará la //interface// //Documento// (y su método //getCliente()//:
-<sxh java>
-public class DocumentoPdf implements Documento{
-    String path;
-    public Cliente getCliente(int id){
-        Cliente cliente = new Cliente();
-        //...
-        return cliente;
-    }
-}
-</sxh>
-En nuestra clase principal, usamos esas clases y métodos:
-<sxh java>
-public class Main {
-    public static void main(String[] args) {
-        Documento documento = new DocumentoPdf();
-        Cliente cliente = documento.getCliente(2);
-    }
-}
-</sxh>
-Date cuenta que estamos usando //polimorfismo// para definir el tipo de la variable //documento//. Lo definimos del tipo //Documento// (//interface//), no como una clase concreta.
-Si cambiamos y queremos usar documentos Json, creamos la nueva clase implementando de nuevo el //interface//:
-<sxh java>
-public class DocumentoJson implements Documento{
-    String path;
-    public Cliente getCliente(int id){
-        Cliente cliente = new Cliente();
-        //...
-        return cliente;
-    }
-}
-</sxh>
-Ahora, lo único que tenemos que cambiar es el tipo de documento en nuestra clase principal, pero el método no hace falta cambiarlo:
-<sxh java; highlight:[4]>
-public class Main {
-    public static void main(String[] args) {
-        Documento documento = new DocumentoJson();
-        Cliente cliente = documento.getCliente(2);
-    }
-}
-</sxh>
-Con este enfoque, desacoplamos las clases entre sí, permitiendo hacer cambios en unas sin que afecten a las otras.
-<note important>En nuestro ejemplo, seguimos teniendo que cambiar cosas en la clase principal (el tipo de documento). Existen mecanismos para reducir todavía más el acoplamiento entre clases, sin tener que definir el tipo de documento donde queremos buscar. En este curso no los veremos, pero en segundo usaremos uno de estos mecanismos: **inyección de dependencias**.</note>
-<note important>Nuestro ejemplo es muy sencillo, pero imagínate una aplicación grande con miles de líneas de código. Como hemos dicho, el uso de los //interfaces// es básico para desacoplar las diferentes capas de una aplicación entre sí. Aunque hasta segundo no veremos las diferentes arquitecturas (en capas, hexagonal...), deberías ir acostumbrándote a usar //interfaces// siempre que puedas, ya que te pueden solucionar muchos problemas en un futuro.</note>