Showing posts with label objeto. Show all posts
Showing posts with label objeto. Show all posts

Thursday, November 27, 2008

BAJEMOS A ECHAR UN VISTAZO


INTERFACES DE BAJO NIVEL

Bueno, en las entregas anteriores hablamos de las interfaces de alto nivel; comentábamos que estas interfaces son de las más fáciles de implementar pues su presentación gráfica queda a cargo del dispositivo en que se ejecute la aplicación.
Esto nos permite ahorrar tiempo y esfuerzo, aunque en ocasiones será necesario tomar el control de la presentación, por ejemplo: Si lo que estamos desarrollando es un videojuego.

REGLA No. 1:
Antes de comenzar, es conveniente que establecer una regla : "Todas las pantallas que vayamos a crear usando las APIs de bajo nivel heredan de la clase Canvas".

Por esta razón, lo primero de todo es conocer a fondo esta clase y luego iremos profundizando en cada uno de los elementos que la componen.
La clase Canvas es la superclase de todas las pantallas que usan las APIs de bajo nivel, al igual que Screen lo era para las pantallas que usaban las APIs de alto nivel.

CONVIVENCIA PACIFICA:
Sin embargo, en la relación de APIs de alto y bajo nivel, no hay nada escrito, ésto es : "No existe ningún impedimento que nos permita usar en el mismo MIDlet pantallas tanto derivadas de Canvas como de Screen"

La clase Canvas permite manejar eventos de bajo nivel y dibujar cualquier cosa por pantalla. Es por ésa razón que se usa como base para la realización de juegos.

Esta clase posee un método abstracto paint() que debemos implementar de manera obligatoria (Por nuestra propia voluntad) y es la encargada de dibujar en la pantalla del dispositivo.


Veamos un ejemplo para irnos familiarizando:


BajoNivel.java


import java.io.IOException;
import javax.microedition.lcdui.*;
public class BajoNivel extends Canvas implements CommandListener {
private PBajoNivel midlet;
private Command salir;
private Image imgFondo, imgTriste;
public BajoNivel(PBajoNivel mid) {
try {
imgFondo = Image.createImage("/fondo.PNG");
imgTriste = Image.createImage("/triste.PNG");
} catch (IOException e) {
e.printStackTrace();
}
salir = new Command("Salir", Command.EXIT,1);
this.midlet = mid;
this.addCommand(salir);
this.setCommandListener(this);
}
public void paint(Graphics g) {
g.setColor(255,255,255);
g.fillRect(0,0,getWidth(),getHeight());
g.setColor(0,0,0);
g.drawImage(imgFondo, 0, 0, 0);
g.drawImage(imgTriste, 40, 40, 0);
}
public void commandAction(Command c, Displayable d){
if (c == salir){
midlet.salir();
}
}
}



Esta rutina es la que nos mostrará en el dispositivo la pantalla, nótese que estamos utilizando dos imágenes fondo.PNG y triste.PNG, estos archivos los colocamos en el directorio de RES en nuestro proyecto.


Ahora veamos el código del MIDlet que lo mandará llamar.


PBajoNivel.java
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
public class PBajoNivel extends MIDlet {
private BajoNivel panCanvas;
private Display pantalla;
public PBajoNivel() throws Exception{
pantalla = Display.getDisplay(this);
panCanvas = new BajoNivel(this);
}
public void startApp() {
pantalla.setCurrent(panCanvas);
}
public void pauseApp() {
}
public void destroyApp(boolean unconditional) {
}
public void salir(){
destroyApp(false);
notifyDestroyed();
}
}


Como se observa, PBajoNivel.java se limita a declarar un objeto pancanvas heredado de la clase BajoNivel.


Veamos dos ejemplos de ejecutar ésta aplicación en dos modelos distintos de cellular, a fin de que el lector pueda constatar la diferencia de despliegue entre uno y el otro.












Sunday, November 23, 2008

EL RESTO DE LAS INTERFACES

En las útimas dos entregas, hemos visto el uso de dos componentes para el uso de menús, vimos la clase LIST y CHOICEGROUP; vimos que básicamente la diferencia entre ambas es que la clase LIST no está subordinada a la clase FORM; ésto es, que no es necesario crear primero un objeto tipo FORM para luego agregar el objeto LIST.



private Display display;

private List miLista;

...

display = Display.getDisplay(this);

miLista = new List("Opciones", List.IMPLICIT);
miLista.append("Altas", null);
miLista.append("Bajas", null);
miLista.append("Consultas", null);
miLista.append("Modificaciones", null);
miLista.append("Impresion", null);
...


display.setCurrent(miLista);



Mientras que un objeto CHOICEGROUP debe estar unido a un objeto FORM.



private Display miDisplay;
private Form miForma;
private ChoiceGroup miGrupo;


...

miDisplay = Display.getDisplay(this);
miForma = new Form("MENU PRINCIPAL");


...

miGrupo = new ChoiceGroup("Opciones: ", ChoiceGroup.EXCLUSIVE);
miGrupo.append("Altas", null);
miGrupo.append("Bajas", null);
miGrupo.append("Consultas", null);
miGrupo.append("Modificaciones", null);
miGrupo.append("Impresion", null);


...

miForma.append(miGrupo);

...
display.setCurrent(miLista);




Pero además de estas clases contamos con muchas otras más como...


Class Ticker

Util para mostrar mensajes en forma de una marquesina deslizándote lado a lado de la pantalla del usuario.


Class DateField

Util para manejar fechas, ya sea para despliegue o para solicitar al usuario que proporcione una fecha en específico.



Class ImageItem

Util para trabajar con archivos de imágenes en nuestra aplicación. Ya lo veremos más adelante pero con esta herramienta podremos agregarle un atractivo visual que lo haga más amigable y agradable para el usuario.


Class TextField

Util para manejar texto; que puede ser de despliegue solamente o bien, para pedir al usuario que teclee datos. Como pueden password, números, nombres, etc.



Hay que recordar que las clases gráficas de alto nivel, tienen la facilidad de que se adaptan al tipo de despliegue con que cuenta el dispositivo en el cual estamos trabajando.

En otras palabras, nosotros llamamos las clases y creamos los objetos en nuestra aplicación, pero la presentación visual queda bajo el control del hardware.



Veamos ahora, el uso de las clases que acabamos de mencionar, en un ejemplo.


import java.io.IOException;
import java.util.Date;
import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.CommandListener;
import javax.microedition.lcdui.DateField;
import javax.microedition.lcdui.Display;
import javax.microedition.lcdui.Displayable;
import javax.microedition.lcdui.Form;
import javax.microedition.lcdui.Image;
import javax.microedition.lcdui.ImageItem;
import javax.microedition.lcdui.Item;
import javax.microedition.lcdui.ItemStateListener;
import javax.microedition.lcdui.TextField;
import javax.microedition.lcdui.Ticker;
import javax.microedition.midlet.MIDlet;
import javax.microedition.midlet.MIDletStateChangeException;



public class MIDOtros extends MIDlet implements CommandListener, ItemStateListener {
private Ticker miMarquesina;
private DateField miFecha;
private ImageItem miImagen;
private TextField miHumor;
private Image imgSerio, imgFeliz, imgTriste;
private Command Salir;
private Display miDisplay;
private Form miForma;


public MIDOtros() {
try {
imgSerio = Image.createImage("/serio.PNG");
imgFeliz = Image.createImage("/feliz.PNG");
imgTriste = Image.createImage("/triste.PNG");
} catch (IOException e) {
e.printStackTrace();
}


Date wHoy = new Date();
miDisplay = Display.getDisplay(this);
miFecha = new DateField("Dia de hoy",DateField.DATE);
miFecha.setDate(wHoy);
miHumor = new TextField("% de Animo", "50", 2, TextField.NUMERIC);
miMarquesina = new Ticker("Ejemplo de Graficos de Alto Nivel. Tutorial para el Desarrollo de aplicaciones en móviles, País México. Noviembre del 2008");
miForma = new Form("Otros Items");
Salir = new Command("Salir", Command.EXIT, 0);
miImagen = new ImageItem(null, imgSerio, 0, null);
miForma.setTicker(miMarquesina);
miForma.append(miFecha);
miForma.append(miImagen);
miForma.append(miHumor);
miForma.addCommand(Salir);
miForma.setCommandListener(this);
miForma.setItemStateListener(this);
}


protected void destroyApp(boolean arg0) throws MIDletStateChangeException {
}


protected void pauseApp() {
}


protected void startApp() throws MIDletStateChangeException {
this.miDisplay.setCurrent(this.miForma);
}


public void commandAction(Command arg0, Displayable arg1) {
if (arg0 == Salir){
try {
destroyApp(false);
} catch (MIDletStateChangeException e) {
e.printStackTrace();
}
notifyDestroyed();
}
}


public void itemStateChanged(Item arg0) {
if (arg0 == miHumor){
int wValor = Integer.parseInt(miHumor.getString());
if (wValor <> 70) {
miImagen.setImage(imgFeliz);
} else {
miImagen.setImage(imgSerio);
}
}
}
}
}




Como se observa, en esta aplicación manejamos archivos de imagen :


imgSerio = Image.createImage("/serio.PNG");
imgFeliz = Image.createImage("/feliz.PNG");
imgTriste = Image.createImage("/triste.PNG");




Que son archivos tipo PNG, este tipo nos permite manejar imágenes con una buena y razonable resolución y almacenarlos en poco espacio.
Bien, una vez compilado nuestro código; podemos ejecutarlo y verlo en acción.

Tuesday, November 4, 2008

EN JAVA TODO ES UN OBJETO




Bueno, ahora que ya tenemos casi todas las herramientas que necesitamos para el desarrollo de aplicaciones para móviles, veamos un poco más de teoría para asegurarnos de que vamos a empezar con el pie derecho.

Lo primero que tenemos que conocer, son los OBJETOS.

¿QUE SON LOS OBJETOS ?

Como se puede ver en la imagen anterior, para poder fabricar los objetos Reloj y Lámpara, se necesita la información pregrabada llamada clases.

Las clases son las que almacenan las propiedades y métodos que contendrá un objeto.

Un objeto cambiará sus propiedades o las propiedades de otros objetos por medio de los métodos.
Los métodos que sólo pueden ejecutarse cuando el objeto existe, son los denominados dinámicos, y los métodos que pertenecen a la clase son denominados estáticos, porque pueden ser llamados sin necesidad de la existencia de un objeto.

En el ejemplo tenemos dos objetos, Reloj y Lámpara los cuales tienen métodos Cuerda e Interruptor, que son los que cambiaran el estado de las propiedades Hora e Ilumina. La clase reloj, podría tener un método estático llamado poner_en_hora, para ajustar todos los relojes fabricados.
Un programa en ejecución inicia en un método estático ya que no existen inicialmente objetos en nuestra aplicación, este método se llama main el cuál se define como:

public static void main(String[] args){
.....
}
Donde args es un vector o arreglo unidimensional que contendrá los argumentos que hayan sido pasados al comando java después de las órdenes y el nombre de la clase principal que alojará este método. El entorno de ejecución o la JVM fabricará objetos de sistema que podrán ser utilizados llamando a métodos estáticos de clases pertenecientes a la biblioteca de java.

Veamos un sencillo ejemplo, imaginemos que tenemos que crear un objeto llamado ALUMNO, todo objeto alumno debe tener las siguientes propiedades : NOMBRE, EDAD y GRADO.

Como métodos, podría tener PonNombre, PonEdad, PonGrado y DatosCompletos.

Escribamos entonces la definición de la clase para el objeto ALUMNO.

Alumno.java

public class Alumno {
String wNombre;
int wEdad;
String wGrado;

public Alumno() {
this.wNombre = "Desconocido";
this.wEdad = 0;
this.wGrado = "Desconocido";
}

public void PonNombre(String wNombre) {
this.wNombre = wNombre;
}

public void PonEdad(int wEdad) {
this.wEdad = wEdad;
}

public void PonGrado(String wGrado){
this.wGrado = wGrado;
}

public void DatosCompletos(String wNombre, int wEdad, String wGrado){
this.wNombre = wNombre;
this.wEdad = wEdad;
this.wGrado = wGrado;
}
}

Ahora que ya tenemos la definición de la clase Alumno, escribamos el código que utilice esta clase y fabrique objetos alumno.

Primero.java

public class Primero {

public Primero(){
}

public static void main(String[] args) {
Alumno miObjeto = new Alumno();

System.out.println("Primera parte....");
System.out.println("Nombre = " + miObjeto.wNombre); System.out.println("Edad = " + miObjeto.wEdad);
System.out.println("Grado = " + miObjeto.wGrado);
System.out.println("Tipo = " + miObjeto.getClass().toString());
System.out.println("\n");

miObjeto.wNombre = "Epigmenio Corrales";
miObjeto.wEdad = 45;
miObjeto.wPuesto = "Grado Doctorado";
System.out.println("Segunda parte....");
System.out.println("Nombre = " + miObjeto.wNombre);
System.out.println("Edad = " + miObjeto.wEdad);
System.out.println("Grado = " + miObjeto.wGrado);
System.out.println("\n");

miObjeto.DatosCompletos("Casildo Ortega Del Monte", 23, "Segundo Grado Maestría");
System.out.println("Tercera parte....");
System.out.println("Nombre = " + miObjeto.wNombre);
System.out.println("Edad = " + miObjeto.wEdad);
System.out.println("Grado = " + miObjeto.wGrado);
}
}

Si ejecutamos este sencillo código que hemos ejecutado, obtendremos un resultado en pantalla como el que sigue:

Primera parte....
Nombre = Desconocido
Edad = 0
Grado = Desconocido
Tipo = class Alumno

Segunda parte....
Nombre = Epigmenio Corrales
Edad = 45
Grado = Grado Doctorado

Tercera parte....
Nombre = Casildo Ortega Del Monte
Edad = 23
Grado = Segundo Grado Maestría

Muy bien, después de este breve y pequeño recordatorio de Java, la definición de Clases y la creación de Objetos; estamos listos para abordar de lleno el tema del J2ME.