pello.ioPosts
Variables de Caracteres, char
En java también existen las variables tipo char, como en el c de toda la vida. Son variables que contienen un único caracter alfabético o especial.
/**
* ValoresCaracteres
* Clase que muestra la declaración de variables de caracteres
*
* Para compilar:
* javac ValoresCaracteres.java
*
* Para ejecutarlo:
* java ValoresCaracteres
*/
/**
* clase ValoresCaracteres
* Muestra la declaración de booleanos: son variables que solo
* pueden contener un caracter, encerrado en comillas simples
* por ejemplo 'a'
*
* @author Pello Altadill
*/
public class ValoresCaracteres {
/**
* main
* Función principal
* esta función es la que se inicia directamente al ejecutar el programa
*/
public static void main (String args[])
{
// Solo pueden ser true o false
char caracter = 'A';
char ultima = 'z';
// Los especiales comienzan por \
char nuevaLinea = '\n';
char tabulacion = '\t';
char retornoCarro = '\r';
char comillaSimple = '\'';
char contrabarra = '\\';
char dobleComillas = '\"';
char formFeed = '\f';
// Vamos a probar a mostrarlos por pantalla: concatenamos con +
System.out.println("Primera letra " + caracter + " y última: " + ultima);
System.out.println("Con la \\ usamos caracteres especiales");
System.out.println("Que parezca un \"accidente\" ");
System.out.println("Vamos a saltar \n y ahora otra vez: " + nuevaLinea);
System.out.println(tabulacion + " Vamos a ver: " + nuevaLinea + " y ahora \r");
}
}
Variables Reales
Así se manejan las variables numéricas de números reales. Atención a las constantes float.
/**
* ValoresReales
* Clase que muestra la declaración de variables numéricas <b>de coma flotante</b>
*
* Para compilar:
* javac ValoresReales.java
*
* Para ejecutarlo:
* java ValoresReales
*/
/**
* clase ValoresReales
* Muestra la declaración de tipos numéricos reales o de coma flotante:
* float : real precisión simple, 4 bytes
* double : real precisión doble, 4 bytes
*
* @author Pello Altadill
*/
public class ValoresReales {
/**
* main
* Función principal
* esta función es la que se inicia directamente al ejecutar el programa
*/
public static void main (String args[])
{
// En los tipos reales debemo usar un . en lugar de , para las decimales
float temperatura;
// Al asginar valor le ponemos la F para distinguir del tipo double
float peso = 78.9F;
double saldoCuentaCorriente = 3423343.43D;
// Los valores altos se pueden abreviar:
// esto sería 4.6 multiplicado por 10 elevado a 9.
double masaJupiter = 4.6E+9D;
// Vamos a probar a mostrarlos por pantalla: concatenamos con +
System.out.println("Tu peso es : " + peso + ", y tu saldo: " + saldoCuentaCorriente);
System.out.println("La masa de Jupiter: " + masaJupiter);
}
}
Variables Numéricas enteras
Este es un ejemplo de declaración de variables numéricas
/**
* ValoresEnteros
* Clase que muestra la declaración de variables numéricas enteras
*
* Para compilar:
* javac ValoresEnteros.java
*
* Para ejecutarlo:
* java ValoresEnteros
*/
// Librería necesaria para trabajar con la entrada/salida
import java.io.*;
/**
* clase ValoresEnteros
* Muestra la declaración de tipos numéricos enteros básicos:
* byte : 1 byte
* short : entero corto, 2 bytes
* int : enter, 4 bytes
* long : entero largo, 8 bytes
*
* @author Pello Altadill
*/
public class ValoresEnteros {
/**
* main
* Función principal
* esta función es la que se inicia directamente al ejecutar el programa
*/
public static void main (String args[])
{
// Declaración de variables: tipo nombre;
byte dias;
short contador;
// Declaración y asignación de valor
// tipo nombre = valor inicial;
short resultado = 42;
// Declaración de varias variables del mismo tipo
short codigo, edad, media;
// Declaración y asignación a varias a la vez:
int i, j, k;
i = j = k = 0;
// El tipo long
long sueldoFutbolista = 23489343;
long valorGoogle = 666000666;
// Vamos a probar a mostrarlos por pantalla: concatenamos con +
System.out.println("El sentido de la vida es: " + resultado);
System.out.println("El sueldo de un futbolista medio es: " + sueldoFutbolista);
}
}
Javajutsu: Argumentos por consola en java
Vamos a ver cómo se recogen argumentos por la línea de comandos. Se hace igual que en c
/**
* Argumentos
* Clase que muestra cómo recoger argumentos de la línea de comandos
*
* Para compilar:
* javac Argumentos.java
*
* Para ejecutarlo:
* java Argumentos argumento
*/
// Librería necesaria para trabajar con la entrada/salida
import java.io.*;
/**
* clase Argumentos
* Muestra cómo recoger parámetros de la linea de comandos
* es decir, cuando ejecutamos el programa:
* java Argumentos ejemplo_de_argumento
* tras el nombre del programa podemos poner lo que queramos como
* parámetro. Para recoger los valores usaremos la variable args[]
*
* @author Pello Altadill
*/
public class Argumentos {
/**
* main
* Función principal
* esta función es la que se inicia directamente al ejecutar el programa
*/
public static void main (String args[])
{
// Vamos a suponer que nos han pasado algún argumento,
// Los argumentos los recoge automáticamente la variable
// args[]. El primer argumento sería args[0], el segundo args[1], etc...
System.out.println("¡Hola Mundo! me has pasado: " + args[0]);
// Lo pasariamos así:
// C:\jdk>java Argumentos blablabla
// ATENCIÓN, si NO le pasamos nada el programa casca con una excepción
}
}
JavaJutsu
Bueno, llegó la hora de darle al java. A lo largo de las siguientes entradas iremos conociendo este lenguaje y algunas herramientas de desarrollo.
Empezaremos con los simple, con las manos desnudas, editor, compilador y línea de comandos. Y poco a poco iremos conociendo las herramientas de poder
/**
* HolaMundo
* Clase que simplemente muestra un mensaje por pantalla
*
* Para compilar:
* javac HolaMundo.java
*
* Para ejecutarlo:
* java HolaMundo
*/
Una referencia es otra forma de acceder a un dato, una especie de alias. Cualquier operacion sobre una referencia afectara a ese dato al que hace referencia.
<?xml version="1.0"?>
<!-- NOTA: Asegúrate de que el fichero lo editas en utf-8 -->
<!-- NOTA: conviene hacer clean y luego compilar -->
<!-- Para generar: ant [tarea] o ant -buildfile [fichero.xml] [tarea] -->
<project name="build.xml de ejemplo" default="pasartest" basedir=".">
<property name="dir.src" value="src"/>
<property name="dir.build" value="build"/>
<property name="dir.dist" value="dist"/>
<!-- Genera los directorios de salida: ant preparar -->
<target name="preparar" description="Crea los directorios">
<mkdir dir="${dir.build}"/>
<mkdir dir="${dir.dist}"/>
</target>
<!-- Elimina todo lo creado: ant clean -->
<target name="clean" description="Elimina todos los ficheros generados">
<delete dir="${dir.build}"/>
<delete dir="${dir.dist}"/>
</target>
<!-- Compilación, primero hace la tarea preparar: ant compilar -->
<target name="compilar" depends="preparar" description="Compilar todo.">
<javac srcdir="${dir.src}" destdir="${dir.build}"/>
</target>
<!-- Establece el classpath -->
<path id="classpath.proyecto">
<pathelement path="${dir.build}"/>
</path>
<!-- Ejecuta los test unitarios -->
<target name="pasartest" depends="compilar" description="Ejecutar test junit">
<junit printsummary="on"
fork="false"
haltonfailure="false"
failureproperty="tests.failed"
showoutput="true">
<classpath refid="classpath.proyecto"/>
<formatter type="brief" usefile="false"/>
<batchtest>
<fileset dir="${dir.src}">
<include name="**/Test*.java"/>
</fileset>
</batchtest>
</junit>
<fail if="tests.failed">
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
ATENCIÓN. HAN CASCADO ALGUNOS TESTS.
ECHA UN OJO A LOS RESULTADOS.
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
</fail>
</target>
<!-- Genera un fichero jar, depende de la tarea compile: ant jar -->
<target name="jar" depends="compilar" description="Genera un fichero jar en el directorio 'dist'.">
<jar jarfile="${dir.dist}/proyecto.jar" basedir="${dir.build}"/>
</target>
</project>
Este midlet tiene varias partes:
- Por un lado está el Midlet o aplicación para el móvil
- Una clase tipo Canvas para hacer los gráficos
- Una clase hilo que se utiliza para que el canvas pinte una y otra vez con pausas.
/*
* RandomCircles
* Midlet que usa una pantalla de tipo Canvas para crear gráficos
*/
package hello;
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
import java.util.*;
public class InfiniteCircles extends MIDlet implements CommandListener {
private Command exitCommand;
private Display pantalla;
private CanvasForInfinite screen;
private Repainter repintar;
public InfiniteCircles () {
// Tomamos la pantalla
pantalla = Display.getDisplay(this);
// Creamos el comando para salir
exitCommand = new Command("Exit", Command.EXIT, 2);
// Asociamos a Screen nuestro Canvas especial
screen = new CanvasForInfinite();
// Establecemos el comando para salir
screen.addCommand(exitCommand);
screen.setCommandListener(this);
repintar = new Repainter(pantalla,screen);
}
/**
* startApp
* se ejecuta al inicio de la aplicación
*/
public void startApp() throws MIDletStateChangeException {
// Establecemos el formulario en la pantalla
pantalla.setCurrent(screen);
repintar.start();
}
/**
* pauseApp
* se ejecuta en caso de pausar la aplicación
*/
public void pauseApp() {
}
/**
* destroyApp
* se ejecuta al terminar la aplicación
*/
public void destroyApp(boolean unconditional) {
}
public void commandAction(Command c, Displayable s) {
if (c == exitCommand) {
destroyApp(false);
notifyDestroyed();
}
}
}
class CanvasForInfinite extends Canvas {
// Dentro de canvas debe existir esta función
public void paint(Graphics g) {
// Declaramos variables para coordenadas, anchura, altura y radio
int x,y,w,h,r,maxx, maxy;
// Variable para generar números aleatorios
Random rnd = new Random();
maxx= maxy = x = y = w = h = r = 0;
maxx = this.getWidth();
maxy = this.getHeight();
//try {
for (int i = 0;i<5;i++)
{
// Establecemos color (r,g,b)
g.setColor( rnd.nextInt(255), rnd.nextInt(255), rnd.nextInt(255));
//g.drawArc(rnd.nextInt(maxx), rnd.nextInt(maxy), maxx/2, maxy/2, 0, 360);
// Para hacer estrellas
//g.drawArc(rnd.nextInt(maxx), rnd.nextInt(maxy), 1, 1, 0, 360);
g.drawArc(rnd.nextInt(maxx), rnd.nextInt(maxy), rnd.nextInt(4), rnd.nextInt(4), 0, 360);
// dibujamos un arco, completo: 360
//g.drawArc(rnd.nextInt(maxx), rnd.nextInt(maxy), rnd.nextInt(), rnd.nextInt(), 0, 360);
}
//g.drawString("Epa", 0, 0, Graphics.HCENTER | Graphics.TOP);
//g.drawString("Vamos",(getWidth() / 2),0 Graphics.HCENTER | Graphics.TOP);
/*
} catch (InterruptedException iex) {
g.drawString("Excepción: " + iex.getMessage(), 0, 0, Graphics.HCENTER | Graphics.TOP);
}
*/
}
}
//
// Y ahora la clase tipo runnable, es decir, un thread que se ejecuta en paralelo al midlet.
// Sacada de las demos de sun
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package hello;
import javax.microedition.lcdui.Canvas;
import javax.microedition.lcdui.Display;
/**
* Class periodically repainting the canvas with all the balls.
*/
public class Repainter implements Runnable {
/* target display */
private Display display;
/* canvas to repaint */
private Canvas canvas;
/* whether the repainting is stopped */
private boolean stop;
/**
* Creates a new instance of repainter.
*
* @param display Target display
* @param canvas Canvas to repaint
*/
public Repainter (Display display, Canvas canvas) {
this.display = display;
this.canvas = canvas;
}
/**
* Starts the repainter
*/
public void start () {
stop = false;
run ();
}
/**
* Stops the repainter
*/
public void stop () {
stop = true;
}
/**
* Actual repainting process being performed serially with actual display
* updates.
*/
public void run () {
if (stop) {
return;
}
try {
// avoid insane repainting
Thread.sleep (5);
}
catch (InterruptedException e) {
// Never mind
}
canvas.repaint ();
display.callSerially (this);
}
}
Ejemplo de un midlet que saca datos de la red, en concreto haciendo peticiones a una URL.
package hello;
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
import java.io.*;
import javax.microedition.io.*;
/**
* @author luser
*/
public class HttpRequestTest extends MIDlet implements CommandListener {
private Command exitCommand, goCommand, backCommand;
private Display display;
private Form locationScreen;
private Form resultScreen;
private TextField urlField;
private StringItem itemResultado;
/**
* HttpRequestTest
* constructor
*/
public HttpRequestTest ()
{
// Pillamos la pantalla para el MIDlet
display = Display.getDisplay(this);
// Creamos comandos esenciales
exitCommand = new Command("Exit", Command.EXIT, 2);
goCommand = new Command("Go", Command.OK, 2);
backCommand = new Command("Back", Command.BACK, 2);
// Formulario para tomar la URL
locationScreen = new Form("Indica una URL destino");
urlField = new TextField("url", "http://localhost/Test.txt", 25, TextField.ANY);
locationScreen.append(urlField);
// Comandos salida y continuar
locationScreen.addCommand(exitCommand);
locationScreen.addCommand(goCommand);
locationScreen.setCommandListener(this);
// Creamos la pantalla de resultado
resultScreen = new Form("URL data:");
itemResultado = new StringItem("", "");
resultScreen.append(itemResultado);
// Metemos los comandos para volver
resultScreen.addCommand(backCommand);
resultScreen.setCommandListener(this);
}
/**
* startApp
* se ejecuta al inicio de la aplicación
*/
public void startApp() {
// Establecemos el formulario en la pantalla
display.setCurrent(locationScreen);
}
/**
* pauseApp
* se ejecuta en caso de pausar la aplicación
*/
public void pauseApp() {
}
/**
* destroyApp
* se ejecuta al terminar la aplicación
*/
public void destroyApp(boolean unconditional) {
}
/**
* commandAction
* captura los comandos.
*/
public void commandAction(Command c, Displayable s) {
String html = "";
if (c == exitCommand) {
destroyApp(false);
notifyDestroyed();
}
else if (c == goCommand) {
// Llamamos a la función que saca los datos
html = getData(urlField.getString());
display.setCurrent(resultScreen);
itemResultado.setText(html);
}else if (c == backCommand) {
// Volvemos al inicio
display.setCurrent(locationScreen);
}
}
/**
* getData
* Solicita una URL y devuelve un String con el resultado
*/
private String getData(String url) {
StreamConnection conn = null;
InputStream in = null;
StringBuffer data = new StringBuffer();
try {
// Abrimos la conexión así de fácil
conn = (StreamConnection)Connector.open(url);
// Sacamos un InoutStream de la conexión
in = conn.openInputStream();
// Vamos leyendo caracteres y los metemos en un string
int ch;
while (((char)(ch = in.read()) != '\003') && (ch != -1) )
{
data.append((char)ch);
}
// Si está vacío, msg al canto con alert
if (data.toString().equals(""))
{
display.setCurrent(new Alert("Url","En esa URL no retornó nada.", null,AlertType.ERROR));
}
return data.toString();
} catch (IOException e) {
return "La conexión no se pudo establecer:" + e.getMessage();
}
}
}
El conversor de ptas,euros y dolares algo mejorado. Campos que solo admiten números,choices, alertas, dos formularios, etc..
*
* Conversor
* Midlet que convierte monedas en dos formularios
*/
package hello;
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
import java.util.*;
public class Conversor extends MIDlet implements CommandListener {
private Command exitCommand, goCommand, backCommand;
private Display pantalla;
private Form formDatos;
private TextField cantidad;
private ChoiceGroup tipoCambio;
private Form formResultado;
private StringItem resultado;
private Alert errorMsg;
/**
* Conversor
* Constructor del Midlet, inicializa todo
*/
public Conversor() {
// Get the Display object for the MIDlet
pantalla = Display.getDisplay(this);
// Creamos los tres comandos
exitCommand = new Command("Salir", Command.EXIT, 2);
goCommand = new Command("Convertir", Command.OK, 2);
backCommand = new Command("Atrás", Command.BACK, 2);
// Creamos el primer formulario
formDatos = new Form("Introducir cantidad");
// En la cantidad aceptamos solo enteros. Para cualquier
// otra cosa pondriamos TextField.ANY
cantidad = new TextField("Cantidad", "", 15, TextField.NUMERIC);
formDatos.append(cantidad);
String[] cambios = { "€ a pta","pta a €","€ a $","$ a €" };
tipoCambio = new ChoiceGroup("Tipo de cambio", List.EXCLUSIVE,cambios, null);
formDatos.append(tipoCambio);
// Ponemos los comandos para el primer formulario
formDatos.addCommand(exitCommand);
formDatos.addCommand(goCommand);
formDatos.setCommandListener(this);
// Creamos la pantalla para el resultado
formResultado = new Form("Resultado al cambio");
resultado = new StringItem("Resultado:\n", "");
formResultado.append(resultado);
// Establecemos los comandos para volver atrás y salir
formResultado.addCommand(backCommand);
formResultado.addCommand(exitCommand);
formResultado.setCommandListener(this);
}
/**
* startApp
* iniciop del Midlet
*/
public void startApp() throws MIDletStateChangeException {
pantalla.setCurrent(formDatos);
}
/**
* pauseApp
* se invoca si se hace una pausa en la aplicación
*/
public void pauseApp() {
}
/**
* destroyApp
* Se invoca al destruir la aplicación
*/
public void destroyApp(boolean unconditional) {
}
/**
* commandAction
* handler para todos los eventos
*/
public void commandAction(Command c, Displayable s) {
if (c == exitCommand) {
destroyApp(false);
notifyDestroyed();
}
else if (c == goCommand) {
// si no se han metido datos, sacamos un alert y ponemos el foco
if (cantidad.getString().trim().equals(""))
{
errorMsg = new Alert("Atención","Introduce algo en el campo cantidad",null,AlertType.WARNING);
pantalla.setCurrent(errorMsg, formDatos);
return;
}
// Hacemos el cálculo
resultado.setText((calcular(Double.parseDouble(cantidad.getString()),tipoCambio.getSelectedIndex()) )) ;
pantalla.setCurrent(formResultado);
}
else if (c == backCommand)
{
// Hacemos limpia de la pantalla inicial
cantidad.setString("");
// Volvemos al inicio
pantalla.setCurrent(formDatos);
}
}
private String calcular (double cantidad, int tipo)
{
String result = "";
switch (tipo)
{
case 0 :
result = cantidad +"€ = "+ (cantidad*166.386) +"ptas";
break;
case 1 :
result = cantidad +"ptas = "+ (cantidad/166.386) +"€";
break;
case 3 :
result = cantidad +"€ = "+ (cantidad*1.2) +"$";
break;
case 4 :
result = cantidad +"$ = "+ (cantidad/1.2) +"€";
break;
default:
break;
}
return result;
}
}
subscribe via RSS