Aquí te dejo varios ejercicios con Clases en Java, para que puedas practicar lo aprendido en post anteriores. No explico la solución, sencillamente muestro una posible solución, pero mi recomendación es que intentes hacer los ejercicios sin mirar mi solución, y que la consultes sólo si te atascas.
Ejercicio 1
Crea una clase llamada Pais.
La clase debe tener los siguientes parámetros (recuerda que los parámetros deben ser declarados como privados por cuestiones de seguridad):
El polimorfismo hace referencia a la capacidad de que objetos de diferentes clases, respondan de manera diferente a un mismo método. En Java, esto se consigue mediante la herencia y las interfaces, posibilitando que distintas clases implementen un mismo método de formas distintas, ajustándolo a sus necesidades.
En el polimorfismo por herencia, las distintas subclases implementan un método de la superclase de distintas maneras, ajustándolo a las necesidades específicas de la subclase en cuestión.
Actividad: Practicando con el polimorfismo
Abrimos un nuevo proyecto de Java en nuestro IDE de trabajo.
Primero definimos la superclase: Animal
class Animal{
public void comer() {
System.out.println("El animal se alimenta");
}
}
Las Clases abstractas y los interfaces son mecanismos que nos ayudan a definir estructuras abstractas, que son especificadas en las clases que las implementan de acuerdo a sus necesidades. Esto habilita al programador de Java a definir un grado de abstracción en sus desarrollos, posibilitando una programación más estructurada y modular, favoreciendo la reutilización del código.
Clases abstractas
Las Clases abstractas nos permiten un mayor nivel de abstracción al definir la estructura de los objetos de nuestro programa. Podemos indicar solamente que comportamiento hay que definir, pero no indicar como. En la práctica esto se traduce en declarar un método, pero no implementarlo. Esto lo indicamos empleando el modificador abstract, que se incluirá tanto en la firma del método como de la Clase que lo contiene.
Ya hemos visto como en Big Data manejamos una gran cantidad de datos que se generan de manera constante a gran velocidad. Datos que además provienen de distintas fuentes, con distintas estructuras, organizadas de distintas maneras. La curación de datos es la actividad por la que organizamos todos estos datos de la misma manera, dejándolos preparados para su posterior análisis y extracción de información.
Curado de datos
Procesos ETL
Cuando nos planteamos el tratamiento de los datos, nos vemos en la necesidad de definir algún tipo de metodología que nos ayude a estructurar el trabajo y evite que nos perdamos entre tanto dato. Estos son los procesos ETL, del inglés: E: extract, T: transform y L: load.
Los nombres de las fases de este proceso ya nos dan una ligera idea de la acción a realizar en cada una de ellas. En cualquier caso, veámoslas con un poco más de detalle.
Extract (Extracción)
El proceso de extracción consiste en ir a las distintas fuentes que manejemos y traernos los datos. Normalmente manejaremos varias fuentes, que además tendrán distintas estructuras.
La calidad de las fuentes también será diferente, por lo que al capturar los datos, realizaremos una serie de comprobaciones sobre los mismos.
Estas fuentes suelen tener una documentación explicativa de la estructura de datos, un fichero que normalmente podremos encontrar con el nombre “Readme” o similar. Básicamente, comprobaremos que cumplen con un conjunto de pautas definidas en dicha documentación, desechando aquellos datos que no cumplan.
Transform (Transformación)
He comentado antes que las distintas fuentes de datos pueden tener distintas estructuras. Para poder tratar conjuntamente los datos de todas las fuentes, tendremos que adaptarlos a una misma estructura de datos final. La etapa de transformación es la que se ocupa de este cometido.
Pongo un ejemplo, para que se entienda mejor. Imaginemos que estamos recopilando datos de posibles votantes en las elecciones presidenciales de EEUU, queremos hacernos una lista de emails para enviarles nuestro programa. Resulta que los datos que obtenemos de la fuente 1, tienen los campos: [nombre] , [primer apellido], [segundo apellido] y [email]. Mientras que los datos de la fuente 2 tienen: [nombre], [apellidos] y [email]. Y en nuestra estructura final, queremos tener sencillamente dos campos: [nombre y apellidos] y [email]. Tendremos que transformar los datos de ambas fuentes a la estructura final que nos interesa.
Load (Carga)
Finalmente, almacenamos los datos en alguna Base de Datos o repositorio, con la estructura final que definimos. De esta forma, tendremos todos los datos curados y transformados a la misma estructura. Listos para poder trabajar con ellos.
Este almacenamiento deberá cumplir con todos los estándares de seguridad e integrad de los datos. Copias de respaldo, gestión de permisos de acceso, etc.
Herramientas ETL
Existen varias herramientas que ayudan a implementar los procesos ETL. Normalmente, las vamos a encontrar agrupadas en tres categorías:
Herramientas de empresa: Son los desarrollos comerciales que compran las empresas. Y algunos ejemplos son: Oracle Data Integrator, SAP Data Services, IBM Infosphere DataStage o Microsoft SQL Server Integration Services.
Open Source: Son los productos de código abierto. Y entre ellos podemos encontrar: Pentaho Data Integration o Talend Open Studio.
Cloud: Aquí agrupamos las soluciones que proveen los servicios en la nube. Y entre ellas podemos destacar: Amazon AWS Glue, Microsoft Azure Data Factory o Google Cloud Dataflow.
Para empezar a practicar, y hacerte una idea de como funcionan estas herramientas, mi recomendación es que pruebes con Pentaho Data Integration. Es posible que la encuentres como Kettle, pues así era denominada anteriormente.
Formatos de datos más habituales
Los datos, los vamos a encontrar disponibles en varios formatos. Los más habituales son estándares abiertos de entre los que yo destacaría : CSV, JSON y XML.
CSV (Comma Separated Values)
Simplemente leyendo el nombre de este formato, no hay que ser un fiera para imaginar que en CSV, los datos los tendremos separados por comas.
Vamos a disponer de una primera línea o cabecera, con los títulos de los datos separados por comas. Sería algo así como los nombres de los campos de una tabla. Y luego, el resto de líneas, son los datos propiamente dichos, separados por comas.
Un ejemplo podría ser el siguiente:
Ejemplo de formato csv
Echando un vistazo al formato CSV, se hace evidente asimilarlo a las bases de datos relacionales. La primera línea sería la lista de los nombres de los campos, y el resto de las líneas seria cada una un registro, con los valores para en cada campo, separados por comas.
Si lo que queremos es capturar los datos de una base de datos relacional, la elección más obvia es usar CSV como formato para el intercambio de datos. Sencillamente, guardaríamos cada tabla con todos sus datos, siguiendo el esquema de arriba.
JSON (JavaScript Object Notation)
Este formato de intercambio de datos, nos permite trabajar con estructuras más complejas que con CSV. Admite dos tipos de estructuras básicas: parejas nombre-valor y listas de valores, estructuras de datos ampliamente usadas en programación: Objetos, arrays, etc.
Internet está repleto de ejemplos de JSON, aquí te reproduzco uno cualquiera, con la idea de que te hagas una idea de la apariencia de estos formatos:
Ejemplo fichero JSON
Seguro que si has programado con un lenguaje de programación orientado a objetos, esta estructura de datos te habrá resultado familiar. JSON lo vamos a utilizar mucho cuando estemos compartiendo y capturando datos directamente de una aplicación o de bases de datos NO relacionales.
XML (Extended Markup Language)
Es un lenguaje de marcado, por lo que vamos a trabajar con etiquetas. Abriremos una etiqueta, pondremos un valor y cerraremos la etiqueta. Por supuesto, podemos complicar la estructura anidando todas las etiquetas que queramos.
Aquí os dejo un ejemplo de XML para que podáis haceros una idea de su apariencia:
Ejemplo de fichero XML
Recuerda bastante a html, por su uso de etiquetas. No obstante, no es tan usado para guardar datos en fuentes abiertas, sino que se emplea fundamentalmente para intercambiar datos entre programas.
NOTA:
Este post es parte de la colección “Entornos Big Data”. Puedes ver el índice de esta colección aquí.
Antes de introducirnos en los entornos Big Data, tenemos que dar respuesta a la pregunta ¿Qué es Big Data?
El término Big Data está de moda, podríamos traducirlo por “flujo de datos masivos” y viene a representar el aumento exponencial de los datos que generamos, almacenamos y manejamos. Estos datos se han convertido en un activo muy valioso para las compañías, que se encuentran con el reto de saber gestionarlos y convertirlos en información útil para el negocio, para ayudar a la toma de decisión en tiempo real. De ahí la manida expresión de los datos son el petróleo del futuro.
Durante los últimos tiempos, esta cantidad de datos ha crecido significativamente, hasta el punto de que los sistemas de gestión de datos tradicionales no dan una respuesta satisfactoria a esta nueva realidad. Y cuando hablo de sistemas tradicionales, me refiero fundamentalmente a las bases de datos relacionales.
Seguramente, habréis escuchado en alguna ocasión, que un Smartphone tiene más capacidad de almacenamiento y computación de la que dispuso la NASA para colocar al hombre en la luna y traerlo de vuelta sano y salvo. Lo cierto es actualmente, en un día, enviamos más de 250 mil millones de correos, realizamos más de 6 mil millones de búsquedas en Google, casi 7 mil millones de reproducciones de videos en YouTube o más de 700 millones de tweets diarios.
En apartados anteriores, habíamos visto como las bases de datos relacionales supusieron la solución para el problema de redundancia que surgía cuando usábamos los ficheros planos para almacenar los datos. No obstante, las bases de datos relacionales presentaban otros problemas, y no tardaron en surgir otras alternativas de bases de datos que organizaban los datos de forma diferente, y que son conocidas en su conjunto como bases de datos no relacionales. En este post, recorreremos estas bases de datos, describiendo brevemente los distintos tipos y explicando como estructuran los datos para su almacenamiento.
La rigidez de las bases de datos relacionales
Al abandonar los ficheros planos y empezar a usar las bases de datos relacionales, solucionamos el problema de redundancia. Ya no teníamos que repetir datos en varias filas y además reducíamos sensiblemente el número de errores en la introducción de los datos, lo que obviamente redundaba en una notable mejora de la calidad de los mismos.
Tras aprender a definir la estructura de la base de datos y a cargar, borrar o actualizar, los datos en las tablas, nos queda aprender como consultar los datos. Esto lo haremos con los comandos SQL para la recuperación de datos, las conocidas como consultas de selección, donde el comando SELECT resulta fundamental.
La sintaxis básica es:
SELECT [ALL | DISTINCT] <lista de campos> FROM <lista de tablas>
[WHERE ….]
[GROUP BY…]
[HAVING….]
[ORDER BY…]
En este post vamos a estudiar los principales comandos SQL para modificar los datos de las tablas de nuestra base de datos. Básicamente tenemos tres comandos para realizar las tres operaciones básicas:
INSERT INTO
Escribir un dato nuevo.
Sintaxis:
INSERT INTO <Tabla> [(campo1,campo2…..)]
VALUES (valor1, valor2, …)
La instrucción debe tener tantos valores como campos se pretenden rellenar y dichos valores deben ser del tipo que almacena el campo destino. En caso de no ser compatible el tipo de dato que queremos almacenar con el tipo del campo destino, se produciría un error y no se completaría la escritura de los datos.
UPDATE
Modificar el valor de un dato: Hay que indicar la tabla y los campos que se quieren actualizar. También podemos indicar un criterio que deben de cumplir los registros para que se produzca la actualización, pero esto es opcional.
Sintaxis
UPDATE tabla
SET campo1 = valor1, campo2 = valor 2,…
WHERE <criterio>
DELETE
Borrar un dato: Con esta instrucción, eliminamos los registros de la tabla indicada tras el comando FROM, y que cumplan los criterios definidos tras el comando WHERE
Sintaxis
DELETE FROM tabla
WHERE <criterios>
Y para practicar estos comandos, realizaremos el ejercicio siguiente:
Ejemplo: Manipulación de datos con SQL
Partimos de la BBDD ProveedoresSQL, que creamos en el post anterior. En ella ya tenemos creadas las dos tablas con las que de momento estamos funcionando: Proveedores y Productos. Pero estas están vacías, todavía no hemos cargado ningún dato.
Paso 1: Sentencias SQL para la carga de datos en la tabla proveedores.
Pongamos que primero vamos a cargar los datos en la Tabla proveedores. Las tres primeras sentencias para cargar los tres primeros registros serían:
INSERT INTO Proveedores (idProveedor, NombreProveedor, ContactoProveedor, Telefono) VALUES(1,"Arroces La Cigala","Maria Alvarez","677889922");
INSERT INTO Proveedores (idProveedor, NombreProveedor, ContactoProveedor, Telefono) VALUES(2,"Arroces La Cigala","Maria Alvarez","677889924");
INSERT INTO Proveedores (idProveedor, NombreProveedor, ContactoProveedor, Telefono) VALUES(3,"Azucarera Sevillana","Rodrigo Mendez","622525885");
En el módulo que creamos en el ejercicio anterior, y que bautizamos con el nombre “PracticasConSQL”, creamos el siguiente procedimiento para ejecutar estas sentencias SQL:
Estas sentencias SQL, al ser sentencias de modificación de datos que no afectan a la estructura de la BBDD, podríamos haberla ejecutado desde la vistaSQL en el interfaz de Access. No obstante, vemos como hacerlo por código en VBA, por si tuviéramos muchos datos y tuviéramos que leerlos de un fichero.
Paso 2: Borrando registros erroneos
Inmediatamente después de la carga nos damos cuenta que el segundo registro en realidad está duplicado, tenía el campo del Teléfono mal. Decidimos eliminar el registro completo, lo cual hacemos ejecutando la siguiente sentencia SQL:
DELETE Proveedores.idProveedor, Proveedores.NombreProveedor, Proveedores.ContactoProveedor, Proveedores.Telefono
FROM Proveedores
WHERE (Proveedores.idProveedor=2);
En esta ocasión, lo hacemos desde la vistaSQL de Access.
Paso 3: Actualizando datos
Ya hemos visto como cargar un registro nuevo en una tabla y como borrarlo completamente, nos queda aprender a actualizar el valor de un campo, sin afectar al resto del registro.
Supongamos que Rodrigo Mendez, el contacto de Azucarera Sevillana nos llama para decirnos que ha cambiado el teléfono, que su nuevo numero es 698527414.
Tendríamos que actualizar el número de teléfono de este contacto, para lo que podemos usar la siguiente sentencia SQL:
UPDATE Proveedores SET Proveedores.Telefono = "698527414"
WHERE (Proveedores.ContactoProveedor="Rodrigo Mendez");
Si ejecutamos ahora esta sentencia SQL, veremos como se nos actualiza el valor del teléfono de Rodrigo Mendez. He establecido la condición por el nombre del contacto, pero podía haberlo hecho por el número de registro (el 3).
NOTA:
Este post es parte de la colección “Sistemas de acceso y almacenamiento de datos”. Puedes ver el índice de esta colección aquí.
SQL significa Structured Query Language, que puede ser traducido como lenguaje de consultas estructuradas. Luego se trata de un lenguaje de programación que emplearemos para hacer consultas. Y es el lenguaje de programación más ampliamente usado para trabajar con bases de datos relacionales.
¿Qué es SQL?
Por tanto, podemos definir SQL como un lenguaje de programación que emplearemos para gestionar las bases de datos relacionales.
