23/5/12

Leer un String, convertirlo a Document y guardarlo como archivo XML

Por lo general cuando trabajo con XML en Java utilizo JDOM, por razones de un proyecto laboral tuve que utilizar DOM, he aquí un ejemplo de cómo leer un String, convertirlo a un objeto Document y guardarlo en un archivo.
Comencemos por la función que convertirá el String en un Document:
public Document stringADocumento(String s) {          
                    Document tmpXml=null;
          DocumentBuilder builder = null;
          try{
               builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
         }catch(javax.xml.parsers.ParserConfigurationException error){
                 System.out.println("Error crando factory String2DOM "+error.getMessage());
                 return null;
          }
          try{
               tmpXml=builder.parse(new ByteArrayInputStream(s.getBytes()));
          }catch(org.xml.sax.SAXException error){
             System.out.println("Error parseo SAX String2DOM "+error.getMessage());
             return null;
           }catch(IOException error){
                System.out.println("Error generando Bytes String2DOM "+error.getMessage());
                return null;
            }
            return tmpXml;
      }
Ahora la funcion main con un String que enviamos:
public static void main (String[] args) throws TransformerConfigurationException, TransformerException {                                                 
         String cadena = "" + " " + " Alvaro" + "    Gerente" + " " + " " + " Lorena" + " administradorA" + " " + "";
         CadenaAXML xm = new CadenaAXML();
         Source origen = new DOMSource(xm.stringADocumento(cadena));
         Result resultado = new StreamResult(new java.io.File("resultado.xml"));
         //nombre del archivo
         Result consola= new StreamResult(System.out);
         Transformer transformar = TransformerFactory.newInstance().newTransformer();
          transformar.transform(origen, resultado);
          transformar.transform(origen, consola);
 }
Finalmente las librerias utilizadas:
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.StringReader;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.Result;
import javax.xml.transform.Source;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.w3c.dom.Document;
import org.xml.sax.InputSource;
Ahora dejo el proyecto realizado en jdeveloper

14/1/12

Herencia y Polimorfismo en Java

Muchas veces damos por sentado que todos en programación saben y aplican la “herencia” y el “polimorfismo”, si bien existe una amplia documentación al respecto; que los invito a buscar en la red, para entender los conceptos y su aplicación un ejemplo sencillo ayudaría mucho, es por esto que decidí escribir esta pequeña nota.

Bueno iniciemos, utilice el IDE que más le guste o si prefiere con un simple editor, por comodidad utilizare un IDE ( mis preferidos son Jdeveloper e SpringSource) pero como todos sabemos es indiferente cual se utilice.

Herencia

A) Creamos un proyecto en nuestro IDE, por ejemplo HerenciayPolimorfismo, tal como lo muestro en la siguiente imagen:



Este proyecto tiene tres clases:

  1. Herencia (clase principal)
  2. acepta
  3. concede

B) La Herencia en java permite que una clase reciba automáticamente las propiedades y los métodos de otra clase.

C) La clase “concede” tiene el siguiente código con un solo método:

package conceptos;
public class concede {
public void estoyEscribiendo(){
System.out.println("Escribo una nota");
}
}

D) Ahora vamos a la clase “acepta” que tiene el siguiente código:

package conceptos;
public class acepta extends concede {
}

La clase concede utiliza la palabra clave “extends” eso quiere decir que automáticamente la clase “acepta” recibe todo lo que le da la clase “concede”.

E) La clase principal crearemos una nueva instancia del tipo “acepta” y nuestra clase principal quedara de la siguiente manera:

package conceptos;
public class Herencia {
public static void main(String[] args) {
acepta herencia = new acepta();
herencia.estoyEscribiendo();
}
}
Si ustedes están realizando este ejemplo con algún IDE, notaran que al escribir “herencia.” tenemos disponible el método “estoyEscribiendo”, pero que sucede si la clase “acepta” no tienen ningún método?, la “magia” esta en la palabra “extends” que esta en “acepta” que le permite heredar de la clase “concede”.
En este caso la clase que proporciona el código es la super clase y la clase que hereda el código es la sub clase.

Al ejecutar(Run) la clase Herencia obtendremos el siguiente resultado:

Escribo una nota

Polimorfismo

Mediante el polimorfismo podemos variar las propiedades de un objeto que a heredado de otra clase, veamos esto siguiendo con nuestro código, añado las siguientes líneas :

package conceptos;
public class Herencia {
public static void main(String[] args) {
acepta herencia = new acepta();
concede herenciaDos = new concede();
herencia.estoyEscribiendo();
herenciaDos.estoyEscribiendo();
}
}
Al ejecutar el anterior código nos desplegara dos veces el mensaje:
Escribo una nota
Escribo una nota

Mediante el polimorfismo podemos hacer que la clase “acepta” que es la que extiende a todas las propiedades de “concede” pueda modificar aquello datos que recibe, en nuestro ejemplo haremos lo siguiente:

package conceptos;
public class acepta extends concede {
public void estoyEscribiendo(){
System.out.println("Tu también escribes una nota");
}
}

Este es un ejemplo claro de polimorfismo ya que la clase “acepta” esta heredando todo lo que tiene la clase “concede”, lo que realizamos en esta clase es añadir un polimorfismo y sobre escribir lo que heredamos, es decir tenemos “estoyEscribiendo” que hemos heredado pero estamos sobrescribiendo lo que he heredado, en pocas palabras estoy sobrescribiendo el método que he heredado cambiando el mensaje que voy a desplegar.

Para aclarar un poco mas la idea, voy a realizar un cambio en la clase “concede” de tal manera que quede de la siguiente manera:

package conceptos;
public class concede {
public void estoyEscribiendo(){
System.out.println("Escribo una nota");
}

public void estoyLeyendo(){
System.out.println("Leo un libro");
}
}

Como podrán apreciar he añadido un método mas a la clase concede y la clase principal quedara de la siguiente manera:

package conceptos;
public class Herencia {
public static void main(String[] args) {
acepta herencia = new acepta();
herencia.estoyEscribiendo();
herencia.estoyLeyendo();
}
}

El resultado de ejecutar el código será lo siguiente:

Tu también escribes una nota
Leo un libro

En este caso podemos comprobar como hemos heredado en la clase “acepta” el método “estoyLeyendo” ya que no existe este metodo en la clase “acepta” y hemos sobrescrito el método “estoyEscribiendo”.

Comprobamos por tanto como “acepta” lo que hace es heredar los métodos deja intacto el método “estoyLeyendo” pero modifica el “estoyEscribiendo” poniendo otro mensaje para desplegar.




Mira #AntesQueSeaTarde completo

Echa un vistazo al Tweet de @NatGeo_la: https://twitter.com/NatGeo_la/status/792908992661950464?s=09