lunes, 22 de octubre de 2012

La clase Scanner


Esta clase permite crear objetos que pueden leer texto desde el teclado o desde un archivo
Scanner teclado = new Scanner(System.in);
Scanner archivo = new Scanner( new FileReader("prueba.txt") );

Dispone de diferentes funciones que permiten leer diferentes tipos de datos y para probar si hay más elementos o no.

  • nextInt
  • nextDouble
  • next
  • nextLine
  • hasNext
  • hasNextInt
  • hasNextDouble


martes, 22 de mayo de 2012

Declarar arrays

Hay varias formar para declararar arrays:

tipo_array [][] nombre_array;

tipo_array  nombre_array [][];

tipo_array  []nombre_array [];

Diferencias en tre i++ y ++i

Vamos a verlo con un ejemplo para entenderlo más facilmente:

i++ --> primero asigno, luego incremento.
++i -->primero incremento, luego asigno.

Ejemplo:

i=0;
a=i++;
Resultado a=0, i=1

i=0;
a=++i;
Resultado a=1, i=1

martes, 10 de abril de 2012

JasperReports Problemas/Solución

He tenido esta semana que generar informes con esta herramientas y me he encontrado con 2 problemas a la hora de generar el pdf.

  1. Me daba el siguiente error:
    Caused by: java.lang.NullPointerException
    at net.sf.jasperreports.engine.JRPropertiesMap.readObject(JRPropertiesMap.java:185)
    at java.io.ObjectStreamClass.invokeReadObject(ObjectStreamClass.java:946)
    at java.io.ObjectInputStream.readSerialData(ObjectInputStream.java:1812)
    at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1719)
    at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1305)
    at java.io.ObjectInputStream.defaultReadFields(ObjectInputStream.java:1910)
    at java.io.ObjectInputStream.readSerialData(ObjectInputStream.java:1834)
    at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1719)
    at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1305)
    at java.io.ObjectInputStream.readArray(ObjectInputStream.java:1634)
    at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1299)
    at java.io.ObjectInputStream.defaultReadFields(ObjectInputStream.java:1910)
    at java.io.ObjectInputStream.readSerialData(ObjectInputStream.java:1834)
    at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1719)
    at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1305)
    at java.io.ObjectInputStream.defaultReadFields(ObjectInputStream.java:1910)
    at java.io.ObjectInputStream.readSerialData(ObjectInputStream.java:1834)
    at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1719)
    at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1305)
    at java.io.ObjectInputStream.readObject(ObjectInputStream.java:348)
    at net.sf.jasperreports.engine.util.JRLoader.loadObject(JRLoader.java:192)
    at net.sf.jasperreports.engine.JasperFillManager.fillReport(JasperFillManager.java:361)
    at JasperService$_closure1.doCall(JasperService.groovy:89)
    at JasperController$_closure2.doCall(JasperController.groovy:85)
    at JasperController.invokeMethod(JasperController.groovy)
    at JasperController$_closure1.doCall(JasperController.groovy:56)
    at JasperController$_closure1.doCall(JasperController.groovy)

    Despúes de mirar que las variables que mandaba no llevara nulos y de mirar por internet, encontré la solución.

    Resulta que los archivos jrxml estaban ya creados,y habían sido compilados en una versión diferente al programa que yo estaba utilizando y el proyecto usaba la librería jasperreport 2.0.4 y yo estaba compilando con la versión 4.5.1, al modificar la librería que se descargaba mi proyecto a la misma que del programa que utilizaba para compilar. Error solucionado.


  2. Me daba el error: java.lang.NoSuchFieldError: PRINTSCALING, este también era un error por incompatibilidad de versiones, concretamente de la librería itext.jar que estaba usando una versión muy antigua, al actualizarla se solucionó ese error.

miércoles, 14 de marzo de 2012

Generic Connection Framework

El soporte que da MIDP2.0 a la programación en red se basa, como en MIDP1.0, en elGeneric Connection Framework.

Generic Connection Framework define una serie de interfaces para dar soporte a la variedad de tipos de conexiones que nos podemos encontrar en dispositivos móviles, pero no implementa ninguna de ellas. Es en los perfiles donde se debe realizar esta implementación.

martes, 6 de marzo de 2012

RMS

El Record Management System (RMS) es el sistema que utilizan los dispositivos MIDP para almacenar datos persistentemente. Sólo existe uno para todas las suites que el dispositivo utilice, pudiendo tener cada una de ellas, una o varias zonas de almacenamiento (RecordStore) en él reservadas.

miércoles, 29 de febrero de 2012

Aplicaciones MIDP

MIDP nos provee de API’s para poder crear una aplicación de dos formas distintas:
  1. Interfaz de bajo nivel --> utiliza la pantalla entera dibujando pixe a pixel los elementos que van a formar la aplicación.Sus elementos y métodos derivaban de la clase Canvas.
  2. Interfaz de alto nivel -->utiliza componentes definidos en MIDP y que cualquier dispositivo MIDP soporta:cajas de textos, grupos de opciones, etc siendo esta su mayor ventaja y su desventaja es que no son personalizable. Sus elementos y métodos derivaban de la clase Screen.
La característica más importante en un dispositivo móvil MIDP es su permanente posibilidad de conexión con el exterior, la cual permitirá establecer una conexión HTTP con un servidor J2EE (entre otras muchas).
Toda conexión en MIDP hereda de la interface Connection. Dicha interface representa la conexión más abstracta posible. Para obtener una instancia de ella o de cualquiera de sus hijas debe usarse alguno de los métodos open() de la clase factoría Connector.
Los tipos de conexión actualmente soportados por MIDP 2.0 son el HTTP, su versión segura HTTPS, las conexiones basadas en SOCKETS (de espera, en servidor, seguros, comunes), la realizada por medio de DATAGRAMAS y la comunicación con puertos serie COMM.


Una conexión HTTP siempre se encontrará en alguno de los tres estados siguientes: Establecimiento, Conectado o Cierre.
Podrán mejorarse las aplicaciones que requieran comunicación HTTP con múltiples consideraciones. Dos de ellas son: cuidar un redireccionamiento adecuado de la URL a buscar y otra, el uso de cookies utilizando el RMS del dispositivo para permitir que el servidor a conectar mantenga un seguimiento adecuado de la sesión.

viernes, 17 de febrero de 2012

API's de MIDP

Esta api esta formada por apis de la clase J2SE:
  • Paquete java.util.
y otra propia:
  • Paquete javax.microedition.

API's de CLDC

Parte de estas API's proviene del API de J2SE:
  • Paquete java.util
  • Paquete java.lang.
  • Paquete java.io.
y otra propia:
  • Generic Connection Framework --> da soporte para la creación de ficheros y para comunicaciones de red.

miércoles, 15 de febrero de 2012

Pasos para desarrollar un MIDlet

Como son dispositivos de capacidades muy limitadas, los pasos aconsejados a seguir son:
  1. Escribir el código fuente.
  2. Compilación.
  3. Preverificador de clases -->mira que las clases cumplan los requisitos necesarios, como no sobrepasar los límites de la pila de la Máquina virtual,uso correcto de las variables y se respeta la estructura de clases. Esta herramienta no la incorpora el KVM ya que pesa mucho y hay que hacerlo desde un entorno externo a ella.
  4. Empaquetamiento (jar,jad).
  5. Ejecución y depuración.

MIDlet

Al conjunto de aplicaciones que se basan en la configuración CLDC y perfil MIDP ,se les denomina MIDlet.

Las acciones que un dispositivo debe realizar antes de lanzar un MIDlet son:
  • Localizar el MIDlet.
  • Descargar el MIDlet.
  • Almacenar el MIDlet.
  • Gestionar el MIDlet.
  • Localizar los archivos JAD que pueden venir incluidos en un MIDlet.
  • Ejecutar los MIDlets descargados.
  • Conectarse a un servidor de internet utilizando el protocolo http y descargar tanto el MIDlet como su JAD asociado.
  • Proporcionar un nombre de usuario y contraseña cuando necesite conectarse a internet y la petición web lo solicite.
  • Instalar y borrar los MIDlets descargados.
Para realizar estos pasos el dispositivo tiene un programa que se encarga de realizar estas acciones llamado AMS o Gestor de aplicaciones.

Estructura de J2ME

Está compuesto por varias partes:
  • Perfil --> es un conjunto de API’s orientado a cubrir específicamente las necesidades de una familia de dispositivo.
  • Configuración -->conjunto de APIs que va a soportar los dispositivos.Existen 2 configuraciones básicas, CDC y CLDC.
  • Máquina Virtual --> Encargada de ejecutar el código, podemos utilizar una de estas dos JVM o KVM.Elegiremos una u otra dependiendo de las características del dispositivo que vamos a crear la aplicación.
Si elegimos la maquina virtual JVM, la configuración que le corresponde sería la CDC y si elegimos la KVM, entonces trabajaríamos con la CLDC y están destinada para dispositivos de pocos recursos.

Existen diferencias entre JVM y KVM haciendo que esta última no tenga características que incluye la primera.:
  1. KVM no trabaja con tipos de datos float ni double.
  2. No existe el main() sino el starApp().
  3. No tienen recolector de basuras.
  4. La verificación de código se hace fuera del dispositivo.
  5. Elimina el JINI.
  6. Elimina los threads.
  7. No tiene método que finalice las clases.
  8. Limitada capacidad para gestionar excepciones.
  9. Incluye una biblioteca gráfica nueva para ser empleada en dispositivos de poca memoria y con un tipo de pantalla más pequeña.
También tenemos que saber que la configuración CDC esta basada en J2SE e incorpora muchas de sus clases y CLDC es un subconjunto de CDC.

Con respecto a los distintos perfiles que hay, ocurre lo mismo con la maquina virtual, si elegimos la configuración CDC, los perfiles que tenemos son:
  • Foundation Profile
  • Personal Profile
  • RMI Profile
Y para la configuración CLDC tenemos:
  • PDA Profile
  • Mobile Information Device Profile (MIDP)--> es el perfil más utilizado.

J2ME

Es un lenguaje de programación y a su vez una plataforma donde se pueden ejecutar software creado en java.

Está orientado al desarrollo de aplicaciones para pequeños dispositivos electrónicos con recursos limitados como móviles, pdas,smartphone,etc...

El sitio oficial de J2ME se encuentra en http://java.sun.com/j2me/index.jsp

miércoles, 1 de febrero de 2012

La serialización de objetos

Es un tipo de persistencia, esto consiste en la codificación de un objeto en cadenas de bytes y almacenar ese objeto o transmitirlo, para poder llevar acabo esta acción lo hacemos mediante la interfaz java.io.Serializable que no tiene métodos solo sirve para indicar que esa clase se puede serializar. Los objetos de clases que no implementan Serializable no pueden salvar o restaurar sus estados.
Toda clase que implemente esta interfaz puede transformar sus objetos a cadenas de bytes y viceversa.Para ello utilizamos las clases del paquete java.io writeObject y readObject.
Hay clases que no se pueden serializar porque sus datos están cambiando constantemente como java.io.FileInputStream y java.lang.Thread.Tenemos que tener cuidado a a hora de serializar un objeto, si este contiene una referencia a un elemento no-serializable,fallaría y se lanzaría la excepción NotSerializableException.

Cuando pasamos objetos Serializable de un lado a otro podemos tener el problema de que la versión de un lado tenga una versión más antigua que en el otro lado. Si sucede esto, la reconstrucción de la clase en el lado que recibe es imposible.Para evitar este problema se aconseja que la clase serializable tenga el atributo privado serialVersionUID. Así java es capaz de detectar rápidamente que las versiones de objeto_serializable.class en ambos lados son distintas o no.

Nota:Los objetos con las propiedades static y transient no se pueden serializar y la mayoría de las clases Java son serializable.

Stream

Cada vez que queramos enviar o traer información sea del tipo que sea (imagenes,caracteres,objetos) utilizamos los stream.Hay streams de entrada (InputStream,Reader) y stream de salida (OutputStream,Writer).

Los stream soportan 2 tipos de datos:
  1. bytes brutos-->implementados por subclases de la clase InputStream y los streams de salida de bytes son implementados por subclases de la clase OutputStream.
  2. caracteres Unicode--> implementados por subclases de la clase Reader y los streams de salida de caracteres son implementados por subclases de la clase Writer.

martes, 31 de enero de 2012

Applet

Un applet es una clase Java que se incrusta en una página HTML y que se descarga y ejecuta con un navegador. Es un tipo específico de contenedor de tecnología Java.

Para ejecutar un applet, el navegador lo carga y después invoca un método init para realizar la inicialización básica del applet. Cuando termina init, el navegador invoca el método start. Este método se invoca en general cuando el applet se hace visible. El método stop se invoca cuando el applet se hace invisible, esto es, cuando el navegador es minimizado o sigue un enlace a otro URL.

Normalmente, un applet se ejecuta dentro de un navegador aunque, para simplificar y acelerar el desarrollo, se usa la herramienta appletviewer diseñada para visualizar applets. Es una aplicación Java que permite la ejecución de applets sin utilizar un navegador. Se puede considerar como un navegador mínimo.

Otros elementos del applet:
  • getDocumentBase -->Devuelve un objeto URL que describe el directorio de la página actual del navegador, donde reside el fichero HTML con la etiqueta applet.

  • getCodeBase -->Devuelve un objeto URL que describe el directorio fuente del fichero de la clase Applet. Frecuentemente es el mismo que el directorio del fichero HTML, pero no siempre es así.

  • getImage(URL base, String target) -->Extrae una imagen del fichero indicado por target localizado en el URL especificado por base. El valor devuelto es una instancia de la clase Image.

  • getAudioClip(URL)--> base, String target) Extrae un sonido del fichero indicado por target localizado en el URL especificando por base. El valor devuelto es una instancia de la clase java.applet.AudioClip.La manera más fácil de escuchar un sonido es usando alguno de los métodos play de la clase Applet.También tenemos loop que reproduce el sonido indefinidamente y stop que finaliza la reproducción del sonido.

En un fichero HTML, una etiqueta "< param >" en un contexto "< applet >" puede pasar información de configuración al applet. Estos parámetros se recogen desde el código del applet por medio de getParameter(nombre). Si el nombre del parámetro no se puede encontrar, devuelve null. El tipo del parámetro es siempre String. Si se desea de otro tipo, se debe convertir.

jueves, 26 de enero de 2012

Excepciones

Las excepciones se generan en la máquina virtual de Java, como respuesta a una condición inesperada, o en el código, como resultado de la ejecución de una instrucción throw.

Una excepción puede ocurrir por dos razones:
  1. Porque se produzca un error en tiempo de ejecución en la máquina virtual de Java: en tal caso, se crea una instancia de un objeto excepción (cualquier objeto que descienda de la clase java.lang.Throwable). A estas excepciones se les denomina excepciones no verificadas.
  2. Porque un método genere explícitamente un objeto que descienda de la clase Throwable (generable): los objetos generables se generan mediante la palabra clave throw. Las excepciones generadas de esta forma se denominan excepciones verificadas.
Vamos a explicar más detalladamente los tipos de excepciones:
  • Excepciones no verificadas-->se generan por errores en tiempo de ejecución. Son no verificadas ya que el compilador no es capaz de determinar si el código gestiona la excepción debido a que un error en tiempo de ejecución puede ocurrir en cualquier parte de un programa y por multitud de razones.Las clases de excepción que descienden de las clases RuntimeException y Error son excepciones no verificadas.
  • Excepciones verificadas -->Las excepciones son verificadas por dos razones:
  1. El compilador comprueba durante la compilación que el método incluye código para generar una excepción de tipo generable (las excepciones no verificadas no necesitan que las declaremos).
  2. El compilador obliga a que el código que llame a uno de estos métodos incluya la llamada en una instrucción try-catch y que proporcione un bloque catch para capturar la excepción.
Las clases de excepción que descienden de las clases Throwable (Error y Exception) son excepciones verificadas.

domingo, 22 de enero de 2012

Clases animadas

La tecnología Java permite declarar una clase dentro de otra. Éstas son llamadas clases anidadas. La clase que contiene estas clases anidadas recibe el nombre de clase exterior o contenedora.


Una clase anidada tiene acceso a todos los atributos y métodos de la clase contenedora. Una clase anidada puede ser declarada public, protected, private o package (por defecto). Por el contrario, la clase contenedora sólo puede ser declarada public o package (por defecto). También, a diferencia de las clases contenedoras, una clase anidada puede ser declarada estática (static).
Las clases anidadas pueden ser divididas en dos categorías:

  • Clases anidadas no estáticas ( clases internas) --> Las clases internas tienen acceso directo a los métodos y los campos de la clase exterior, así como a los métodos y los campos que hereda de su superclase. Pero, debido a que una clase interna se ha cargado sólo dentro del contexto de una instancia de su clase exterior, no podemos definir ningún miembro estático.

    Tenemos dos tipos diferente de clases anidad no estáticas:

  1. Clases internas locales: Una clase interna local (a veces llamada clase local), es una clase declarada dentro de un bloque de código en el cuerpo de un método. Una clase interna local sólo es visible dentro del bloque de código en el que se ha definido.

  2. Clases internas anónimas → Las clases internas anónimas (también llamada clases anónimas), son muy similares a las clases internas locales, pero sin nombre. En las clases internas locales primero se define la clase y luego se crean uno o más objetos. En las clases anónimas se unen estos dos pasos. Como la clase anónima no tiene nombre, sólo se puede crear un único objeto, ya que las clases anónimas no pueden definir constructores. Se utilizan en clases con poco código.Siempre deben ser clases interna e implícitamente finales.La declaración y el uso de la clase son adyacentes.Nunca pueden ser abstractas Nunca pueden ser clases estáticas.Para instanciar una clase interna desde algún lugar que no sea la clase exterior, primero debemos instanciar la clase exterior, y a continuación, instanciar la clase interior.

  • Clases anidadas estáticas → Las clases anidadas estáticas sólo pueden ser creadas dentro de otra clase al máximo nivel, es decir, directamente en el bloque de definición de la clase contenedora y no en un bloque más interno. Este tipo de clases anidadas se definen utilizando la palabra static.Debido a su carácter "estático", estas clases no pueden acceder a los miembros de su clase contenedora directamente, sino a través de la instancia de un objeto.Puede acceder a una clase anidada estática utilizando una referencia que remite a la clase: Outer.StaticNested

miércoles, 18 de enero de 2012

Programación Orientada a Objetos

Tienes 3 pilares básicos:
  1. Encapsulación -->un método pueda usar a otro método para recibir un resultado sin que el primer método sepa como trabaja el segundo.
  2. Polimorfismo -->diferentes formas en que una variable puede apuntar a un objeto.
  3. Herencia --> una clase puede heredar atributos de la clase que hereda.

lunes, 16 de enero de 2012

Encapsulación

Este concepto consiste en la ocultación del estado o de los datos miembro de un objeto, de forma que sólo es posible modificar los mismos mediante los métodos definidos para dicho objeto.

Cada objeto está aislado del exterior, de forma que la aplicación es un conjunto de objetos que colaboran entre sí mediante el paso de mensajes invocando sus operaciones o métodos. De esta forma, los detalles de implementación permanecen "ocultos" a las personas que usan las clases, evitando así modificaciones o accesos indebidos a los datos que almacenan las clases.

Además, el usuario de la clase no se tiene que preocuparse de cómo están implementados los métodos y propiedades, concentrándose sólo en cómo debe usarlos.

La encapsulación es una de las principales ventajas que proporciona la programación orientada a objetos.