Hola y bienvenidos a esta elección.
A continuación vamos a revisar el tema de manejo de interfaces en Java.
Están listos.
Vamos bien lo que vamos a trabajar en este ejercicio va a ser el siguiente diagrama de clases en el
cual vamos a crear un paquete de datos y en este paquete vamos a agregar una interface la interfaz se
va a llamar acceso a datos y posteriormente vamos a agregar dos clases concretas en este caso van a
ser dos clases que van a implementar la interface de acceso a datos llamada implementacion o Lackey
y otra clase concreta llamada implementacion Maisí.
Y por otro lado vamos a crear un paquete llamado manejo interfaces y la clase para poner a prueba estas
claves que hemos creado en el paquete de datos.
La clave se va a llamar manejo interfaces así que el diagrama de clases que vamos a desarrollar a continuación
bien como primer paso vamos a abrir nuestro aire vamos a cerrar cualquier proyecto que tengamos abierto
damos clic derecho choclos posteriormente vamos a crear un nuevo proyecto damos un Infinit Project y
ya la web Java Application y creamos el proyecto Manejo interfaces
y lo depositamos en la carpeta desde dos puntos de agonal inversa cursos diagonal inversa Java el nombre
de grupo oiría cm x con G.M de globalmente.
La versión 1.0 y dejamos el nombre del paquete vacío no hemos podido finalizar y como siguiente paso
vamos a crear una interface sobre esos paquetes.
Vamos a dar clic derecho NIU y en lugar de seleccionar Java class vamos a seleccionar Java Interface.
Así que damos clic sobre la interface y esta interfaz se va a llamar acceso a datos y la depositamos
en el paquete de datos y damos pueden finalizar.
Quitamos estos comentarios
y podemos observar que a diferencia de una clase en este caso en lugar de utilizar la palabra reservada
Class utiliza la palabra reservada interface y ahora vamos a continuar vamos a agregar la otra clase
damos clic derecho Nio.
En este caso si va a hacer una clase Java class se va a llamar implementacion ahora con el nombre del
paquete es igual el paquete de datos y damos clic en Finalizar
quitamos estos comentarios y esta clase de implementación Oracle va a implementar la interface acceso
a datos.
Para ello vamos a agregar lo siguiente agregamos implement acceso datos una clase en Java solamente
puede extender de una clase pero en Java puede extender de múltiples interfaces así que simplemente
poniendo una coma podríamos indicar que vamos a implementar múltiples interfaces pero en este caso solamente
vamos a implementar una interface y de momento va a ser todo el código que vamos a agregar posteriormente
vamos a agregar métodos a esta interface y esos métodos los vamos a implementar en estas clases que
implementan la interface de acceso a datos bien vamos a agregar la segunda clase sobre el paquete de
datos agregamos otra clase llamada implementacion Maisí.
El paquete de datos y damos clic en Finalizar
quitamos estos comentarios y de igual manera esta clase implementa la interface acceso datos.
Ahora vamos a empezar a modificar nuestra interface de acceso a datos una interface puede tener atributos
o métodos.
No es necesario que tenga ambos puede tener uno u otro y cualquier variable que agreguemos va a ser
una constante así que si definimos por ejemplo una variable de tipo entero llamada máx registros y la
asignamos por ejemplo el valor de 10 esto en automático va a ser una constante sin necesidad de especificarlo
en automático el compilador va a agregar públic Static a esta variable así que es opcional agregar esto
publica Static pero el compilador en automático va a ser esta variable una constante así que si no vemos
estos modificadores de todas maneras esta variable es una constante.
Por ello es que las deponiendo en mayúscula para indicar que es una constante
en este caso voy a dejar el código muy explícito pero ustedes ya saben que si no agregan este código
estos modificadores de acceso se agregan de manera automática esto solamente dentro de interfases y
como siguiente elemento de una interfase podemos tener métodos y esos métodos también en automático
se les agregan ciertas características ciertos modificadores.
En este caso los modificadores es públic y abstract así que los modificadores de públic y abstract se
agregan a todos los métodos que definamos en una interfase en este caso vamos a definir dos métodos
el método de insertar y el método de listar pero también debemos de saber que si no vemos los modificadores
de públic y abstract entonces en automático el compilador agrega Estos dos modificadores a estos métodos.
Por ello es que estos métodos no contienen un cuerpo únicamente terminan con punto y coma como los métodos
abstractos definidos en una clase abstracta es exactamente lo mismo ya que estos métodos también son
abstractos.
Esto quiere decir que las interfaces no van a agregar ningún comportamiento únicamente van a agregar
la firma del método y las clases que implementen a estas interfaces son las responsables de implementar
el comportamiento de estos métodos.
Vamos a agregar otro método
el método de listar no regresa nada y recordemos que si no agregamos públic y abstract de todas maneras
el compilador lo va a hacer de manera automática así que con eso estamos definiendo nuestra interfase.
Podemos se va que no tiene ningún comportamiento únicamente estamos definiendo una constante y los métodos
abstractos de insertar y listar bien.
Ahora vamos hacia la clase de implementación oracular en este caso podemos observar que el compilador
ya nos está marcando un error debido a que estamos indicando que vamos a implementar la interfase acceso
a datos.
Por lo tanto la clase de implementación Oricon está indicando que no es abstracta y que no está escribiendo
el método abstracto de listar ya que este método se ha definido en la interfase de acceso a datos y
por lo tanto estamos obligados a implementar los métodos definidos en la interfase.
Los métodos de insertar y de listar si no queremos implementarlos entonces tenemos que definir esta
clase como abstracta y podemos observar que si agregamos el modificador abstracto entonces esta clase
ya no marca ningún problema pero tampoco podríamos crear objetos de esta clase y tendría que ser otra
subclase de esta clase la que se tendría que encargar de definir finalmente el comportamiento de los
métodos definidos en la interfase acceso a datos bien pero en este caso si vamos a agregar la implementación
de los métodos definidos en la interfase así que vamos a hacer lo siguiente Si damos clic sobre el error
que nos está indicando podemos observar que el IDE nos está indicando que debemos de implementar todos
los métodos abstractos definidos en la interfase acceso a datos así que damos clic
y podemos observar que en automático nos agrega la implementación del método insertar y del método de
listar utilizando exactamente la misma firma del método definido en la interfase acceso datos y además
no se agrega la notación de overnight.
Sin embargo en este caso también cabe mencionar que es igual que las clases abstractas no es que estemos
escribiendo el comportamiento de la interfase ya que la interfase no ha agregado ningún comportamiento
por lo tanto es la primera vez que se está implementando el comportamiento del método insertar.
Por lo tanto el IDE nos está marcando que estamos implementando el método y no sobre escribiéndolo.
Sin embargo para el compilador es opcional agregar la notación de overnight o sobre escritura y por
default no se agrega el siguiente código en la cual se arroja una excepción que indica que este método
no está soportado aún.
Vamos a quitar estas líneas de código ya que nosotros vamos a agregar la implementación de estos métodos.
Obviamente este código también lo podemos agregar manualmente que básicamente es la implementación de
los métodos insertar y listar definidos en la interfase acceso datos.
Podemos observar que ya no tienen la palabra reservada abstract debido a que ya estamos implementando
el comportamiento de estos métodos iba a ser muy simple la implementación solamente vamos a mandar el
mensaje insertar desde Oracle
y también el método de listar tiene el mensaje listar desde ahora con el manejo de conexión a una base
de datos real lo vamos a ver en el nivel de Java con JDBC.
En este caso solamente estamos configurando el tema de interfaces pero este mismo código lo podemos
utilizar en el nivel de Java con JDBC en el cual si vamos a conectarnos a una base de datos real bien
con esto ya tenemos todo el código de nuestra clase implementación.
Vamos a hacer exactamente lo mismo en la clase de implementación de Maykel pero la implementación de
los métodos va a ser distinta damos clic para que implemente todos los métodos abstractos.
Quitamos este código y la implementación en este caso va a indicar
la implementación de este método va a ser insertar pero desde Maisí
o también el método del Istar va a ser listar desde.
Y con eso ya estamos agregando la implementación de los métodos definidos en la interfase tanto para
la implementación de Blackout como para la implementación de México.
Y aquí básicamente lo que estamos haciendo es cumplir con lo que se conoce como el contrato de la interfase
estamos definiendo dos métodos y las clases están implementando estos dos métodos pero cada una utilizando
su propia tecnología.
En este caso es un simple mensaje pero eso mismo que estamos haciendo es lo que hacen los manejadores
de bases de datos para implementar el API de Java con JDBC.
Esto simplemente por poner un ejemplo así que de esta manera cada proveedor de base de datos implementa
una interfase en la cual se define una cantidad de métodos y los proveedores de base de datos deben
de implementar esos métodos para sus propias bases de datos así que aunque este ejemplo es un ejemplo
sencillo realmente es lo que se utiliza en la vida real.
Obviamente lo que cambia simplemente es el código que implementa este método.
Por último vamos a poner en práctica estas dos clases sobre los paquetes vamos a crear una nueva clase
damos clic derecho Nioh Java class la clase se llama manejo interfaces y el paquete también se llama
manejo interfaces y damos siguen finalizar
agregamos un método main a esta clase de públiques nativo y Main y vamos a agregar el siguiente código
lo que vamos a hacer es que vamos a definir primero un tipo de la clase interface ya que cabe mencionar
que un tipo interface puede apuntar a objetos de clases que han implementado la interface es muy similar
al concepto de clases hijas.
Sin embargo en este caso la interfase no tiene clases fijas sino tiene clases que implementan la interface
así que en este caso la clase el tipo de dato de interfase acceso a datos puede apuntar a objetos de
tipo implementación Oracle debido a que esta clase implementa la interfase acceso a datos y lo mismo
con la clase de implementación.
Así que lo primero que hacemos es definir una variable de tipo acceso datos llamada datos y esta variable
va a apuntar a un objeto de tipo implementación Oracle
si esta clase de implementación Oracle no implementará la interface entonces esta variable de acceso
a datos de tipo interfase no podría apuntar a un objeto de este tipo de implementación Oracle vamos
a importar estas clases ponemos punto asterisco para que podamos utilizar todos los tipos del paquete
bien así que según lo que hemos comentado si esta clase de implementación Oracle no implementara la
interface entonces el compilador nos marca que son tipos incompatibles ya que no hay ninguna relación
entre el tipo de interface y la clase concreta implementación Oracle y tampoco podríamos decir que estamos
implementando el método de insertar tendríamos que quitar esta notación de overnight bien pero eso solamente
en caso de que esta clase no implementara la interface en este caso si la queremos implementar regresamos
el código y podemos ver que en este caso debido a que esta clase es simplemente la interface entonces
un tipo de acceso a datos del tipo interface puede apuntar a un objeto de tipo que implementa la interfaz
acceso datos y posiblemente con esta variable podemos ejecutar los métodos insertar o listar definidos
en la interfase pero implementados en la clase de implementación Oracle así que abordamos cambios y
ejecutamos
y podemos ver que de esta manera no llamar el método insertar pero desde ahora ya que estamos utilizando
la clase implementación Oracle y ahora vamos a hacer algo similar pero utilizando la otra implementación.
Así que vamos a utilizar la misma variable de tipo acceso datos de tipo interface pero le vamos a asignar
un objeto
de tipo implementación Maisí cual viene con esto ya estamos apuntando con la variable acceso a datos
a un objeto de tipo implementación Maisí cual podemos mandar a llamar los mismos métodos y aquí podemos
observar que estamos cumpliendo con el contrato de definido en la interfase así que sin importar la
implementación que estemos utilizando de Oracle o de Meucci tenemos acceso exactamente a los mismos
métodos.
Así que en este caso podemos mandar a llamar el método insertar de nueva cuenta pero la implementación
que se va a ejecutar en este caso en este segundo caso es la implementación de Maisí.
Así que guardamos cambios y ejecutamos y podemos observar que dependiendo del objeto al cual esté apuntando
es el método que se va a ejecutar ya sea la implementación de Oracle o la de Maisí cual y simplemente
para comprobar.
También podemos mandar a llamar el método de listar en este caso esta variable de datos ya está apuntando
a la implementación de Maisí
por lo tanto el método que deberían ejecutar es listar pero desde Maisí puede así que básicamente con
esto estamos cumpliendo con el contrato definido en la interfase es decir con el listado de métodos
que se han definido y cada una de estas clases implementa estos métodos
ahora por último si queremos acceder a la constante que hemos definido en la interfase que los atributos
marcados como estáticos son constantes.
Por lo tanto vamos a utilizar directamente el nombre de la interface así que ponemos acceso a datos
y con esto podemos acceder a la constante que hemos definido Max registros
y mandamos a imprimir esta constante
guardamos cambios y ejecutamos y Podemos se va que nos muestra el valor de 10 el valor que hemos definido
en esta constante y aunque es de tipo públic si tratamos de modificarlo
si tratamos de asignarle algún valor podemos observar que ya no podemos modificar el valor debido a
que esta variable está marcada como final incluso si quitamos esos modificadores de acceso públic static.
De hecho aquí me faltó también el modificador de acceso final ya que esto es una constante así que cualquier
atributo que definamos en una interface va a ser de tipo Public Static final se van a agregar esos tres
modificadores de manera automática y aunque no lo hayamos definido en automático podemos observar el
mensaje que nos manda que no podemos modificar el valor a una variable final así que este código no
se puede ejecutar y si el atributo no fuera público tampoco podríamos acceder directamente con el nombre
de la clase.
De igual manera si no fuera estático no podríamos acceder directamente con el nombre de la clase y finalmente
si no fuera final entonces podríamos modificar su valor pero con eso estamos comprobando que los atributos
son públic Static y final.
Los atributos definidos en una interface y nos muestran el valor del atributo más registros
bien así que agregamos los modificadores Public Static y final a quién le ha faltado feina pero con
esto ya lo estamos agregando son los modificadores que se agregan a los atributos definidos en una interface.
Realmente son constantes y con eso terminamos el ejercicio de manejo de interfaces.
El uso de interfaces vamos a seguir utilizando en niveles posteriores pero eso simplemente es la base
para que puedan comenzar a trabajar ese tipo de conceptos bien nos vemos en la siguiente elección.
Saludos.