Java

Vamos a ver cómo organizar los programas Java, en clases u objetos como prefiramos llamarlos. Cómo dividir los códigos fuentes en distintos ficheros o cómo plantearse la creación de un programa bien grande estructurándolo para poder hacerlo poco a poco, repartiendo el trabajo o haciéndolo en partes más simples.

Todo son clases en Java, y estas clases se organizan packetes, llamados packages en inglés. Podemos crear clases a partir de otras clases utilizando el extends. Y cada clase la podemos separar individualmente en cada fichero. Por otro lado los paquetes de clases los podemos importar para usarlos en una clase mediante la instrucción import. Resumiendo ésto es todo, a continuación lo veremos explicado.


Cada fichero se debe nombrar con el nombre de la clase principal. Un ejemplo que nos va a servir para comprender varios conceptos es el siguiente:


package javaMedio;

import java.util.Date;

public class JavaMedio1ClasesPaquetes {

public static void main(String[] args) {
Persona p = new Persona();
p.nombre = «Pepito»;
p.escribir();
}

}

class Persona {
String nombre = new String();
Date fechaCreacion = new Date();

public void escribir() {
String aux = new String();
aux = «Objeto de tipo Persona con nombre: » + nombre + «n» 
+ «Creado en fecha: » + fechaCreacion;
System.out.println(aux);
}
}

Éste programa de aquí arriba debemos guardarlo en un fichero llamado JavaMedio1ClasesPaquetes.java para que funcione y no nos de error. Para empezar escribimos el paquete al que pertenece una clase mediante una línea como la que sigue:

package JavaMedio;

Podemos tener muchas clases dentro del paquete JavaMedio, y si queremos usar todas las clases del paquete en una nueva clase deberemos importar el paquete mediante la instrucción import. En el ejemplo, a continuación, vemos que se ha importado la clase fecha (Date en inglés), que está dentro del paquete de utilidades que proporciona Java de la siguiente manera:

import java.util.Date;

Si queremos importar todas las utilidades de Java, lo haríamos de la forma siguiente:

import java.util.*;

A continuación se declara la clase principal con la función main principal, porque es una aplicación de consola, es decir, se ejecuta en línea de comandos:


public class JavaMedio1ClasesPaquetes {

public static void main(String[] args) {
Persona p = new Persona();
p.nombre = «Pepito»;
p.escribir();
}

}

Podemos leer la clase JavaMedio1ClasesPaquetes es una clase pública, es así porque tiene el main. Y dentro del main tenemos que se declara la variable p de tipo Persona, se reserva memoria, se le pone el nombre Pepito y a continuación se llama a la función escribir() de la clase Persona.

Hay varios tipos de clases que son: abstract, final, public y synchronizable. Abstract son clases que se usan para hacer otras con ellas. Final son clases con las que no se pueden hacer otras a partir de ellas. Las public son las normales. Y las synchronizable son clases que no se pueden usar en paralelo desde dos hilos de ejecución distintos. Para más información sobre las clases de tipo synchronizable acudir a la programación multihilos de Java.

En la declaración de la clase Persona podemos ver que no es una clase pública, esto se hace así porque la he puesto dentro del mismo fichero, y no debe haber más que una clase pública en cada fichero. Vamos a analizar el código de la clase:


class Persona {
String nombre = new String();
Date fechaCreacion = new Date();

public void escribir() {
String aux = new String();
aux = «Objeto de tipo Persona con nombre: » + nombre + «n» 
+ «Creado en fecha: » + fechaCreacion;
System.out.println(aux);
}
}

Vemos que la clase Persona tiene dos variables: nombre y fechaCreacion. Y tiene una función pública: escribir(). La función lo que hace es escribir las variables internas de Persona. La variable nombre podemos acceder a ella desde fuera, es decir, es pública, como podemos observar en el main:

p.nombre = «Pepito»;

Ésta instrucción nos lo permite. Siempre que una variable no se le ponga el tipo de control de acceso permitido, se supone pública. Podríamos haber escrito mejor en la clase Persona:


class Persona {
public String nombre = new String();
public Date fechaCreacion = new Date();
…

Así estaría más claro el nivel de acceso desde fuera de la clase.

El control de acceso dentro de una clase se especifica mediante las palabras public, protected y private. Public indica que la variable o función se puede usar desde fuera. Private es lo contrario que public, protected indica que sólo acceder si la clase que accede es del mismo paquete.

Si queremos usar la clase Persona desde otras clases o ficheros deberíamos separar en un fichero la clase, quedaría un fichero llamado Persona.java que tendría lo siguiente:

package javaMedio;

import java.util.Date;

public class Persona {
public String nombre = new String();
public Date fechaCreacion = new Date();

public void escribir() {
String aux = new String();
aux = «Objeto de tipo Persona con nombre: » + nombre + «n»
+ «Creado en fecha: » + fechaCreacion;
System.out.println(aux);
}

}

Podemos ver que tanto la clase JavaMedio1ClasesPaquetes como Persona están en el mismo paquete, entonces para usar Persona en el fichero JavaMedio1ClasesPaquetes.java no hace falta usar el import.

Para terminar, saber que algunos de los paquetes principales que proporciona Java son los siguientes para el que quiera continuar investigando:

java.applet Para la creación de Applets.
java.io Para manejo de la entrada y salida.
java.lang Paquete de clases variadas.
java.net Aquí tenemos clases que usan TCP/IP.
java.util Utilidades variadas.
java.awt Para hacer interfaces de usuario con botones, ventanas, etcétera.
java.swing Más compatible con los distintos Sistemas Operativos que la AWT, yo usaría ésta en vez de la AWT porque te aseguras de que tu programa va a funcionar en más plataformas.

Por ahora queda terminado este minitutorial sobre clases y paquetes.
Saludos;}

Ya estamos a domingo de nuevo, parece que va siendo costumbre los domingos de nuevo escribir un post. Vamos a empezar con un tipo de variables que vamos a usar para almacenar muchos datos de igual naturaleza, es decir, los llamados vectores y matrices. Algunos llaman a los vectores matrices también porque son matrices de una sola fila.

Imaginemos pues que queremos guardar 3 elementos de tipo entero. Para ello usaremos lo siguiente:

package javaBasico;

public class JavaBasico6Matrix {

public static void main(String[] args) {

// declaración de la variable ‘vector’
int vector[];

// se reserva memoria para guardar los 
// valores, es decir, guardamos 3 posiciones
// de memoria de tipo entero
vector = new int[3];

// guardamos en la posición 0 el número 2
vector[0] = 2;

// guardamos…
vector[1] = 3;

// guardamos…
vector[2] = 4;

// escribimos en el out (pantalla) el vector
System.out.println(vector[0] + «, » + vector[1] + «, » + vector[2]);

}

}

En Java siempre los vectores y matrices, también las clases que hagamos primero hay que declararlas y luego se les reserva memoria para poder usarlas. Es decir, la primera parte es decirle al programa que vamos a usar una variable, que le llamamos ‘vector’, y que va a ser un vector de enteros. Lo siguiente es realmente reservar una parte de la memoria del ordenador para guardar esos números enteros.

Internamente el Sistema Operativo se encarga de la reserva de memoria, generalmente es en memoria principal (la RAM o caché). Hay que acordarse, siempre se declara, luego se reserva memoria. La memoria se libera automáticamente porque Java tiene un sistema por el que todas las variables usadas en una clase se borran en memoria cuando la vida de la clase ha terminado.

Los tipos de datos primitivos sólo se declaran y directamente se utilizan sin tener que reservar memoria, ésta es una diferencia básica.

Vamos ahora con las matrices.

Si queremos por ejemplo almacenar valores como hacemos en una hoja de Excel, ordenando por filas y columnas, podemos usar una variable ‘matriz’ de la forma siguiente:


package javaBasico;

public class JavaBasico6Matrix {

public static void main(String[] args) {

// declaración de la variable
int matriz[][];

// se reserva memoria 
matriz = new int[2][2];

// guardamos…
matriz[0][0] = 2;

// guardamos…
matriz[0][1] = 3;

// guardamos…
matriz[1][0] = 4;

// guardamos…
matriz[1][1] = 5;

// escribimos en el out 
System.out.println(matriz[0][0] + «, » + matriz[0][1]);
System.out.println(matriz[1][0] + «, » + matriz[1][1]);

}

}

Es igual que un vector pero ahora tenemos dos coordenadas, donde pone: matriz[a][b]
a y b son las coordenadas.

Hay que fijarse en que en la reserva de memoria se le dice el tamaño o número de posiciones, pero a la hora de usar la variable, comenzamos por la posición 0 como primera posición. Ésto puede llevar a confusión porque la última posición de la matriz por ejemplo, no es matriz[2][2], sino es matriz[1][1], porque hemos empezado por matriz[0][0].

Falta decir que en un vector o en una matriz podemos poner enteros, decimales, o incluso objetos de la clase que queramos, por ejemplo:

package javaBasico;

class Persona {
// ésta es una clase que
// de momento son
String nombre;
int edad;
}

public class JavaBasico6Matrix {

public static void main(String[] args) {

// declaración de la variable 
Persona personas[];

// se reserva memoria 
personas = new Persona[20];

}

}

Hola! hoy es domingo, tengo un rato libre, y he pensado avanzar un poco este curso de programación rápido con las funciones. Vamos a ver en líneas generales cómo dividir el código de nuestro programa para que sea más fácil luego leerlo, para desarrollarlo en partes o poco a poco, en fin, es de buena costumbre usar funciones cuando hacemos tareas que usan mas de unas 20 líneas de código.

Es decir, comenzamos escribiendo código en el ‘main’, y llegado el momento de que nuestro ‘main’ ocupa muchas líneas entonces se convierte en un mamotreto de código que es bien complicado de leer. Para evitar ésto lo dividimos con funciones como por ejemplo puede ser el código siguiente:

public class JavaBasico4Funciones {

public static void main(String[] args) {

PrincipioDelPrograma();

HacerCosa1();
HacerCosa2();
HacerCosa3();

FinalDelPrograma();

}

static void PrincipioDelPrograma(){

}

static void HacerCosa1(){

}

static void HacerCosa2(){

}

static void HacerCosa3(){

}

static void FinalDelPrograma(){

}

}

De ésta manera queda más claro todo y podemos centrarnos en hacer los subprogramas declarados en las funciones. Éste es un ejemplo claro de la técnica de programación ‘Divide y vencerás’.

También puede ocurrir que estamos escribiendo un programa y llegamos a un momento en que nos bloqueamos. Por ejemplo:

…
// un montón de líneas de código..
// llegamos al momento en que imprimimos el resultado
System.out.println(«El resultado es:»);
System.out.println(…

Ahora aquí deberíamos de imprimir el resultado del programa pero no sabemos cómo calcularlo, nos estan saltando chispas del cerebro, entonces ponemos:

System.out.println(ResultadoDelPrograma());

Y ya más adelante cuando tengamos la mente más fresca lo resolvemos programando la función que acabamos de poner aquí arriba:

static String ResultadoDelPrograma() {
// aquí dentro va el subprograma que calcula el resultado
}

Las funciones pueden recibir variables, y también pueden devolver resultados o escribir en dichas variables. Para crear una función que recibe parámetros podemos verlo claro en el siguiente ejemplo:

static void Sumar(int a, int b) {
int resultado;
resultado = a + b;
System.out.println(a + » + » + b + » = » + resultado);
}

La forma de usar ésta función en el main podría ser:

Sumar(1,2);

Lo que escribirá por pantalla: 1 + 2 = 3

Si queremos devolver un valor con una función podríamos modificar la anterior de la forma:

static int Sumar2(int a, int b) {
int resultado;
resultado = a + b;
return resultado;
}

Sábado por la mañana, hace buena temperatura ahora en otoño, ni frio ni calor en Alicante. Así da gusto. Pues hoy voy a darle vueltas a los bucles y a controlar qué se ejecuta en un pequeño programa en Java.

Vamos a ver los bucles y las estructuras principales que se usan. Éstos son los if, else, switch, while, do while, for, break, continue y el try-catch para control de errores de ejecución.

Vamos al grano, si usamos el siguiente código:

// Paquete donde se organiza ésta clase de Java
package javaBasico;


// Declaración de la clase con su nombre
public class JavaBasico3BuclesEstructuras {

// Entrada principal al programa, el main para los amigos
public static void main(String[] args) {

// Aquí va el código que empieza nada más 
// arrancar el programa
System.out.println(«¡Hola Mundo!»);

// declaro la variable a y le doy valor
byte a = 1; 

// el if sirve para comprobar si ocurre
// una cosa…
if (a == 2) {

// si a vale 2 entonces hace ésto
System.out.println(«a sí vale 2»);

} else {

// si a no vale 2 muestra éste mensaje
System.out.println(«a no vale 2»);

}

// switch sirve para hacer una lista de 
// casos posibles
switch (a) {
case 1: // caso de que a valga 1
System.out.println(«a vale 1»);
break;
case 2: // ..
System.out.println(«a vale 2»);
break;
case 3: // ..
System.out.println(«a vale 3»);
break;
default:
break;
}

a = 0;

// el while repite lo que tenemos entre 
// llaves mientras se cumpla la
// condición
while (a != 10) {
a++;
System.out.println(«a = » + a);
}

// éste bucle es parecido al anterior
// pero comprueba si a > 5 después de ejecutar 
// una vez lo que hay entre llaves
do {
System.out.println(«a ahora vale » + a);
a–;
} while (a > 5);

short b;

// ésta parte del código intenta ejecutarse
// try significa ejecutar
try {

b = 0;
a = (byte) ((byte) 1 / b);

} catch (Exception e) {

// si ocurre algún error en el try
// ejecuta
// lo siguiente
System.out.println(«ERROR: « + e.getMessage());

}

// mensaje de fin de programa…
System.out.println(«Ha terminado el programa…»);
}
}

El código está comentado, espero que no sea demasiado de golpe, si estas empezando con ésto de la programación y te complicas mucho no dudes en comentar el post y gustoso lo aclaro.

Éstas son las formas sencillas de estructurar los programas para que hagan tareas cuando se cumplan ciertas condiciones de algunas variables. También se utilizan para tareas repetitivas los bucles. Con ésto y las funciones podremos estructurar nuestros programas de manera dividamos el problema en subproblemas más sencillos de solucionar.

Divide y vencerás

Ésta forma de afrontar los problemas de programación se utiliza mucho.

El try-catch necesita de una especial mención porque es una estructura para controlar los posibles que pueden suceder en un programa y evitar así que se queden colgados, terminen inesperadamente y en definitiva la tarea no se termine. El try-catch tiene muchas opciones pero necesitaría de otro post para ello así que tal vez en un futuro.

Espero que sirva para aclarar algo a los nuevos, o para repasar a los veteranos.
Un saludo

En éste post vamos a ver los tipos de datos primitivos, los básicos, sobre los que se construirán datos u objetos más complejos o complicados, valga la redundancia. Los más usuales son:

• byte, que permite almacenar número de 8 bits, negativos y positivos. Es decir desde el -11111111 al +11111111, o que es lo mismo que desde -128 al +127.
• short, es igual que el byte pero en vez de 8 bits con signo tenemos 16 bits. Aumentan considerablemente la contidad de números posibles que van desde el -32768 al +32767.
• int, es igual pero ahora tenemos 32 bits.
• long, ahora tenemos 64 bits.
• char, guarda valores del 0 al 65535. Los primeros valores corresponden a los caracteres ASCII, que son los caracteres normales que usamos al escribir, es decir, las letras. Por ejemplo el 97 es la ‘a’
• float, se utiliza para números decimales. Se utilizan 32 bits, con una precisión aproximada de 7 dígitos.
• double, es un número decimal. Internamente se usan 64 bits, con lo que se tiene una mayor precisión, aproximadamente de unos 16 dígitos.
• boolean, se usa para almacenar un valor booleano, es decir, verdadero o falso.

Aquí dejo la estructura básico de un programa mínimo en Java, el clásico ‘Hola Mundo’. Suponemos que ya estamos familiarizados con nuestro IDE de desarrollo favorito, así que iremos al grano. Creamos una nueva clase, yo la he llamado JavaBasico1HolaMundo, está creada dentro del paquete de código javaBasico, con lo que el fichero del programa se llama JavaBasico1HolaMundo.java y su contenido es el siguiente: