Facultad de Ingeniería
Ingeniería de Sistemas e Informática
TAREA ACADÉMICA 2
Alumno: Retamozo Rosales Hernan
Código: u21322551
Ciclo: 3
Curso: Taller de programación
Profesor: Lizardo Silva Ubaldo
2021
Contenido
TEMA 1: MODULOS EN JAVA: CONCEPTOS, CREACION............................................3
TEMA 2: MÓDULOS EN JAVA: COMPILACIÓN, DESPLIEGUE...................................4
TEMA 3: CONTROL DE VERSIONES, QUE ES, PARA QUE SIRVE, SOFTWARE DE
CONTROL DE VERSIONES...................................................................................................6
TEMA 4: EJEMPLO EN JAVA...............................................................................................8
CONCLUSIONES....................................................................................................................10
BIBLIOGRAFÍA......................................................................................................................10
TEMA 1: MODULOS EN JAVA: CONCEPTOS, CREACION
Java se ajusta plenamente a la programación orientada a objetos (POO). Aparte de los
8 tipos de datos primitivos, todos los cuales tienen su correspondiente objeto. La POO
se basa en una serie de conceptos, entre los que destaca el de encapsulación, cuyo
objetivo es promover la modularidad y solidez del código. Este concepto consiste,
principalmente, en ocultar los detalles de los campos y los métodos dentro del propio
objeto, es decir, declarar estos detalles con los modificadores de
visibilidad private o protected. Consiste, por tanto, en dejar accesible desde el exterior
del objeto solo lo estrictamente necesario para su uso. Esto significa declarar con el
modificador public únicamente lo necesario para el uso externo.
Un objeto de una clase diseñada según este principio de POO puede ser modificado sin
consecuencias para el resto del código, siempre que no se modifique el formato de su
parte pública. Esto confiere a la aplicación una gran robustez y escalabilidad durante su
ciclo de vida, ya que el código de una aplicación siempre necesita ser modificado para
corregir anomalías o para que funcione mejor.
Ampliación de la Noción de Encapsulación
En la práctica, se ha comprobado que la granularidad de la clase dentro del software es
demasiado baja para garantizar una reutilización y robustez suficientes. Esto es una
consecuencia natural de la creciente complejidad y tamaño del software que hay que
construir. Hoy en día, una aplicación media puede alcanzar rápidamente varios cientos
de clases. Por ello, el nivel de abstracción de la encapsulación ganaría en eficiencia si se
extendiera a un nivel superior: el paquete, que agrupa varias clases en un único espacio
de nombres.
En un paquete se puede declarar una clase:
Con el modificador public, lo que hace que sus métodos y campos públicos sean
accesibles desde otros paquetes.
Sin modificador: No se puede acceder desde otros paquetes.
Esto hace que el paquete sea una posible unidad de modularización de un código de
software. Se puede considerar una biblioteca/componente de software compuesta por un
único paquete en el que una o varias clases públicas constituyen la interfaz del
componente y otras clases no públicas se encargan de los detalles internos de esta
biblioteca/componente.
Particularmente, la ausencia de cualquier control previo de coherencia entre unidades
modulares conduce a la posibilidad de conflictos que solo son detectables en tiempo de
ejecución, lo que provoca errores de ejecución. Este problema se conoce como JAR
Hell.
Módulos en Java 9:
Los módulos introducidos en Java 9 llevan la posibilidad de encapsulación a un nivel de
abstracción aún mayor. Es en el nivel físico del archivo JAR donde puede tener lugar la
encapsulación. Pero más allá de la encapsulación, la modularización avanzada del
código de las aplicaciones es posible gracias a las características de los módulos Java:
Agrupación del código de la aplicación como una colección de paquetes de
cualquier tamaño.
El módulo también puede contener código nativo, archivos de configuración y
recursos estáticos.
Visibilidad externa declarativa del tipo exports/requires que permite construir
fácilmente un árbol de dependencias.
Verificación previa a la ejecución de la coherencia de las interdependencias
entre módulos.
En concreto, un archivo JAR/módulo sólo se diferencia de un archivo JAR clásico en
que debe existir un archivo llamado module-info.java en su raíz. Este archivo contiene
una definición declarativa del módulo.
TEMA 2: MÓDULOS EN JAVA: COMPILACIÓN, DESPLIEGUE
Creación de un Módulo Java
Con un editor de texto, se debe crear el archivo X.java cuyo contenido es:
package net.meddeb.Xmodule;
class X {
public static void main(String[] args) {
System.out.println("¡Módulo!");
Y el archivo module-info.java cuyo contenido es:
module es.java.modulo {
exports es.java.modulo;
Luego se compila el código y se crea el archivo JAR para el módulo ejecutando una
serie de 3 comandos en el orden correcto en lo que debemos tomar en cuenta lo
siguiente:
En la práctica, es mejor anteponer un nombre de dominio para que sea
universalmente único.
Contiene un único paquete que a su vez contiene una única clase.
Exporta su único paquete: la declaración exporta en el archivo module-info.java
Se puede comprobar el contenido de un archivo JAR de un módulo ejecutando el mismo
en el que la salida final será de la forma:
(--------) module-info.class
(-----) es/
(-----) es/Y/
(-----) es/Y/Xmodule/
(--------) es/Y/Xmodule/X.class
Se puede ejecutar la clase X de dos maneras diferentes. Como una clase ejecutable (que
contiene el método main()) en cualquier archivo JAR, por compatibilidad con versiones
anteriores y también puede ejecutarse como una clase ejecutable contenida en un
módulo.
Sin embargo, se debe tener en cuenta que el segundo comando solo funciona en JAVA
9+. Su posible ejecución demuestra que el JRE reconoce nuestro módulo como tal y no
funcionaría si se elimina el archivo module-info.class del JAR.
TEMA 3: CONTROL DE VERSIONES, QUE ES, PARA QUE SIRVE,
SOFTWARE DE CONTROL DE VERSIONES
¿Qué es un control de versiones?
Actualmente es imprescindible contar con algún sistema de control de errores y
versiones, es así como surge el CVS o sistema de control de versiones. El cual lo
podemos definir como un conjunto de herramientas que nos permite monitorear y
gestionar cambios realizados en un software durante un periodo de tiempo.
Según otros autores, los controles de versiones se pueden definir como:
El proceso de almacenar y recuperar cambios de un proyecto de desarrollo. Los sistemas
de control de versiones SCV, permiten disponer de una versión anterior para corregir
errores o actualizar funciones. Dentro de sus funcionalidades está el conservar las
versiones que se hayan generado a través del tiempo, así como los diferentes archivos
que integran el proyecto en cuestión, uniendo en forma automática las aportaciones de
los integrantes de un equipo de trabajo (Tello-Leal, 2012, pág 2).
Entonces, podemos decir que un sistema de control de versiones es un instrumento en el
cual pueden participar una o más personas, y sirve para supervisar y gestionar cambios
realizados en un software o archivo de trabajo. Nos da las opciones de examinar y
eliminar errores, además de optimizar funciones.
¿Para qué sirve un control de versiones?
Sin duda, un CVS o control de versiones, es una herramienta de gran utilidad que
resulta necesaria para la obtención de un trabajo óptimo y fluido. Entre sus
funcionalidades más útiles tenemos:
a. Historial:
Cada cambio realizado se encuentra almacenado y la extensión de tiempo es muy
amplia, se puede visualizar el historial de hace un día o de hace un año. Asimismo, se
puede observar quién fue la persona encargada de los cambios efectuados, junto con
notas que contienen las razones por las cuales se generaron modificaciones. Pero lo más
importante a resaltar en un historial es la facilidad con la cual se pueden detectar errores
y remediarlos, puesto que, al contar con un historial de todas las versiones hechas, se
nos facilita detectar en qué momentos se produjeron errores. Incluso si estos fueron
cometidos con gran anterioridad, es posible guiarse de los errores para reconstruir y
remediar archivos anteriores.
b. Trabajo en equipo:
Los trabajos generalmente son hechos en colaboraciones con un equipo designado, por
lo cual se pueden emplear dos tipos de sistemas de control. El primero es el
centralizado, en este se trabaja con un único repositorio. En el cual, cada programador
está conectado a su puesto de trabajo correspondiente. En este sistema todo se encuentra
fuertemente vinculado. Por otro lado, tenemos al sistema distribuido. En este sector
encontramos que el repositorio principal tiene un clon y cada programador puede tener
un repositorio clonado, por lo cual se pueden generar cambios que no modifiquen, en su
totalidad, al repositorio principal. E incluso los programadores pueden rápidamente
compartir sus cambios realizados a modo de feedback antes de subir los cambios finales
al repositorio. De igual manera, en este sistema si el repositorio principal llegara a sufrir
algún percance o desperfecto, todos los datos pueden ser recuperados sencillamente
desde un repositorio local.
Nos damos cuenta de que la implementación de un CVS tiene diversas ventajas y una de
las más resaltantes es la colaboración entre equipos mediante los tipos de sistemas
existentes.
c. Trazabilidad:
Los sistemas de control de versiones también nos permiten trazar los procedimientos, a
modo de observar la evolución de los cambios hechos y examinarlos detenidamente.
Asimismo, el CVS se puede conectar a un sistema que nos permite gestionar los
procesos y otorgar seguimiento de errores. De esta forma, al momento de efectuar la
lectura de códigos, se puede examinar cuál fue el error para poder erradicarlo y realizar
un cambio adecuado de códigos.
d. Ramas y fusiones:
Independientemente si el trabajo es realizado autónomamente o en equipo, se pueden
elaborar ramas que contengan diversos flujos de trabajo. Con la finalidad de tener
sectores separados para una mejor examinación en caso una de las partes esté fallando.
Incluso se puede dividir el trabajo en ramas cuando se quiere trabajar específicamente
en un sector determinado. Y de la misma manera en que las ramas se separan, también
se unen.
Software de control de versiones
Contar con un software de control de versiones es una pieza fundamental que todo gran
negocio debe tener para poder gestionar sus avances y la solución de conflictos
encontrados. Entre los más conocidos y completos tenemos:
a. Ve - Git:
Esta herramienta es una de las más completas que lidera el mercado, se caracteriza por
tener un modelo de sistema distribuido que apoya el desarrollo no lineal, Además, es
compatible con protocolos como HTTP, FTP, SSH, los cuales son los más utilizados.
Asimismo, te permite manejar proyectos de diversos tamaños, así sean pequeños o
grandes.
b. CVS:
Este tiene un modelo cliente-servidor que permite que diversos programadores trabajen
simultáneamente. Igualmente, posee una gran adaptabilidad y mantiene un historial de
cambios muy extenso.
c. Apache Subversion - SVN:
Al igual que el sistema CVS, posee un modelo cliente-servidor; sin embargo, este hace
uso de un sistema distribuido. Asimismo, tiene excelentes funciones como el empleo de
enlaces simbólicos versionados, uso de confirmaciones atómicas, correcto empleo de su
ramificación y almacenamiento, etc.
TEMA 4: EJEMPLO EN JAVA
Para el siguiente ejemplo se creará un Utility Project el cual se define como una librería
o JAR.
package com.arquitecturajava.core;
import com.arquitecturajava.utils.UtilidadIVA;
public class Factura {
private int numero;
private String concepto;
private double importe;
public int getNumero() {
return numero;
}
public void setNumero(int numero) {
this.numero = numero;
}
public String getConcepto() {
return concepto;
}
public void setConcepto(String concepto) {
this.concepto = concepto;
}
public double getImporte() {
return importe;
}
public void setImporte(double importe) {
this.importe = importe;
}
public double getImporteIVA() {
return UtilidadIVA.calcularIVA(this.importe);
}
}
package com.arquitecturajava.utils;
public class UtilidadIVA {
public static double calcularIVA(double importe) {
return importe *1.21;
}
}
En este ejemplo se muestran 2 clases Java relacionadas en diferentes package. A
continuación, se puede verificar la información que contiene el fichero que se encarga
de la gestión de módulos.
module ModuloA {
exports com.arquitecturajava.core;
}
De esta manera se puede verificar la estructura del módulo creado. Finalmente, para
usar la librería o JAR en otro proyecto Java que tenga un fichero main, se realiza lo
siguiente:
package com.arquitecturajava;
import com.arquitecturajava.core.Factura;
import com.arquitecturajava.utils.UtilidadIVA;
public class Principal {
public static void main(String[] args) {
Factura f= new Factura();
f.setImporte(200);
System.out.println(f.getImporteIVA());
UtilidadIVA
}
}
CONCLUSIONES
Es de suma importancia usar módulos en Java ya que aporta solidez y eficacia al
código planteado.
La carga rápida es uno de los puntos fuertes de los módulos ya que el sistema
reconoce dónde está cada paquete sin tener que escanear todas las clases.
BIBLIOGRAFÍA
http://revistas.usbbog.edu.co/index.php/IngUSBmed/article/view/267/181
https://www.atlassian.com/es/git/tutorials/what-is-version-control#:~:text=El
%20control%20de%20versiones%2C%20tambi%C3%A9n,en%20el%20c
%C3%B3digo%20de%20software.
https://spa.myservername.com/15-best-version-control-software#1_Git
https://javadesdecero.es/avanzado/modulos-java-ejemplos/
