AWT y swing

Hoy vamos hablar de AWT y swing, AWT es una libreria de Java para crear la parte grafica (Ventanas , Botones , etc) y swing es una extensión o mejora de AWT , en el esquema que tenemos en la foto de la entrada tenemos la herencia de clases, como podeis ver todas las clases heredan de Componet, bien expliquemos un poco.



Container: Es un contenedor y por lo tanto, también puede contener a mas container, para simplificarlo seria la ventana de la interfaz grafica. Se utiliza junto a un Layout ( ahora explicaremos que es un Layout ) , permitiendo que aparezcan varios objetos en nuestras interfaces para el usuario.Hay dos tipos de clases que heredan de Container Window y Panel, Window es la clase de la tipica ventana que estamos acostumbrados a ver, Panel como su propio nombre indica es un simple Panel sin botones maximizar, minimizar , cerrar.



Como ya comentamos antes ,cada Container tiene su Layout que sirve para administrar la posicion de los componentes dentro de un Container , Aqui teneis el enlace a la interfaz LayoutManager de las API de java.



De Component tambien heredan una serie de clases que sirven para crear Botones , campos de textos , Listas , etc... objetos que permiten que el usuario se comunique con nuestra aplicación.

¿Como manejar el blog usando Java?

Esta aplicación a la cual le voy a dedicar esta entrada tiene como finalidad poder acceder a un blog , mediante las API java de Blogger (que permite a un programa java conectarse a nuestro blog para pedir las entradas o publicar nuevas) para ello usaremos estas clases e interfaz.


GmailUsuario


Sirve para almacenar la cuenta y la clave del usuario del blog.

Atributos:

cuentaMail (String)

clave (String)


Enlace a la clase



EntradaBlog:

Clase para almacenar una entrada de blog.

Atributos

titulo (String)
contenido (String)

Enlace a la clase


ServicioBloggerImpl


Clase que implementa la interface ServicioBlogger (tiene como metodo conectar(GmailUsuario)) , esta clase se usa para conectar con el blog y recibir las entradas usando las API.


Metodos:

conectar:Devuelve un objeto ConexionBlogger.


Requiere un objeto de clase GoogleService que a su vez este objeto como parametro necesita el usuario y la clave que tenemos almacenado en un objeto de clase GmailUsuario.



dameEntradas: Devuelve una Colección de Entradas.


Requiere una Colección de tipo EntradaBlog , un objeto de clase Feed(objecto donde estan almacenadas todas las entradas del Blog con su cuerpo y su titulo) y uno de clase URL que le asignaremos la ruta del blog para mas tarde cargar a nuestro objeto Feed con todas las entradas del blog y poder trabajar con ellas.


Enlace a la clase


CLASES DE EXCEPCIONES


ErrorBlogger

BlogNoExistenteException

ErrorConexion.java


En el enlace al repositorio podreis ver las pruebas realizadas y el proyecto entero:

Repositorio

Colecciones Tipos y formas de Recorrerla.

Java tiene tres interfaces de colecciones Map, List y Set a continuación explicare cada una de ellas:

Map: Interfaz de colección de elementos pares los cuales van con una clave y un valor muy utiles cuando se quiere hacer una busqueda por la clave.

Set: Interfaz que como pecualiaridad tiene que no deja meter dos elementos en las colecciones iguales.

List:La ordenación es la característica más importante de una Lista, asegurando que los elementos siempre se mantendrán en una secuencia concreta.

Para ordenar elementos List podemos usar el método sort() de la clase java.util.Collections. Podemos pasarle al método un objeto con la interaz List, o podemos pasarle un objeto con la interfaz List y un Comparator. Si los elementos de la coleción List son todos del mismo tipo de clase y esa clase implementa el interface Comparable, simplemente podemos llamar a Collections.sort().

public static class Comparando
    implements Comparator {
  public int comparar(Object elemento1,
      Object elemento2) {
    String lower1 =
      element1.toString().toLowerCase();
    String lower2 =
      element2.toString().toLowerCase();
    return lower1.compareTo(lower2);
  }
}

TreeSet es una clase que utiliza la interfaz Set y que sirve para ordenar la colección segun como definas el metodo compareTo() de la interfaz comparable que hay que implementar , que comfiguremos al crearnos el objeto TreeSet.

Las formas de recorrerla son varias:

Tipico for ejemplo:
for(int i=0; i Object o = lista.get(i); System.out(o); }

Desde i = 0 hasta que i sea mayor o igual que la magnitud de la lista imprime el elemento Object de la lista.

foreach: Por cada elemento de la lista tipo Alumno imprime el elemento de la lista:

foreach(Alumno al:lista){ System.out(al.getNombre()); }


Itinerator:Usando un objeto de clase Iterator podemos recorrer la coleccion por el indice:

List pruebaItinerator = new LinkedList();

for (Iterator iterator = pruebaItinerator.iterator(); iterator.hasNext();) {
String t = (String) iterator.next();

}

Programación usando pruebas

Hola buenas hoy vamos a ver otra forma de programar usando el pluggin TestNG , para ello nos crearemos una carpeta Soucer aparte de src llamada test donde tendremos la misma estructura de paquetes que la clases que queramos probar por ejemplo:

Poniendo la misma estructura de paquetes y bajandote e instalando el pluggin TestNG y la libreria podremos probar nuestro codigo incluso antes de crearlo mediante el metodo assert() que se encarga de asegurar que la condicion que le pasas entre parentesis es cierta ejemplo:



@Test
public void pruebaCalendar() {
Calendar fecha = Calendar.getInstance();
assert (fecha.get(Calendar.YEAR) == 2008);
}

Ya comentamos en la entrada anterior que para que el TestNG testee un trozo de codigo debemos poner @Test encima del metodo o clase.Bien explico el ejemplo creamos un objeto de clase Calendar por defecto Calendar coje la fecha del sistema si no la modificamos, por eso podemos asegurar que el año de nuestro objeto Calendar es 2008 y ya estamos seguro de que en cualquier momento , que usemos ese codigo el valor del año sera 2008 ya que TestNG si no es cierto te lo indica.



Ventajas: Las ventajas son de mucho valor ya que te aseguras de todo lo que estas programando constantemente y puedes probar que tu codigo siempre esta bien y al final siempre te ahorras tiempo de debug que en algunos casos se hace bastante pesado.

Desventaja:Al principio quizas se hace un poco pesado estar probando cada trozo de tu codigo y eso hace que te relentices un poco programando.


La estructura de paquetes sirve para no tener que importar las clases y poder acceder a los atributos y metodos que no sean private y el escenario de prueba es donde se declaran los objetos que mas tarde usaremos en la prueba , ejemplo:

@Test
public void pruenaAlumno(){
////////// Escenario de pruebas
Alumno a1= new Alumno();
Alumno a2= new Alumno();
////////// FIN Escenario de pruebas
boolean res= a1.equals(a2);

assert(b):"No son iguales"


}

Anotaciones @Test ,@BeforeTest , @AfterTest

Buenas hoy voy hablar de estas anotaciones en especial ya que me parecen interesantes y la vereis amenudo en mi codigo (si no sabes que son las anotaciones mas abajo hay una entrada que lo explica) bien dicho esto comencemos:

@Test: Cuando tu haces una clase Test, para avisar que a de leer esa parte del codigo al Testing, colocamos @Test encima del metodo o clase que deseemos ,veamos el ejemplo:

@Test
public void pruebaOrden() {
coches.add(coche3);
coches.add(coche1);
Collections.sort(coches);
assert (coches.get(0).equals(coche1));
}

@BeforeTest: Cuando lo que deseas es que lea antes que @Test otro trozo de codigo colocas esta anotación, esta anotación es muy util para declarar variables antes de usarlas en los metodos que contienen una @Test, por ejemplo:

@BeforeTest
public void inicializarRecursos() {
coches = new ArrayList();
coche1 = new Coche("Opel", "Astra");
coche2 = new Coche("Opel", "Astra");
coche3 = new Coche("Renault", "T5");

}

@AfterTest:Y por ultimo cuando lo que quieres es que tu trozo de codigo selea despues del @Test colocas esta anotaión, es my util para limpiar las variables despues de un @Test, un ejemplo es:

@AfterTest
public void limpiarRecursos() {
coche1 = null;
coche2 = null;
coche3 = null;
coches = null;
}

Enumerations

Hoy vamos a dedicarle la entrada a los objetos de clase Enumerations, dichos objetos tienen como finalidad organizar las constantes , expliquemoslo con un ejemplo :


Nos Creamos nuestro Objeto Enum tiene como valores constantes A,B,C y D que son los niveles de acceso

package eticom.nums;
/**
* @author Administrador
*
*/

public enum NivelDeAcceso {

A, B, C, D }

-------------------------------------------------------------------------------------------



Nos creamos la clase Acceso que tendra como atributo niveldeaceso un objeto de mi enums que creamos con anterioridad y redifiniremos el metodo equals para poder comparar el objeto(si tienes dudas de como se hace mas abajo esta la explicación)


package eticom;
import eticom.nums.NivelDeAcceso;

/**
* @author Administrador
*
*/
public class Acceso {

public NivelDeAcceso niveldeacceso;

/**
* Constructor por defecto
*/

public Acceso() {
}
/**
* Constructor que crea el objeto pasandole un objeto de clase enum
*
* @param nivelParametro
* Mandatory
*/
public Acceso(NivelDeAcceso nivelParametro) {
niveldeacceso = nivelParametro;
}
/**
* Redefinir Metodo Equals
*/

public boolean equals(Object a) {
boolean respuesta = false;
Acceso u = (Acceso) a;
if (u.niveldeacceso.equals(this.niveldeacceso)) {
respuesta = true;
};
return respuesta;
}
}
--------------------------------------------------------------------------------
Bien ahora nos crearemos la prueba y veremos la utilidad a todo esto, haremos una prueba que comparara un objeto de clase Acceso con otro de clase Acceso si quieres comparar Acceso literalmente y por algun casual te equivocas al escribir el valor ejemplo:

String admin = new String("Acceso A");
String usuario = new String("acceso A");

assert(admin.equals(usuario)):"No son iguales"

Dara fallo ya que uno empieza en mayusculas y otro en minuscula pero si nos creamos un enums estamos obligados a escoger un valor constante si no no compilara ,bien despues de esta parrafada hagamos la prueba:


/**
*
*/
package eticom;
/**
* @author Administrador
*
*/
import org.testng.annotations.Test;
import eticom.nums.NivelDeAcceso;

@Test

public class AccesoTest {

/**
* Prueba de la clase Acceso
*/
public void pruebaAcceso() {
Acceso admin = new Acceso(NivelDeAcceso.A);
Acceso usuario = new Acceso(NivelDeAcceso.B);
Acceso usuario2 = new Acceso(NivelDeAcceso.A);
assert (admin.equals(usuario2)) : "No tienen el mismo acceso";
assert (!admin.equals(usuario)) : "tienen el mismo acceso";
}
}

Interface Java

Concepto:

El concepto de Interface , trata de una clase donde todos los métodos son abstractos . Permite al diseñador de clases establecer la forma de una clase (nombres de métodos, listas de argumentos y tipos de retorno, pero no bloques de código).

Para crear una interface, se utiliza la palabra clave interface en lugar de class. La interface puede definirse public o sin modificador de acceso, y tiene el mismo significado que para las clases. Todos los métodos que declara una interface son siempre public.

Para indicar que una clase implementa los métodos de una interface se utiliza la palabra clave implements. El compilador se encargará de verificar que la clase efectivamente declare e implemente todos los métodos de la interface. Una clase puede implementar más de una interface.

Declaración y uso

Una interface se declara:

interface nombre_interface {
tipo_retorno nombre_metodo ( lista_argumentos ) ;
. . .
}

Por ejemplo:

interface Bailarin{
void bailar();

}

Y una clase que implementa la interface:

class Persona extends Object implements Bailarin{
String tipoDeBaile;

public String bailar(String tipo) {

tipoDeBaile=tipo;

return "El tipo de baile que baila este bailarín es:"+tipoDeBaile;

}


}

Java te permite crear un objeto de una clase pero usando su interface de esta manera si por algun casual cambias la clase no se modificaria el codigo , simplemente implementariamos la interface a la nueva case, ejemplo:

Nos estamos creando el objecto a de clase persona pero usando la interface en este caso si cambiamos la clase y hacemos una nueva ,llamada Persona2 no cambiariamos el codigo (a.bailar("Tango");) solo cambiariamos (Bailarin a = new Persona2();) ya que al usar la interface te obliga a usar solo los metodos redefinidos de la interface en la clase.

Bailarin a = new Persona();

a.bailar("Tango");

Redefinir el metodo Equals

Muy buenas hoy vamos a ver como se redefine el metodo equals de la clase objects para poder utilizarlos en nuestra clase, para ello nos crearemos nuestra clase y definimos un metodo equals de este modo:


package eticom;
import eticom.anotaciones.Desarrollador;



@Desarrollador(nombre="Alberto")
public class Usuario {

String nombre;
String clave;


public Usuario() {
nombre="Jesus";
clave="1111";

}

public Usuario(String nombre, String clave) {
this.nombre = nombre;
this.clave = clave;

}
/*
Al llamarlo igual que el metodo de la clase Object redefiniremos el metodo pasandole un objeto y haciendo un casting al object para convertirlo en obejeto de nuestra clase.


*/
public boolean equals(Object a) {
boolean respuesta=false;
Usuario u = (Usuario)a;
if(u.nombre.equals(this.nombre)&& u.clave.equals(this.clave)){
respuesta=true;

};
return respuesta;

}



}

Hagamos la prueba:


package eticom;

import org.testng.annotations.Test;

import eticom.anotaciones.Desarrollador;
import eticom.anotaciones.FechaProyecto;

public class UsuarioTest {
String nombre;
String clave;

public UsuarioTest() {

}

public UsuarioTest(String nombre, String clave) {
this.nombre = nombre;
this.clave = clave;

}


@Test
public void pruebaEquals() {
Usuario uno = new Usuario();
Usuario dos = new Usuario();
assert (uno.equals(dos)) : "No son iguales";
Usuario tres = new Usuario("pepe", "3333");
Usuario cuatro = new Usuario("juan", "7777");
assert (!tres.equals(cuatro)) : "Son iguales";
}
}

Anotaciones

Las anotaciones son un mecanismo para dotar a las clases de Meta información.

Para acceder a la información de una anotación en tiempo de ejecución utilizamos el API de reflexión: java.reflection, que se ha completado en Java 5 para tener acceso a las anotaciones.

Las anotaciones se utilizan para anotar nuestro código, y la información de la anotación puede estar relacionada con la seguridad (permisos, usuarios, roles), persistencia (transacciones, cache, tablas, esquemas ...), logging ... dando lugar a un nuevo complemento de la POO, la Programación Orientada a Atributos

Un ejemplo de anotacion:

Esta es la anotacion que nos creamos
-----------------------------------------------------
package eticom.anotaciones;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD, ElementType.TYPE})
public @interface Desarrollador {

String nombre();


}

---------------------------------------------------------------
Y aqui en la clase UsuarioTest es donde la usamos
--------------------------------------------------------------
package eticom;

import org.testng.annotations.Test;

import eticom.anotaciones.Desarrollador;

public class UsuarioTest {

@Test
public void pruebaAnotacionAutorExiste(){
assert(Usuario.class.isAnnotationPresent(Desarrollador.class)):" no existe la anotación";
Desarrollador annotation = Usuario.class.getAnnotation(Desarrollador.class);
assert(annotation.nombre().equals("Juan")):" no coincide el valor con Juan";
}

}

Etiquetas JSF , Seam y AJAX

JSF
Este primer enlace es de JSF y te viene como son los tags en JSF y como serian en HTML esta bastante bien ya que para el que sepa HTML le sera muy facil entenderlos :)

http://www.exadel.com/tutorial/jsf/jsftags-guide.html



SEAM
Bien aqui teneis un manual de Seam una tecnología que tiene mucho que decir, para el que no conozca esta tecnología ,Seam es un producto creado por Gavin King el creador de Hibernate y que busca la creación rápida de aplicaciones web java:

http://docs.jboss.com/seam/2.0.0.GA/reference/en/html
/index.html

AJAX
Definicion:AJAX, acrónimo de Asynchronous JavaScript And XML (Javascript asíncrono y XML), es una técnica de desarrollo web para crear aplicaciones interactivas o (Rich Internet Applications). Éstas se ejecutan en el RIA cliente, es decir, en el navegador de los usuarios y mantiene comunicación asíncrona con el servidor en segundo plano. De esta forma es posible realizar cambios sobre la misma página sin necesidad de recargarla. Esto significa aumentar la interactividad, velocidad y usabilidad en la misma.

http://labs.jboss.com/file-access/default/members/
jbossajax4jsf/freezone/docs/devguide/index.html

Master Java

Hola buenas me presento , me llamo Alberto y estoy iniciando mi camino como programador .En este blog ire añadiendo los conocimientos que adquiera en el nuevo curso de Java que comenzare hoy y en las practicas de empresa que efectuo en la empresa Viavansi