java | Cyberexplorador's Blog

Ejemplo de Polimorfismo en Java

agosto 4, 2012 a las 7:34 pm | Publicado en Java | Deja un comentario
Etiquetas: figura, java, polimorfismo

Vamos a ver un ejemplo de polimorfismo en Java con el uso de interfaces. En la definición de Polimorfismo tenemos:

El polimorfismo es un concepto de la programación orientada a objetos que nos permite programar en forma general, en lugar de hacerlo en forma específica. En general nos sirve para programar objetos con características comunes y que todos estos compartan la misma superclase en una jerarquía de clases, como si todas fueran objetos de la superclase. Esto nos simplifica la programación.

No nos vamos a enfocar mucho en la teoría sino en la parte práctica. Vamos a usar una interfaz para aplicar el concepto de polimorfismo.

Primero creamos un proyecto Java en Eclipse. y vamos a crear en el src el package llamado com.practica.polimorfismo.

Ahora vamos a crear la clase Figura.java que contendrá el siguiente código:

publicclass Figura {

private String nombre;

private String color;

public Figura(String nombre) {

super();

this.nombre = nombre;

}

public Figura(String nombre, String color) {

super();

this.nombre = nombre;

this.color = color;

}

public String getNombre() {

return nombre;

}

publicvoid setNombre(String nombre) {

this.nombre = nombre;

}

public String getColor() {

return color;

}

publicvoid setColor(String color) {

this.color = color;

}

}

Esta va a ser nuestra super clase de la cual heredarán otro tipo de figuras. Esta clase es simplemente un POJO que tiene el nombre y el colo de la figura y sus getters y setters y dos constructores, aunque solo usaremos uno.

Ahora vamos a crear una interfaz. En Eclipse nos vamos a File -> New -> Other -> Interface. La interfaz se llamara OperacionesFigura.java Esta interfaz contendrá el siguiente código:

package com.practica.polimorfismo;

publicinterface OperacionesFigura {

double calcularArea();

Figura figura();

}

Básicamente la interfaz tendrá dos métodos. Uno es el método calcularArea() que devolverá un double con el valor del área de la figura, y otro método que nos devolverá todo el objeto Figura. Como sabemos cada figura tiene diferente forma de calcular el área, pero todas tienen esta característica por eso las figuras que implementen esta interfaz deberán implementar estos dos métodos.

Ahora vamos a crear la clase Triángulo.java. Esta clase va a extender o heredar de Figura y a implementar la interfaz OperacionesFigura.

package com.practica.polimorfismo;

publicclass Triangulo extends Figura implements OperacionesFigura {

privatedouble base;

private Double altura;

public Triangulo(String nombre, String color, double base, Double altura) {

super(nombre, color);

this.base = base;

this.altura = altura;

}

@Override

publicdouble calcularArea() {

return (base * altura) / 2;

}

publicdouble getBase() {

return base;

}

publicvoid setBase(double base) {

this.base = base;

}

public Double getAltura() {

return altura;

}

publicvoid setAltura(Double altura) {

this.altura = altura;

}

@Override

public Figura figura() {

return new Figura(getNombre(), getColor());

}

}

Triangulo.java tendrá los atributos propios de un triángulo que son base y altura y además los atributos de la super clase Figura, es decir el nombre y el color. Aquí al implementar la interfaz tenemos el método calcularArea() que es base * altura dividido para 2, en el método figura retornamos una nueva Figura obteniendo el nombre y el color de la super clase. Además tenemos un constructor con todos los atributos de Triangulo y de la super clase Figura.

Ahora aplicamos lo mismo a otra figura. Creamos la clase Circulo.java:

package com.practica.polimorfismo;

importstatic java.lang.Math.*;

publicclass Circulo extends Figura implements OperacionesFigura {

privatedouble radio;

public Circulo(String nombre, String color, double radio) {

super(nombre, color);

this.radio = radio;

}

/*

* (non-Javadoc)

*

* @see com.practica.polimorfismo.OperacionesFigura#calcularArea()

*/

@Override

publicdouble calcularArea() {

returnPI * pow(radio, 2);

}

publicdouble getRadio() {

return radio;

}

publicvoid setRadio(double radio) {

this.radio = radio;

}

@Override

public Figura figura() {

returnnew Figura(getNombre(), getColor());

}

}

Tiene la misma estructura que Triangulo. En este caso tiene como atributo el radio del círculo y en calcularArea() aplicamos la fórmula del área del círculo.

Una vez realizado esto vamos a ver cómo ejecutar estos procedimientos. Para ello creamos la clase CalcularOperacionesFigura.java que contendrá el siguiente código:

package com.practica.polimorfismo;

import java.util.ArrayList;
import java.util.List;

public class CalcularOperacionesFigura {

/**
* @param args
*/

public static void main(String[] args) {
OperacionesFigura of = new Triangulo(«Triangulo», «Azul», 15.0, 3.0);
OperacionesFigura of2 = new Circulo(«Circulo», «Verde», 12.3);
List<OperacionesFigura> lista = new ArrayList<OperacionesFigura>();
lista.add(of);
lista.add(of2);

calcularArea(lista);
}

public static void calcularArea(List<OperacionesFigura> listaOperacionesFiguras) {
for (OperacionesFigura of : listaOperacionesFiguras) {
System.out.println(«Area es: » + of.calcularArea());
System.out.println(«Nombre es: » + of.figura().getNombre());
System.out.println(«Color es: » + of.figura().getColor());
}
}

}

Analicemos un poco el código.

En el método main creamos una instancia de la interfaz OperacionesFigura y le decimos que es igual a new Triángulo y llenamos los valores del constructor: nombre, color, base, altura. Podemos hacer esto porque Triángulo implementa OperacionesFigura. Luego hacemos lo propio para Circulo.java y le instanciamos desde la interfaz.

Hecho esto creamos una lista genérica de la interfaz List<OperacionesFigura> lista, como es genérica solo se puede agregar a la lista objetos de tipo OperacionesFigura. Hecho eso agregamos a la lista las dos interfaces que instanciamos anteriormente

Ahora creamos un método que se llama calcularArea que recibe como parámetro una lista de interfaz de tipo OperacionesFigura. Luego con un foreach recorremos nuestra lista y accedemos a los métodos de la interfaz que son calcularArea() y figura() y de esa manera podemos obtener el área de la Figura que creamos en la instancia. Nótese que se accede a los métodos de la interfaz y no de Triangulo o Circulo. De esta manera la interfaz sabrá qué calculo debe hacer para obtener el área gracias a la implementación de la interfaz.

Este es un ejemplo sencillo de polimorfismo.

Para descargar el código fuente se puede ir a: http://mygnet.net/codigos/java/varios/ejemplo_de_polimorfismo_en_java.3541

Validar el ingreso del RUC de Ecuador en Java – Tercera parte

febrero 20, 2011 a las 5:37 pm | Publicado en Java, Programacion | 1 comentario
Etiquetas: cedula, java, ruc

En la primera parte les mostré cómo validar el RUC de una persona natural. En la segunda parte les mostré cómo validar el RUC para persona jurídica o extranjera. Ahora les mostraré cómo validar el RUC para empresas públicas.

RUC para empresas públicas

La estructura de este tipo de RUC se muestra en la siguiente figura:

La validación de este tipo de RUC se basa en el algoritmo de Módulo 11. Los coeficientes son: 3, 2, 7, 6, 5, 4, 3, 2.

El procedimiento es el siguiente:

Se multiplican los primeros nueve dígitos del RUC por cada uno de los coeficientes que le corresponde en la misma posición.
Se suma ese resultado.
Se divide ese resultado para el módulo, como este RUC es módulo 11, se divide la suma para 11, y se obtiene su residuo.
Se resta el módulo (en este caso 11) de el residuo de la división anterior.
El resultado es el dígito verificador. Si ese número coincide con el número del RUC de la posición 9 el RUC es correcto.

Excepción: Si el residuo es cero, el dígito verificador es cero.

Ejemplo:
Coeficiente: 3 2 7 6 5 4 3 2

RUC: 1 7 6 0 0 0 1 5 5 0 0 0 1

Producto: 3 14 42 0 0 0 3 10 14

Sumatoria: 72

Residuo: 72 dividido para 11 da como respuesta 6, y como residuo 6.

Resta: 11 – 6 = 5.

5 Es el dígito verificador.

El código es el siguiente:

public class ValidaRucEP {

public static final int num_provincias = 24;

public static Boolean validaRucEP(String ruc){
int prov = Integer.parseInt(ruc.substring(0, 2));
boolean val = false;

if (!((prov > 0) && (prov <= num_provincias))) {
return val;
}

Integer v1,v2,v3,v4,v5,v6,v7,v8,v9;
Integer sumatoria;
Integer modulo;
Integer digito;
Integer sustraendo;
int[] d = new int[ruc.length()];

for (int i = 0; i < d.length; i++) {
d[i] = Integer.parseInt(ruc.charAt(i) + «»);
}

v1 = d[0]* 3;
v2 = d[1]* 2;
v3 = d[2]* 7;
v4 = d[3]* 6;
v5 = d[4]* 5;
v6 = d[5]* 4;
v7 = d[6]* 3;
v8 = d[7]* 2;
v9 = d[8];

sumatoria = v1+v2+v3+v4+v5+v6+v7+v8;
modulo = sumatoria % 11;
sustraendo = modulo * 11;
digito = 11-(sumatoria – sustraendo);
System.out.println(«Digito RUC –> «+digito);
System.out.println(«Digito Calculado –> «+v9);

if(digito == v9){
val = true;
}else
val = false;
return val;
}

public static void main(String[] args) {
String ruc_dato = «1760001550001»;
if (validaRucEP(ruc_dato)) {
System.out.println(«El RUC es correcto»);
} else
System.out.println(«El RUC es incorrecto»);
}
}

Espero que les sirva.

Pueden descargarse el código fuente de esta explicación en el siguiente enlace: http://mygnet.net/codigos/java/varios/validar_la_cedula_y_el_ruc_de_ecuador_en_java.3335

Validar el ingreso del RUC de Ecuador en Java – Segunda parte

febrero 20, 2011 a las 5:26 pm | Publicado en Java, Programacion | 2 comentarios
Etiquetas: java, ruc-ecuador, validar

En la primera parte les mostré cómo validar el RUC de una persona natural. Ahora les mostraré cómo validar el RUC de una persona jurídica o extranjera.

RUC de persona jurídica o extranjera

La estructura de este tipo de RUC se muestra en la siguiente figura:

La validación de este tipo de RUC se basa en el algoritmo de Módulo 11. Los coeficientes son: 4, 3, 2, 7, 6, 5, 4, 3, 2.

El procedimiento es el siguiente:

Se multiplican los primeros nueve dígitos del RUC por cada uno de los coeficientes que le corresponde en la misma posición.
Se suma ese resultado.
Se divide ese resultado para el módulo, como este RUC es módulo 11, se divide la suma para 11, y se obtiene su residuo.
Se resta el módulo (en este caso 11) de el residuo de la división anterior.
El resultado es el dígito verificador. Si ese número coincide con el número del RUC de la posición 10 el RUC es correcto.

Excepción: Si el residuo es cero, el dígito verificador es cero.

Ejemplo:
Coeficiente: 4 3 2 7 6 5 4 3 2

RUC: 1 7 9 0 0 1 1 6 7 4 0 0 1

Producto: 4 21 18 0 0 5 4 18 14

Sumatoria: 84

Residuo: 84 dividido para 11 da como respuesta 7, y como residuo 7.

Resta: 11 – 7 = 4.

4 Es el dígito verificador.

El código es el siguiente:

public class ValidaRucSociedades {

/**
* @param args
*/
private static final int num_provincias = 24;
//public static String rucPrueba = “1790011674001″;
private static int[] coeficientes = {4,3,2,7,6,5,4,3,2};
private static int constante = 11;

public static Boolean validacionRUC(String ruc){
//verifica que los dos primeros dígitos correspondan a un valor entre 1 y NUMERO_DE_PROVINCIAS
int prov = Integer.parseInt(ruc.substring(0, 2));

if (!((prov > 0) && (prov <= num_provincias))) {
System.out.println(«Error: ruc ingresada mal»);
return false;
}

//verifica que el último dígito de la cédula sea válido
int[] d = new int[10];
int suma = 0;

//Asignamos el string a un array
for (int i = 0; i < d.length; i++) {
d[i] = Integer.parseInt(ruc.charAt(i) + «»);
}

for (int i=0; i< d.length – 1; i++) {
d[i] = d[i] * coeficientes[i];
suma += d[i];
//System.out.println(“Vector d en ” + i + ” es ” + d[i]);
}

System.out.println(«Suma es: » + suma);

int aux, resp;

aux = suma % constante;
resp = constante – aux;

resp = (resp == 10) ? 0 : resp;

System.out.println(«Aux: » + aux);
System.out.println(«Resp » + resp);
System.out.println(«d[9] » + d[9]);

if (resp == d[9]) {
return true;
}
else
return false;
}

public static void main(String[] args) {
String ruc_dato = «1790011674001»;
if (validacionRUC(ruc_dato))
System.out.println(«El RUC es correcto»);
else
System.out.println(«El RUC es incorrecto»);
}
}

En la tercera parte les enseñaré a validar el RUC para empresas públicas.

Pueden descargarse el código fuente de esta explicación en el siguiente enlace: http://mygnet.net/codigos/java/varios/validar_la_cedula_y_el_ruc_de_ecuador_en_java.3335

Validar el ingreso del RUC de Ecuador en Java – Primera parte

febrero 20, 2011 a las 4:58 pm | Publicado en Java, Programacion | 1 comentario
Etiquetas: cedula, java, ruc-ecuador, validar

En este nuevo tutorial les voy a enseñar a validar el RUC ecuatoriano. La validación de la cédula del Ecuador lo pueden encontrar en el siguiente enlace: http://www.coplec.org/?q=2008/07/01/validador-de-c%C3%A9dula-ecuatoriana

Les puse ese enlace porque usaremos ese código para validar uno de los tres tipos de RUC que existen en el Ecuador.

Los tres tipos de RUC son:

RUC de persona jurídica o extranjera.- Es del tipo 1790011674001
RUC de persona pública (entidades estatales).- Es del tipo 1760001550001
RUC de persona natura.- Es del tipo 1701300103001

Se mostrará la validación por partes según cada tipo de RUC.

RUC de personas naturales

La estructura de este tipo de RUC se muestra en la siguiente figura:

Su validación se explica a continuación:

El RUC de una persona natural será 13 dígitos, sin letras, sin caracteres especiales , únicamente números, de los cuales los 10 primeros será la cédula de identidad.
Las 2 primeras posiciones corresponden a la provincia donde fue expedida, por lo cual los dos primeros números no será mayor a 24 ni menor a 1.
El tercer dígito es menor a 6 ( 0,1,2,3,4,5 ).
Del cuarto al noveno dígito es un número consecutivo de 6 dígitos.
El décimo dígito es el dígito verificador.
Del décimo primer dígito al décimo tercer dígito, identifican en forma consecutiva el número de establecimientos. Empieza siempre con el 0001.

El número de RUC es: 1710034065001 independientemente del número de establecimientos que tenga el contribuyente, no existe un número de RUC tal como 1710034065002.

La validación de la cédula de Identidad pasa un algoritmo «Módulo 10». Al número se lo divide en 13 partes, las 9 primeras son el número mismo, la 10 es el dígito autoverificador, y las 3 restantes indican si es principal o establecimiento adicional. Los coeficientes usados para verificar el décimo dígito de la cédula, mediante el algoritmo «Módulo 10» son: 2.1.2.1.2.1.2.1.2

Como se ve en la imagen se usan los 9 primeros dígitos del RUC. Los números de las posiciones impares e multiplican por 2, y los números de las posiciones pares se multiplican por 1. Si el resultado de multiplicar por 2 es mayor a 9, se resta 9. Como en la figura, 12 – 9 = 3.

Luego se suman todos los valores del producto. En este caso la respuesta es 25.

Luego se resta este número de su decena superior. La decena superior a 25 es 30. Por lo tanto queda: 30 – 25 = 5.

Y 5 es el dígito verificador, si este número coincide con el décimo dígito del RUC la cédula es correcta.

Excepción: Si el resultado de la resta es 10, el dígito verificador será 0.

Usando el código de la página que les puse arriba y haciéndole una pequeña modificación, el resultado queda:

public class ValidaCedula {
private static final int num_provincias = 24;

public static Boolean validacionCedula(String cedula){
//verifica que los dos primeros dígitos correspondan a un valor entre 1 y NUMERO_DE_PROVINCIAS
int prov = Integer.parseInt(cedula.substring(0, 2));

if (!((prov > 0) && (prov <= num_provincias))) {
//addError(«La cédula ingresada no es válida»);
System.out.println(«Error: cedula ingresada mal»);
return false;
}

//verifica que el último dígito de la cédula sea válido
int[] d = new int[10];
//Asignamos el string a un array
for (int i = 0; i < d.length; i++) {
d[i] = Integer.parseInt(cedula.charAt(i) + «»);
}

int imp = 0;
int par = 0;

//sumamos los duplos de posición impar
for (int i = 0; i < d.length; i += 2) {
d[i] = ((d[i] * 2) > 9) ? ((d[i] * 2) – 9) : (d[i] * 2);
imp += d[i];
}

//sumamos los digitos de posición par
for (int i = 1; i < (d.length – 1); i += 2) {
par += d[i];
}

//Sumamos los dos resultados
int suma = imp + par;

//Restamos de la decena superior
int d10 = Integer.parseInt(String.valueOf(suma + 10).substring(0, 1) +
«0») – suma;

//Si es diez el décimo dígito es cero
d10 = (d10 == 10) ? 0 : d10;

//si el décimo dígito calculado es igual al digitado la cédula es correcta
if (d10 == d[9]) {
return true;
}else {
//addError(«La cédula ingresada no es válida»);
return false;
}
}

public static void main(String[] args) {
String ruc_dato = «1710034065001»;
if (validacionCedula(ruc_dato.substring(0, 10)))
System.out.println(«El RUC es correcto»);
else
System.out.println(«El RUC es incorrecto»);
}
}

Una explicación del código. Hay una parte donde dice:

d[i] = ((d[i] * 2) > 9) ? ((d[i] * 2) – 9) : (d[i] * 2);

El uso del símbolo de pregunta ? es un equivalente al uso del if. Todo lo que está entre el ? y los dos puntos será lo que suceda en caso de ser verdadero, y lo que está después de los dos puntos sucederá en caso de ser falso.

Validar el ingreso del RUC de Ecuador en Java – Segunda parte

Validar el ingreso del RUC de Ecuador en Java – Tercera parte

Para conocer un poco más sobre la estructura del RUC pueden visitar el siguiente sitio: http://www.campvs.org/legislacion/index.php?option=com_content&task=view&id=18&Itemid=69

Pueden descargarse el código fuente de esta explicación en el siguiente enlace: http://mygnet.net/codigos/java/varios/validar_la_cedula_y_el_ruc_de_ecuador_en_java.3335

Programa de encriptación simétrica con el método matricial hecho en Java

agosto 4, 2010 a las 10:03 pm | Publicado en Java, Programacion | 3 comentarios
Etiquetas: desencriptacion, encriptación, java, programa

Este es un programa que hicimos en la universidad. Está hecho en un applet de Java en Netbeans. Primero les explico cómo funciona este método de encriptación y desencriptación y luego el funcionamiento del programa.

El método de encriptación simétrica se llama así porque usa la misma clave para encriptar y desencriptar. La clave es un valor numérico.

Para entender cómo funciona vamos a usar un ejemplo.

El mensaje a encriptar será: HOLA MUNDO ES UNA FRASE COMUN y la clave va a ser 4.

Lo que hacemos es agrupar el texto en número de caracteres según la clave y formar una matriz. Así con esa frase y esa clave nos quedaría:

H   O   L   A
_   M U N
D   O   _   E
S   _   U   N
A   _   F    R
A   S   E    _
C   O   M   U
N _    _    _

Para el ejemplo reemplacé los espacios con guiones bajos. Viendo esa frase en una línea sería:

HOLA | _MUN |DO_E | S_UN |A_FR | ASE_ | COMU | N_ _ _ |

Al último puse 3 guiones bajos para completar los 4 caracteres finales. Para encriptar la frase viendo la matriz vamos cogiendo los caracteres de la primera columna, luego de la segunda, etc, la frase nos queda:

H_DSAACN -> Primera columna
OMO__SO_ -> Segunda columna
LU_UFEM_ -> Tercera columna
ANENR_U_ -> Cuarta columna

La frase encriptada completa nos queda:

H_DSAACNOMO__SO_LU_UFEM_ANENR_U_

Tomando en cuenta que los guiones bajos son en realidad espacios.

Ahora analizando el número de caracteres tenemos que la frase original tiene 29 caracteres incluyendo los espacios, mientras que la frase encriptada tiene 31 caracteres (no se toma en cuenta el último espacio).

Este dato necesitamos para el proceso de desencriptación. Para eso se parte de la frase encriptada y se divide el número de caracteres para la clave. Si el residuo es cero, la respuesta de la división es el número de filas de la matriz, si no es cero el número de filas de la matriz es la respuesta d ela división más uno.

Si dividimos 31 para 4 la respuesta es 7 con residuo 3, como no es exacta entonces el número de filas será 7 + 1 = 8. Quiere decir que debemos agrupar la frase encriptada en grupo de 8 caracteres así:

H_DSAACNOMO__SO_LU_UFEM_ANENR_U -> Frase encriptada

H_DSAACN | OMO__SO_ | LU_UFEM_ | ANENR_U

Para formar la matriz cada grupo de caracteres es una columna de la matriz, nos queda por tanto:

H   O    L   A
_   M   U   N
D   O    _   E
S    _    U   N
A   _    F    R
A   S    E    _
C    O   M   U
N   _   _

Nuevamente volvemos a la matriz original y ya es cuestión de leer las filas en orden y se obtiene el mensaje desencriptado.

Esto es lo que haremos en el programa hecho en Java.

Lo pueden descargar del siguiente enlace: http://www.mygnet.net/codigos/java/criptografia/encriptacion_simetrica_con_metodo_matricial.3224

Manipular archivos XML usando Java mediante JDOM

agosto 16, 2009 a las 2:12 pm | Publicado en JDOM, Programacion | 13 comentarios
Etiquetas: API, archivos, java, JDBC, JDOM, manejar, manipular, postgresql, XML

En este tutorial vamos a ver cómo manejar archivos XML usando el lenguaje de programación Java.

Para hacer este manejo se necesita un API que nos permita manipular archivos XML desde Java. La verdad existen muchos basta hacer una búsqueda en Google para encontrar varios API que nos permiten hacer eso.

Entre los muchos API que existen hay uno particularmente fácil de usar, cuando hacíamos este proyecto en la Universidad empezamos desde cero, el ingeniero solo nos envío a hacer un programa que manipule un archivo XML relacionado con un sistema de riego usando como lenguaje de programación Java y además almacene información en una base de datos de PostgreSQL al mismo tiempo, el único problema es que no sabíamos como hacer eso.

Fue así que di con estos API’s pero entre tantos no sabíamos cuál usar. Finalmente la mayoría de tutoriales nos llevaba a un API que parecía ser lo bastante fácil de manejar, así que lo escogimos, se llama JDOM y se lo puede bajar gratuitamente de la página http://www.jdom.org/

Aquí no vamos a explicar su funcionamiento completo, es más ni siquiera sé qué nomás permite este API. Así que nos limitaremos a lo básico: crear nuevos elementos en un archivo XML y los eliminaremos. Por cierto, con JDOM puedes hacer todo, desde crear un archivo XML desde cero, hasta manipular uno ya existente, incluyendo poder hacer consultas XPath.

En la parte de documentación de JDOM en http://www.jdom.org/docs/apidocs/ podrás conocer todos los componentes de este API.

Si buscas más información de este API aquí te dejo un buen tutorial que podría servirte: http://www.webtaller.com/construccion/lenguajes/java/lecciones/java-xml-jdom.php

Al descargarte el JDOM te vas a bajar un archivo comprimido ZIP, aquí tienes los archivos para bajarte: http://www.jdom.org/dist/binary/debes bajarte la última versión, ya sea en formato .zip o .tar.gz.

Para usarlo solo debes descomprimir este archivo en la ruta Classpath, es decir, donde están los archivos .class, yo trabajé con Netbeans así que descromprimí el archivo dentro de la carpeta build/classes.

Como había mencionado antes, el programa también hace un almacenamiento en una base de datos de PostgreSQL, para eso necesitamos el JDBC necesario que se lo puede descargar de http://jdbc.postgresql.org/ allí te bajarás un archivo .jar solo debes descomprimirlo en la misma ruta que el JDOM, es decir, en el Classpath.

Aquí no vamos a explicar el funcionamiento de JDOM ni el JDBC para conexión con Postgres, simplemente mostraremos el funcionamiento del programa. Existen gran cantidad de manuales en Internet que te podrían ayudar. Aquí solo se pretende ser una guía de lo que puedes hacer con JDOM.

El programa está hecho con NetBeans y desde la página de MyGnet te puedes bajar todo el programa y lo puedes abrir como Proyecto y ejecutarlo inmediatamente, o si no aquí te voy a dejar los archivos por partes para que los compiles creando un proyecto nuevo, ya sea usando NetBeans, Eclipse o cualquier programa que te permita programar en Java.

Antes de ir a los códigos vamos a ver el programa funcionando. Antes cabe mencionar el hecho de que este programa fue hecho para manejar un archivo XML de un sistema de riego, modificando el código podemos manejar cualquier cualquier archivo XML.

El archivo XML que usaremos se llama RiegoVale.xml y contiene lo siguiente:

<?xml version=»1.0″ encoding=»UTF-8″?>
<SistemaRiego>
<tipo riego=»Inundacion»>
<Aplicacion>Cultivos de arroz</Aplicacion>
<CostoInicial>Bajo</CostoInicial>
<ConsumoEnergia>Baja</ConsumoEnergia>
<eficiencia>40%-65%</eficiencia>
<Descripcion>El agua es distribuida superficialmente sobre el terreno de regado</Descripcion>
</tipo>
<tipo riego=»Goteo»>
<Aplicacion>Cultivos de espaciamiento amplio</Aplicacion>
<CostoInicial>Alta</CostoInicial>
<ConsumoEnergia>Mediana</ConsumoEnergia>
<eficiencia>90%-95%</eficiencia>
<Descripcion>El agua es distribuida de manera localizada, por gotas, a traves de goteros instalados en mangueras de goteo.</Descripcion>
</tipo>
</SistemaRiego>

Esta es la primera pantalla que aparece al cargar el programa: