viernes, 22 de mayo de 2020

Interfaces

Es un tipo de referencia que está estrechamente relacionado con una clase al tener múltiples similitudes con estas.

Definir una interfaz es muy parecido a definir una clase abstracta:

 
/* se usa la palabra reservada "interface" */
public interface InterfazDeJava{

}


Cuando define una interfaz se crea una referencia similar a una clase con la principal diferencia en que no define ninguna implementación de sus métodos. Además, presenta las siguientes características o restricciones.

  • Una interfaz no puede ser instanciada, por lo que no se define un constructor.
  • Los únicos campos permitidos en una definición de interfaz son constantes que se declaran tanto estáticas como finales.
  • Una interfaz define una API pública. Todos los métodos de una interfaz son implícitamente públicos, incluso si se omite el modificador público. Es un error definir un método protegido o privado en una interfaz.
  • Una interfaz no contiene implementación alguna. Todos los métodos de una interfaz son implícitamente abstractos, incluso si se omite el modificador abstracto.
  • Las interfaces pueden heredar de otras interfaces y pueden soportar herencia múltiple.
  • Son las clases que al implementar una interfaz mediante la palabra reservada "implements" implementan el código de los métodos declarados en una interfaz.
  • Una interfaz puede ser implementada en múltiples clases y una clase puede implementar múltiples interfaces.

Ejemplo de interfaz y su implementación en código

Código de la interfaz:

 public interface Calculadora {

 Float sumar(Float a, Float b);

 Float restar(Float a, Float b);

 Float multiplicar(Float a, Float b);

 Float dividir(Float a, Float b);

 String getMensaje();
}



Código de la clase:

 public class CalculadoraDecimal implements Calculadora {

 private String mensaje;

 public CalculadoraDecimal() {
 }

 @Override
 public Float sumar(Float a, Float b) {
  mensaje = null;
  return a + b;
 }

 @Override
 public Float restar(Float a, Float b) {
  mensaje = null;
  return a + b;
 }

 @Override
 public Float multiplicar(Float a, Float b) {
  mensaje = null;
  return a + b;
 }

 @Override
 public Float dividir(Float a, Float b) {
  if (b == 0) {
   mensaje = "No se puede dividir entre cero";
   return null;
  } else {
   mensaje = null;
   return a / b;
  }
 }

 @Override
 public String getMensaje() {
  return mensaje;
 }

}

Herencia en interfaces

Como se ha mencionado, las interfaces pueden heredar de otras interfaces sus métodos y constantes. Aquí las superinterfaces (similar a las superclases) deben colocarse luego de la palabra reservada "extends"

Herencia simple:


 
/* se usa la palabra reservada "extends " */
public interface InterfazHija extends InterfazPadre{

}

Herencia múltiple:


 
/* se usa la palabra reservada "extends " */
public interface InterfazHija extends InterfazPadre1, InterfazPadre2{

}


Fuentes:

  • Flanagan, D. (2002). JAVA IN A NUTSHELL Desktop Quick Reference (4a ed.). England: Pearson Education.


jueves, 21 de mayo de 2020

Patrón de diseño Facade

Este es un patrón de diseño orientado a la simplificación de los entornos de programación mediante la división del programa en módulo, reduciendo la dependencia que tienen entre ellos al crear un módulo especial llamado Facade (fachada) con el cual interactúa el cliente.

Su aplicación se puede realizar en los siguientes casos

  • Tener una interfaz simple para un subsistema complejo
  • Estructurar varios subsistemas en capas, ya que las fachadas serían el punto de entrada a cada nivel.
  • Desacoplar un sistema de sus clientes y de otros subsistemas, reduciendo dependencias entre los subsistemas y los clientes.


Fachada (Facade): utiliza a los módulos para llevar a cabo las diversas operaciones que el cliente solicita, de manera que el cliente desconoce la complejidad de todo el programa y solo se centra en este.

Subclases (Los módulos): son los que implementan las diferentes funcionalidades del programa. La fachada es quién los invoca. Lo más importante es que no dependen de la fachada, la creación o desaparición de esta no debe afectarlos en absoluto.



Ejemplo con Java

Supongamos que creamos un programa que permite registrar y mostrar licencias de conducir pidiendo el DNI, tipo y categoría. Además, la mayor cantidad de registros son de licencias A1. Entonces podemos emplear el patrón Facade de la siguiente forma


Tenemos una clase llamada "Licencias" que almacena los valores mencionados y un método para visualizar el registro.
package entidades;

public class Licencias {
 private String dni; 
 private String categoria;
 private String tipo;
 
 public Licencias() {
 }

 public String getDni() {
  return dni;
 }

 public void setDni(String dni) {
  this.dni = dni;
 }

 public String getCategoria() {
  return categoria;
 }

 public void setCategoria(String categoria) {
  this.categoria = categoria;
 }

 public String getTipo() {
  return tipo;
 }

 public void setTipo(String tipo) {
  this.tipo = tipo;
 }
 
 public String verDetalle() {
  return String.format("DNI: %s\nLicencia: %s%s", 
    dni,categoria,tipo);
 }
 
}


Creamos la fachada para el caso más usual que serían las licencias A1
package facade;

import entidades.Licencias;

public class CatA1Facade {

 private Licencias licenciaA1;
 
 public CatA1Facade(String dni) {
  licenciaA1 = new Licencias();
  licenciaA1.setDni(dni);
  licenciaA1.setCategoria("A");
  licenciaA1.setTipo("I");
 }
 
 public String verDetalle() {
  return licenciaA1.verDetalle();
 }
}


Creamos la un registro A1 sin aplicar Facade y luego uno aplicándolo.
package test;

import entidades.Licencias;
import facade.CatA1Facade;

public class Ejecutor {

 public static void main(String[] args) {

  // Sin Facade
  Licencias licenciaA1 = new Licencias();
  licenciaA1.setDni("70686223");
  licenciaA1.setCategoria("A");
  licenciaA1.setTipo("I");
  System.out.println(licenciaA1.verDetalle());
  
  // Con Facade
  CatA1Facade a1Facade = new CatA1Facade("78465521");
  System.out.println(a1Facade.verDetalle());  
 }
}

Estructura del proyecto:

Se puede apreciar que existe una simplicidad en la generación de estos al evitar repetir código.

sábado, 16 de mayo de 2020

Java Standard Tag Library

JSTL es la biblioteca de etiquetas estándar de Java, que darán soporte a los JSP y es uno de los componentes de JAVA EE.

Su utilizad radica en que permite la creación de páginas web dinámicas de forma más eficiente que si no se les usara. Además,  aprovecha el "request", donde almacena variables, datos, etc. para dar soporte a la página JSP desde un servlet.

Cuenta con 6 bibliotecas que la componen:
  • core, iteraciones, condicionales, manipulación de URL y otras funciones generales.
  • biblioteca de funciones
  • xml, para la manipulación de XML y para XML-Transformation.
  • sql, para gestionar conexiones a bases de datos.
  • TLV
  • fmt, para la internacionalización y formateo de las cadenas de caracteres como cifras.

Para agregar esta biblioteca a un proyecto web en Netbeans se sigue los siguientes pasos:

Primero se debe agregar una nueva biblioteca:

Luego seleccionar JSTL y agregar

Dentro de los archivos JSP podemos emplear la paleta que provee Netbeans. Para ello, se hace los siguiente

Aparecerá una barra lateral donde se debe ubicar los siguiente


JSTL CORE


<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>JSTL - JavaJhon</title>        
    </head>
    <body>
        <strong>Usando JSTL IF</strong>
        <!--Suponemos que hemos capturado o recibido un valor 
        numérico y lo almacenamos en una variable "nota", luego 
        realizamos una comparación con otro valor.-->
        <% Double nota = 20d;%>
        <c:if test="<%= nota>11.5d %>">
            <p>Felicidades ustes ha aprobado con nota: <%= nota%></p>
        </c:if>
        <hr/>
        <br/>        
        <strong>Usando JSTL CHOOSE</strong>
        <!--Suponemos que hemos capturado o recibido un valor 
        numérico y lo almacenamos en una variable "dia", luego 
        realizamos una comparación con otros valores.-->
        <% Integer dia = 6;%>
        <c:choose>
            <c:when test="<%= dia== 1%>">
                <p>Es lunes</p>
            </c:when>
            <c:when test="<%= dia== 2%>">
                <p>Es martes</p>
            </c:when>
            <c:when test="<%= dia== 3%>">
                <p>Es miércoles</p>
            </c:when>
            <c:when test="<%= dia== 4%>">
                <p>Es jueves</p>
            </c:when>
            <c:when test="<%= dia== 5%>">
                <p>Es viernes</p>
            </c:when>
            <c:when test="<%= dia== 6%>">
                <p>Es sábado</p>
            </c:when>
            <c:when test="<%= dia== 7%>">
                <p>Es domingo</p>
            </c:when>
            <c:otherwise>
                <p>Valor erróneo</p>
            </c:otherwise>
        </c:choose>        
        <hr/>
        <br/>
        <strong>Usando JSTL FOR</strong><br/>
        <!--Suponemos que hemos capturado o recibido un valor 
        numérico y lo almacenamos en una variable "n", luego 
        creamos una lista desplegable con valores del 1 a "n"-->
        <% Integer n = 12;%>
        <select>
            <c:forEach var="i" begin="1" end="<%= n %>">
                    <option value="${i}">Item ${i}</option>
            </c:forEach>   
        </select>     
        <hr/>
        <br/>
    </body>
</html>

Obtendremos el siguiente resultado:


Usando JSTL IF
Felicidades ustes ha aprobado con nota: 20.0


Usando JSTL CHOOSE
Es sábado


Usando JSTL FOR



Patrón de diseño de Software MVC

El patrón Modelo Vista Controlador

El patrón MVC nos permite separar:
  • La lógica de control (las funcionalidades del proyecto)
  • La lógica de negocio (como se llevarán a cabo esas funcionalidades)
  • La lógica de presentación (cómo interactúa el usuario con el proyecto)

Utilizando patrón de separación en capas es posible conseguir:
  • Mayor calidad en el producto a desarrollar.
  • Un mantenimiento más sencillo y por ende menos costoso (recordemos que es la etapa del ciclo de vida más costosa).
  • Partir de un modelo base. 
  • Normalizar y estandarizar el desarrollo de Software.

Esto es gracias a que:
  • Existe una bien marcada separación entre los componentes (capas) de un programa; lo cual permite implementar estos por separado.
  • Existen varios Frameworks como JSF, Spring MVC, etc. que permiten reemplazar el modelo, la vista o el controlador, sin demasiada dificultad. Incluso sin un Framework es relativamente sencillo cambiar uno de los componentes del MVC sin afectar a los demás.
  • La conexión entre la capa de modelo y la capa que contiene las vistas es dinámica, pues se produce en tiempo de ejecución, no de compilación.

Ejemplo de aplicación con JAVA Web

En el lenguaje Java, específicamente un proyecto web dinámico tendríamos las siguientes consideraciones.
  • Model: el lenguaje SQL impera sobre el java.
  • Controller: el lenguaje java impera
  • View: el lenguaje HTML impera


La capa de la vista: La capa de persistencia (modelo) La capa de control

 
 


Adicionalmente tenemos:
Bibliotecas externas Bibliotecas internas Clases o entidades

 
 

martes, 12 de mayo de 2020

Instalando Payara Server con Eclipse IDE

Oracle detuvo el soporte comercial para GlassFish hace unos años, en respuesta la comunidad libre al mismo estilo de MariaBD con MySQL creo Payara, que es un servidor de aplicaciones Java EE de código abierto que se bifurcó en 2014. De esta manera, las compañías que anteriormente usaban GlassFish comercialmente podrían cambiar sin esfuerzo a Payara y continuar disfrutando del soporte comercial. Gracias al soporte comercial para clientes comerciales que anteriormente usaban GlassFish, el software del servidor de aplicaciones Payara se puede corregir y mejorar continuamente.

Descargar Payara Server

Ingresar a su página web: https://www.payara.fish/  y buscar la sección de descargas donde se debe elegir la opción de Payara Server Full, lo bueno es que es gratis.

Se obtendrá un archivo comprimido .zip que se debe descomprimir en el disco. Eso es todo.

Pasos para configurar en Eclipse

Desde el Marketplace de Eclipse descargamos e instalamos el GlassFish Tool o Payara Tool, con ambos se puede realizar la configuración. En este caso se emplea la segunda opción, el proceso es prácticamente el mismo.



Se crea un nuevo servidor siguiendo esta secuencia



Se selecciona la opción Server



En la selección se marca Payara, si usan el GlassFish Tool se debe ubicar en Oracle. Colocar un nombre, en este caso Payara5



Ingresar la ubicación donde está descomprimido el archivo descargado.



Verificar los siguientes datos, no es necesario realizar cambios, darle clic a finalizar.



En la pestaña de Servers se puede ubicar el nuevo servidor, para iniciarlo solo le damos clic derecho y la opción Start o Iniciar.



El servidor se iniciará



Para probar un proyecto se debe ejecutar en un servidor como se indica a continuación:


Si todo fue correctamente instalado y configurado se iniciará en el navegador el proyecto

Fuentes:

  • Schotlz, B. y Tijms, A. (2018). The Definitive Guide to JSF in Java EE 8:Building Web Applications with JavaServer Faces. United States of America: Apress.


viernes, 1 de mayo de 2020

Polimorfismo

Dentro de las características del paradigma de la programación orientada a objetos una de ellas es el polimorfismo.

Dentro de JAVA esta característica permite que un objeto interactúe de forma diferente en relación de los parámetros con los que un método es invocado o mediante especialización de un método que es heredado, de ahí la estrecha relación entre el polimorfismo y la herencia.


Polimorfismo por parámetros

Se produce cuando existen funciones con el mismo identificador en una misma clase donde se diferencian por la cantidad y/o nombre de parámetros

package entidades;

public class Calculadora{
 
 public Calculadora(){
  //Constructor
 }
 
 public Double procesar(Double a){
  return a*2;
 }
 
 public Double procesar(Double a, Double b){
  return a*b;
 }
 
 public Double procesar(Double a, Double b, Double c){
  return a+b+c;
 } 
}


Polimorfismo por inclusión

Se produce mediante el uso de interfaces, de forma que las clases especializadas desconocen la implementación de las funciones entre ellas.

package entidades;

public abstract class AbstractCalculadora{ 
 public Double procesar(); 
}


package entidades;

public class Calculadora extends AbstractCalculadora{ 
 private Double a;
 private Double b;
 private Double c;
 
 public Calculadora(Double a, Double b, Double c){
  this.a=a;
  this.b=b;
  this.c=c;  
 }
 
 @Override
 public Double procesar(){
  return a+b+c;
 }
}


Fuentes:

  • Flanagan, D. (2002). JAVA IN A NUTSHELL Desktop Quick Reference (4a ed.). England: Pearson Education.


Clases y métodos abstractos

Método abstracto

Java nos permite definir un método sin implementarlo declarando el método con el modificador abstracto. Un método abstracto no tiene cuerpo; simplemente tiene una definición de firma seguida de un punto y coma.

// Ejemplo de método abstracto
public abstract String saludo();


Clase abstracta

Una clase abstracta es aquella cuya implementación es incompleta y no puede ser instanciada. Cualquier clase con uno o más métodos abstractos debe declararse abstracta.

// Ejemplo de clase abstracta

public abstract class SerVivo{
   //Atributos

   //Métodos

}


Consideraciones

  • Cualquier clase con un método abstracto se abstrae automáticamente y debe declararse como tal.
  • La clase abstracta no puede ser instanciada.
  • Una subclase de una clase abstracta se puede instanciar solo si invoca a cada uno de los métodos abstractos de su superclase y proporciona una implementación para todos ellos. Dicha clase a menudo se denomina subclase concreta, para enfatizar el hecho de que no es abstracta.
  • Si una subclase de una clase abstracta no implementa todos los métodos abstractos que hereda, esa subclase es en sí misma abstracta.
  • Los métodos estáticos, privados y finales no pueden ser abstractos, ya que estos tipos de métodos no pueden ser anulados por una subclase. Del mismo modo, una clase final no puede contener ningún método abstracto.
  • Una clase puede declararse abstracta incluso si en realidad no tiene ningún método abstracto. Declarar dicho resumen de clase indica que la implementación está de alguna manera incompleta y está destinada a servir como una superclase para una o más subclases que completarán la implementación. Tal clase no puede ser instanciada.


Ejemplo en código

Se creó dos clases, una abstracta llamada "Figura" y otra común llamada "Cuadrado", la primera tiene dos métodos abstractos y es la superclase de la segunda, esto implica que los dos métodos se deben implementar en la clase hija o subclase.
package entidades;

public abstract class Figura {
 
 public abstract Double area();
 public abstract Double perimetro();

}


package entidades;

public class Cuadrado extends Figura{
 private Double lado;
 
 public Cuadrado(Double lado) {
  super();
  this.lado = lado;
 }

 @Override
 public Double area() {
  return Math.pow(lado, 2);
 }

 @Override
 public Double perimetro() {  
  return 4*lado;
 }

 public Double getLado() {
  return lado;
 }

 public void setLado(Double lado) {
  this.lado = lado;
 } 
 
}

package test;

import entidades.Cuadrado;

public class Ejecutor {
 public static void main(String[] args) {
  Cuadrado cuadrado = new Cuadrado(3d);
  System.out.println("Medida del lado: " + cuadrado.getLado().toString());
  System.out.println("Área: " + cuadrado.area().toString());
  System.out.println("Perímetro: " + cuadrado.perimetro().toString());
 }
}

Salida:

Medida del lado: 3.0
Área: 9.0
Perímetro: 12.0

Esquema del proyecto:



Fuentes:

  • Flanagan, D. (2002). JAVA IN A NUTSHELL Desktop Quick Reference (4a ed.). England: Pearson Education.