artbaby game, niños inteligentes y alegres

Aquí tenemos una pequeña review de una app dedicada a los niños pequeños. 

Se llama artbaby game y es una aplicación de juego libre y estimulación temprana destinada a bebés y niños pequeños. Según su creadora su carácter autónomo, intuitivo y multisensorial estimularán al bebé desde el principio y además el juego libre y espontáneo que la caracteriza será muy positivo para que los bebes desarrollen la creatividad, habilidades sociales, etc.

Muchas son las ventajas que se obtienen a la hora de escuchar música, pues con esta app tenemos la posibilidad de exponer a sus usuarios a muchos tipos de música estimulando así en los bebes el lenguaje, coordinación, autoestima, razonamiento, resolución de problemas, etc.

El funcionamiento de la aplicación es sencillo, partimos de una pantalla en blanco y al ir tocando podemos ir dibujando y oyendo música con diferentes colores, instrumentos, figuras, etc. Podemos jugar con 1 dedo o con muchos dedos a la vez cómo lo haría un niño, si solo vamos apretando con un dedo van saliendo imágenes, si lo deslizamos podemos dibujar, si mantenemos apretado las imágenes se hacen más grandes, etc las posibilidades son infinitas y los pequeños estarán muy entretenidos aunque también la pueden usar los adultos perfectamente para relajarse oyendo y creando música.

Para obtener mas información sobre artbaby game lo mejor es visitar su página http://artbabygame.com/inicio/ además existe una versión de prueba para que la probéis y veáis cómo funciona por vosotros mismos.

Depuración y pruebas de unidad

En programación tenemos varios términos importantes que no podemos dejar de lado.

El termino depurar hace referencia al intento de apuntar con precisión un error en el propio código para poder corregirlo.

Una prueba es una actividad que persigue comprobar si un código (un programa, método, etc) produce el comportamiento para el que ha sido diseñado.

Una prueba de unidad es un prueba por partes, es decir dentro de una aplicación se van examinando sus partes por separado, individualmente, para ver si con ellas se obtiene el resultado deseado. Podríamos decir que una prueba de unidad está contrapuesta a una prueba de aplicación ya que esta última prueba la aplicación completa y la prueba de unidad solo una parte concreta.

Es aconsejable ir probando el código a medida que lo vamos construyendo y no esperar a tener terminada la aplicación pues pudiera ser que siguiéramos construyendo sobre errores si no los detectamos teniendo que rehacer el código por completo con la consiguiente perdida de tiempo cuando nos diéramos cuenta del error o errores.

Para probarlo podemos hacer pruebas positivas y también pruebas negativas, las pruebas positivas son aquellas pruebas en las que esperamos que se produzcan casos exitosos en cambio las pruebas negativas son las que se espera que fallen al ejecutarlas.

Por ejemplo una prueba positiva para un método que suma 2 números sería el resultado correcto, le daríamos dos números y haría la operación correctamente. Una prueba negativa para ese mismo método sería introducirle un número y una letra y ver cómo el método da error al no poder sumarlos.

Es común que sólo se realicen pruebas positivas olvidando las pruebas negativas y eso es un error, debemos asegurarnos que nuestras aplicaciones funcionen independientemente de que se le den datos correctos (funcionaría correctamente) o datos erróneos (debería mostrar un mensaje de aviso o algo, pero no bloquearse o cerrarse).

Evitar los errores en aplicaciones muy grandes y que trabajan miles de personas en su desarrollo es muy difícil, vease grandes juegos, sistemas operativos, etc que sacan betas para que los prueben los usuarios y vayan detectando errores para poder ir haciendo parches para corregir esos errores.

¿Es imposible que una aplicación del tamaño comentando en el párrafo anterior no tenga ningún error? yo creo que no es imposible, pero si muy difícil, porque en una aplicación de esa envergadura entran en juego el diseño de la misma, las miles de personas que trabajan en ella, los diferentes departamentos, etc y coordinar todo eso es muy complejo.

Palabra clave static en Java

La palabra clave static está en la sintaxis de Java y sirve para definir variables de clase.

Se utiliza de la siguiente manera:

public static int Comer;

Ahí estamos declarando una variable de tipo int de nombre Comer que es pública pero vemos también que usamos la palabra static indicando así que es una variable de clase.

Una variable de clase es una variable que se almacena en la misma clase y no en los objetos de la misma y es común usarlas cuando una variable debe tener el mismo valor en todos los objetos o instancias de la clase.

Una variable de clase también puede ser utilizada sin crear ningún objeto ya que cómo hemos dicho antes la variable se almacena en la clase y no necesita de objetos.

Además de variables de clase también existen métodos de clase o métodos estáticos que veremos más adelante y que son métodos, al igual que las variables, que pertenecen a una clase.

Un uso común de la palabra static es la declaración de constantes. Una constante es igual que una variable solo que como su propio nombre indica no puede cambiar de valor, tiene siempre el mismo valor que le damos al crearla.

Para crear una constante usamos la plabra final de la siguiente forma:

public final int Peso = 70;

En esta línea estamos creando una constante de nombre Peso que siempre tendrá el valor 70 que no podremos cambiar durante la ejecución de la aplicación.

Al igual que las variables las constantes también pueden ser de clase poniendo delante la palabra clave static al igual que lo hacíamos con las variables

public static final int Peso = 70;

Ahora estamos creando la constante Peso con valor 70 con la diferencia de que es una constante de clase.

Cualquier cosa no dudéis en ponerla en los comentarios ;)

Modificadores de acceso en Java

Los modificadores de acceso nos sirven para definir la visibilidad de un campo, constructor o método.

A la hora de programar y crear nuestras aplicaciones en Java en las clases podemos tener elementos públicos que son accesibles desde dentro de la misma clase y también desde fuera de ella. También podemos tener elementos privados que solamente son accesibles desde dentro de la misma clase en la que son declarados.

Para declarar un campo, constructor o método cómo público basta con ponder la palabra public delante de su declaración de la siguiente manera:

public void entrenar //no pongo el resto de la implementación

En esa línea estamos declarando un método que podrá ser accesible, es decir, podrá ser usado por la clase en la que está declarado y también por otras clases diferentes.

Si en cambio lo declaramos así:

private void entrenar //no pongo el resto de la implementeación

De esta forma sólo la clase en la que está declarado puede utilizarlo.

Y podríamos preguntarnos ¿por qué se hace esto? ¿por qué no declarar todos los elementos públicos y que ya cada clase use los que les haga falta?

Esto se hace por el principio que se conoce como ocultamiento de la información que establece que los detalles internos de implementación de una clase deben permanecer ocultos para las otras clases asegurando así una mejor modularización de la aplicación. Lo que nos permite por ejemplo asegurarnos que una clase no dependa de cómo está implementada otra clase y además nos ayuda a realizar mejores diseños en nuestras aplicaciones (más adelante profundizaremos más en ello cuando hablemos de cohesión y acoplamiento)

Además de estos niveles de acceso (public y private) Java también tiene otros dos niveles de acceso uno que se declara con la plabra clave protected y otro que se usa cuando no se declara ningún modificador de acceso (más adelante hablaremos de ellos).

Cualquier cosa ponerla en los comentarios ;)

Documentar a la hora de programar

Documentar nuestro trabajo a la hora de programar es muy importante pues nos servirá para muchas cosas que ahora vamos a comentar.

La documentación de nuestro trabajo debe ser suficiente para que otros programadores puedan entenderla en caso de que la quieran usar o en el caso de que nosotros queramos utilizar ese trabajo posteriormente.

A la hora de programar podemos hacer aplicaciones tan complejas y extensas que pudiéramos llegar a tener problemas de entender cómo se hace cada cosa en cada momento y no entender nuestro propio código, por eso es muy importante que vayamos documentando todo lo que hagamos para que con un simple vistazo sepamos que hace cada parte del código y cómo lo hace y no tener que estar pensando cómo está eso ahí y porque.

Una buena documentación de una clase en Java debe incluir el nombre, un comentario que describa lo que hace la clase, también es útil poner que versión es, el nombre del autor o autores, documentar correctamente los constructores y los métodos incluyendo su nombre, lo que retornan, nombres y tipos de parámetros, descripción de lo que hacen, de los parámetros, de los valores que devuelven, etc. Haciéndolo así e incluyendo todos esos apartados en nuestros trabajos estaremos documentando correctamente nuestro trabajo facilitando así su posterior uso por nosotros o por otras personas.

Muchos programadores descuidan esta faceta y apenas comentan y documentan sus clases y trabajos y esto es una mala práctica que se debe evitar, pues si queremos usar las clases posteriormente en otros proyectos o si tenemos un proyecto muy grande es mejor tener todo bien documentando para saber cómo funciona con un simple vistazo y no tener que perder tiempo intentando entender que queríamos hacer con ese código en el momento que lo programamos.

Conjuntos en Java con HashSet

Un conjunto es una colección que almacena elementos y no mantiene un orden específico entre ellos.

A diferencia de lo que pueda parecer un HashSet tiene mas cosas en común con un ArrayList que con un HashMap. De echo podríamos afirmar que un HashSet es cómo un ArrayList pero sin orden en sus elementos.

Con un HashSet podemos ingresar elementos en él y posteriormente recuperarlos. Para poder hacer un HashSet en nuestras aplicaciones lo que tenemos que hacer primeramente es importar la clase HashSet de la siguiente forma:

import java.util.HashSet;

Una vez importada para usarla es igual que al querer usar un método de otra clase, creamos un objeto y ya podemos usar sus métodos. En este caso usaremos el método add para añadir elementos al conjunto, un ejemplo de su uso sería el siguiente:

HashSet<String> conjunto = new HasSet<String>();

Con esta línea estamos creando un conjunto que almacena elementos de tipo String y que se llama conjunto.

Para añadir un elemento al conjunto se usa el método add de la siguiente forma:

conjunto.add("JuegoSoftware");

Así añadiríamos el elemento "JuegoSoftware" al conjunto. Para recorrer el conjunto o tratar sus elementos ya podemos usar ciclos for, iteradores, etc e ir tratando cada elemento o ver si alguno cumple una condición o lo que se nos ocurra o necesitemos.

Si queréis profundizar mas sobre HashSet no dudéis en consultar la biblioteca de clase de Java para poder aprender un montón de cosas más, de todas formas, cualquier cosa no dudéis en ponerla en los comentarios.

;)

HashMap en Java

Un HashMap en Java es un implementación de un Map.

Un mapa es una colección que almacena pares llave-valor como entradas y luego los valores los podemos obtener introduciendo la llave.

Un ejemplo de HashMap podría ser un listado de teléfonos donde la llave sea el nombre y valor sea el número de la siguiente forma: ("JuegoSoftware", "123456789")  donde JuegoSoftware sería la llave y 123456789 sería el valor.

Para poder usar la clase HashMap primeramente tenemos que importarla de la siguiente forma:

import java.util.HashMap;

A la hora de implementarlo en Java es muy sencillo, basta con pasarle los tipos que tendrán la llave y el valor de la siguiente forma:

HashMap<String, String> nuestroHashMap = new HasMap<String, String>();

Así ya tendríamos lo que sería un HashMap de nombre nuestroHashMap en el que la llave sería de tipo String y el valor también sería de tipo String, no hace falta que sean del mismo tipo, podrían ser de tipos diferentes perfectamente.

Los métodos que mas vamos a usar de las clase HashMap son el metodo put para introducir la llave y el valor y el método get que es el que nos permite recuperar el valor introduciendo la llave.

Un ejemplo de uso del método put sería de la siguiente forma:

nuestroHashMap.put("Jamón", "987654321");

Con ese ejemplo estaríamos introduciendo en nuestroHashMap la llave Jamón asociada al valor 987654321

Si ahora queremos recuperar el valor de la llave Jamón lo podemos hacer de la siguiente forma:

String valor = nuestroHashMap.get("Jamón");

Con esta línea estaríamos almacenando el valor asociado a la llave Jamón a la variable valor, una vez ahí ya lo podemos usar como una variable normal y por ejemplo para imprimirla en pantalla sería así:

System.out.println(valor);

Los HashMap tienen muchísimas posibilidades y se usan en un montón de aplicaciones así que os recomiendo que si queréis profundizar  más en ellos no dudéis en visitar la biblioteca de clases de Java e informaros mas a fondo.

Cualquier cosa no dudéis en ponerla en los comentarios.

;)

Clases genéricas o parametrizadas en Java

En Java podemos encontrarnos clases parametrizadas, también conocidas como clases genéricas. 

Estas clases parametrizadas se diferencian de las demás en que en sus nombres tienen un formato diferente a las clases normales ya que incluyen los símbolos de mayor y menor.

Un ejemplo de clase parametrizada es la clase ArrayList que si la buscamos en la biblioteca de clases de Java veremos que viene así ArrayList<E> o la clase HashMap<K, V>. Esto nos indica que son clases parametrizadas o genéricas.

La información que contienen entre los símbolos de menor y mayor nos indica que necesitan uno o más parámetros para funcionar correctamente, de ahí su nombre de clases parametrizadas.

Un ejemplo que vimos en posts anteriores fue al usar la clase ArrayList cuando la usamos pasándole cómo parámetro String para que fuera un ArrayList de String y que sería así: ArrayList<String>

También podemos crear nuestras propias clases genéricas o parametrizadas, muchas veces se usan para crear estructuras de datos cómo listas, colas, árboles, etc pero eso ya lo veremos más adelante.

Para más información sobre clases genéricas puedes visitar este post dónde se explica más en profundidad cómo son estas clases parametrizadas o genéricas pulsando aquí 

Así que si veis que en el nombre de una clase tenemos los símbolos de mayor y menor no os asustéis, se trata de una clase genérica o parametrizada que lo único que necesita es que le pongáis el parámetro correcto según la vayáis a usar.

Crear número aleatorio en Java con la clase Random

Anteriormente vimos la diferencia entre un número aleatorio y un número pseudo-aleatorio, sin entrar más en ese debate, vamos a ver cómo podemos crear un número aleatorio en Java utilizando para ello la clase Random.

Lo primero que tenemos que hacer para crear nuestro número aleatorio es importar la clase Random, la importamos del paquete util de la siguiente forma:

import java.util.Random;

Una vez importada tenemos que crear un objeto de esa clase para poder usarla, lo podemos crear así:

Random numeroAleatorio; //creamos el objeto de la clase numeroAleatorio en los campos

Seguidamente en el constructor lo inicializamos así:

 numeroAleatorio = new Random();

Una vez creado e inicializado el objeto ya podemos usar sus métodos para poder crear los números aleatorios, en este caso el que usaremos es nextInt() que nos crea un numero aleatorio que en el ejemplo que vamos a poner lo generará en el rango de números enteros de Java, para limitar ese rango después pondremos otro ejemplo.

La clase completa que tiene un método que crea un número aleatorio usando la clase Random es la siguiente:

import java.util.Random;

public class CreandoNumeroAleatorio

{

   

    int num;//variable donde almacenaremos el número aleatorio

    Random numeroAleatorio;//objeto numeroAleatorio de la clase Random

    

    //inicializamos las variables en el constructor

    public CreandoNumeroAleatorio()

    {

        numeroAleatorio = new Random();

        num = 0;

    }

    

    //método que nos crear un número aleatorio y lo imprime en pantalla

    public void crearNumero()

    {

        num = numeroAleatorio.nextInt();

        System.out.println(num);

    }

}

La podéis copiar y pegar que funciona perfectamente y al invocar el método crearNumero os imprimirá por pantalla un número aleatorio, que cómo hemos dicho será del rango total de Java de números enteros que va desde -2147183648 a 2147183647. Para limitar ese rango y que por ejemplo nos cree un número aleatorio del 0 al 10 hay que hacer una pequeña modificación en el código. El método nextInt(int n) especifica al recibir el parámetro n que creará un número aleatorio desde 0 inclusive hasta n exclusive, por lo que si queremos crear un número aleatorio del 0 al 10 deberemos poner el número 11, sólo habrá que cambiar la línea:

num = numeroAleatorio.nextInt();

por está otra:

num = numeroAleatorio.nextInt(11);

Quedando la clase final así:

import java.util.Random;

public class CreandoNumeroAleatorio

{

   

    int num;

    Random numeroAleatorio;

   

    public CreandoNumeroAleatorio()

    {

        numeroAleatorio = new Random();

        num = 0;

    }

    public void crearNumero()

    {

        num = numeroAleatorio.nextInt(11);

        System.out.println(num);

    }

}

Cómo vemos crear números aleatorios es bastante sencillo y pronto empezaremos a usarlo en nuestras aplicaciones y juegos que podéis ir viendo en las últimas publicaciones y en Crear Juego en Java desde 0

Aleatorio o pseudo-aleatorio???

¿Se pueden crear números aleatorios en un ordenador o computadora o sólo se pueden crear números pseudo-aleatorios?

Podemos definir un número aleatorio cómo un número que de ninguna forma podemos predecirlo, en cambio un número pseudo-aleatorio si podriamos llegar a predecirlo, pues estos números "aleatorios" generados por programas u ordenadores, no son aleatorios completamente, por eso se llaman pseudo-aleatorios.

Los ordenadores o computadoras operan de una manera bien definida y determinista que se apoya en el hecho de que todo cálculo u operación que hagamos es predecible y repetible en el futuro, por ello podemos afirmar que no existe un comportamiento totalmente aleatorio.

A lo largo del tiempo los investigadores, ingenieros informáticos, programadores, etc han intentado crear algoritmos para producir secuencias semejantes a números aleatorios. Estos número no los podemos definir puramente cómo números aleatorios pues se basan en unos cálculos para ser creados y por tanto podríamos llegar a predecir que números van a salir en esas secuencias si conocemos el algoritmo en que se basan para ser creados, por tanto estos número en computación se llaman números pseudo-aleatorios.

En lenguajes de programación como Java, tenemos clases que nos ayudan en la generación de números pseudo-aleatorios que ya tienen implementados esos algoritmos para que nosotros no los tengamos que crear y podamos ahorrar mucho tiempo y trabajo, por lo que si queremos crear números pseudo-aleatorios para dar a nuestros programas un toque "aleatorio" en su comportamiento basta con que importemos esas clases y usemos sus métodos en nuestras aplicaciones.

En la entrada siguiente veremos la clase Random de la biblioteca de clases de Java y cómo con ella podemos crear números pseudo-aleatorios para añadir comportamiento "aleatorio" a nuestros programas de una manera bastante sencilla, ya que con unas pocas invocaciones ya tendriamos nuestros números pseudo-aletarios sin ningún problema.

Diferencia entre interfaz e implementación

Interfaz o interface no es lo mismo que implementación.

En programación podemos definir interface de una clase como la descripción de lo que es capaz de hacer dicha clase y la manera que se puede usar sin necesidad de ver cómo ha sido creada ni nada. Con solo ver la interface ya podemos saber cómo se usa la clase y que hace.

La implementación es el código completo de la clase, código fuente. En la implementación están todos los detalles de código de la clase y ahí podemos ver cómo hace todas las cosas que podemos ver en la interface.

Un ejemplo donde podemos ver interfaces sin necesidad de ver su implementación para saber como funcionan es la biblioteca de clases de Java, en dicha biblioteca podemos encontrar muchísimas clases y viendo sus interfaces podemos saber que hacen y podemos usarlas en nuestro programas sin necesidad de saber cómo han sido implementadas internamente, es decir, nosotros sólo sabemos que hace y la usamos, no nos preocupamos de que código han utilizado ni cómo lo han hecho ni nada. 

Es una ventaja importante que le da muchísima potencia a la biblioteca de clases, pues gracias a ello podemos usar un montón de métodos de otras clases que ya han sido implementados sin necesidad de implementar nada, nos basta sólo con que veamos su interface y sepamos usarla.

Sistemas Gestores de Bases de Datos

Un sistema gestor de bases de datos es una colección de datos interrelacionados y un conjunto de programas para poder acceder a dichos datos.

Los datos que gestiona un sistema gestor de bases de datos es lo que se denomina base de datos y puede ser de muchísimos tipos dependiendo de en que sector o ámbito nos estemos moviendo.

Estos sistemas se diseñan para gestionar cantidades muy grandes de información y esto implica la definición de estructuras para almacenar esa información así cómo de mecanismos para poder usarla y manipularla.

Las bases de datos actualmente se usan en infinidad de campos de nuestra vida diaria cómo puede ser las universidades, finanzas, líneas aéreas, telecomunicaciones, etc.

Estas bases de datos proporcionan un lenguaje de definición de datos para especificar el esquema de la base de datos y también un lenguaje de manipulación de datos para hacer modificaciones, consultas, etc. En la práctica estos dos lenguajes (definición y manipulación) no son dos lenguajes diferentes ya que forman para de un único lenguaje. El lenguaje más usado en las bases de datos es SQL aunque hay otras opciones.

Las bases de datos están en todos los ámbitos de nuestra vida diaria y suponen uno de los campos mas importante de las telecomunicaciones ya que cualquier comunicación que hagamos ya sea por correo electrónico, whatsapp, etc usa las bases de datos para almacenar los mensajes, imágenes, datos, etc.

Vectores y Matrices en Java

Los vectores y las matrices son colecciones de tamaño fijo que podemos implementar en Java, los vectores son de una dimensión y las matrices de 2 aunque se pueden implementar de mas dimensiones.

En Java es sencillo implementar matrices y vectores y se puede hacer de la siguiente forma:

Para un vector basta con esta línea de código:

public double[] vector=new double[X]; 

Con está línea estamos creando un vector de tipo double de nombre vector con X elementos, así de sencillo, luego para referenciar un elemento sería vector[i]. Una vez creada para inicializarlo basta con utilizar un for de la siguiente forma:

for(int i=0;i<X;i++){

           vector[i]=0.0;

           }

Para una matriz basta con la siguiente línea:

public int[][] matriz=new double[X][Y]; 

Con está línea estamos creando una matriz de tipo int de nombre matriz de X filas e Y columnas. Para referenciar un elemento de esta matriz sería de la siguiente forma matriz[i][p]. Para inicializar una matriz hay que usar dos for anidados por tener 2 dimensiones. Se hace de la siguiente forma:

 for(int i=0; i<X; i++){

            for(int j=0; j<Y; j++){

                x[i][j]=0;

            }

        }

De esta forma podemos crear y usar matrices y vectores en Java que son colecciones de tamaño fijo, que cómo su nombre indica, no pueden cambiar de tamaño una vez creadas pero que son muy útiles si sabemos de antemano cuantos elementos vamos a necesitar en la colección y además son muy fáciles de crear y utilizar.

Iterador en Java

Un iterador es un objeto que nos proporciona funcionalidades para recorrer los elementos de una colección que tengamos.

Java tiene la clase Iterator que nos provee de dos métodos para recorrer una colección que son hasNext y next. Ahora pondremos un ejemplo con su código pero mas o menos podemos definir hasNext cómo una comprobación que va viendo si hay más elementos en la colección y el next que nos da el siguiente elemento de la misma.

Para usar un iterador tenemos que importar el paquete donde está definido que es el siguiente: java.util.Iterator, una vez lo tengamos importado tenemos que crear un objeto para poder usarlo igual que hemos hecho en entradas anteriores para usar métodos de otras clases.

Ejemplo de de como usar un iterador:

Imaginemos que tenemos una colección de nombre agenda de tipo String donde se almacenan nombres y que queremos imprimir los contactos que en ella tenemos, lo que tendríamos que hacer sería lo siguiente:

//método que usa un iterador para imprimir por pantalla los contactos de una agenda

 public void mostrarContactos()

    {

        Iterator<String> it = agenda.iterator();

        while (it.hasNext()) {

            System.out.println(it.next());

        }

    }

El funcionamiento del método que usa ese iterador es muy sencillo, en la primera línea definimos el iterador de tipo String que se va a llamar it y que va a iterar sobre la colección agenda que teníamos creada previamente. Seguidamente entramos en un while que mientras haya un elemento sin tratar en la colección (it.hasNext()) se ejecutará y lo que ejecutará es System.out.println(it.next()); que imprimirá en pantalla el siguiente elemento de la colección.

Cómo vemos es muy sencillo utilizar un iterador y nos ofrece la posibilidad de recorrer una colección y de tratar sus elementos de una forma fácil y sencilla.

Ciclos en Java

Un ciclo en Java puede ejecutar repetidamente un bloque de sentencias sin tener que escribirlas varias veces. Dependiendo del ciclo que usemos tendremos unas u otras posibilidades.

Los ciclos más usados en Java son: while, do-while y for

Pasamos a poner la sintaxis y la explicación de cada uno de ellos:

Ciclo while:

while(expresión){

sentencias;

}

Con este ciclo mientras se cumpla la condición que establezcamos en la expresión se ejecutarán las sentencias.

Ciclo do-while:

do{

sentencias

}while(expresión);

Este ciclo es similar al while con la diferencia de que las sentencias siempre se ejecutan una primera vez y luego se siguen ejecutando si se cumple la condición de la expresión. En el while podría darse que nunca se ejecutaran las sentencias si no se cumpliera la expresión. Con el do-while nos aseguramos esa primera ejecución de las sentencias aunque no se cumpla la expresión, en caso de que se cumpla se seguirán ejecutando exactamente igual que en el while hasta que deje de cumplirse esa condición.

Ciclo for:

Aquí tenemos dos posiblidades:

for-each para recorrer colecciones que se usa de la siguiente forma:

for(declaración de variable : colección){

sentencias;

}

Y for "normal" que sirve para que unas sentencias se vayan ejecutando si se cumple una condición que vamos controlando con un índice:

for(int i=0; i<=X;i++){

sentencias;

}

El cuerpo de este ciclo es más complejo, en primer lugar declaramos una variable (int i=0), seguidamente establecemos la condición que va a hacer que se ejecute el ciclo hasta que se siga cumpliendo esa condición (i<=X) y finalmente se pone un autoincremente o decremento de la variable para que cada vez que se ejecuta el ciclo vaya cambiando y llegue a cumplir la condición que le hemos establecido (i++).

Los ciclos nos ofrecen muchísimas posibilidades de control sobre nuestras aplicaciones y también permiten que los anidemos, es decir que haya uno dentro de otro, o todos los que queramos, al hacer eso debemos tener mucho cuidado pues podemos incurrir en costes computacionales muy altos y hacer que nuestros programas sean inviables.

También al usar ciclos debemos tener especial cuidado en no crear ciclos infinitos pues si usamos unos índices erróneos o condiciones que nunca se pueden alcanzar podríamos tener el bucle ejecutándose hasta el fin de los tiempos y el programa no avanzaría a las siguientes sentencias.

Cualquier cosa no dudéis en comentarla ;)

Saludos a tod@s!!

Númeración en colecciones Java e IndexOutBoundsException

A la hora de crear o utilizar una colección en Java, ya sea un vector, una matriz, un ArrayList, etc debemos tener especial cuidado en cómo utilizamos sus elementos.

En una colección en Java debemos tener presente que están numeradas a partir del número cero, es decir, el primer elemento de una colección es el que están la posición 0.

Por tanto para referirnos a un elemento de un vector de 3 elementos debemos tener presente que el primer elemento será el situado en la posición 0 del vector, el 2 será el de la posición 1 y el 3 será el de la posición 2 y así sucesivamente si el vector tuviera más elementos.

Esta posición es conocida comúnmente como su índice, por lo que podemos decir que la posición que ocupa un objeto en una colección es conocida como su índice y el primer elemento de esa colección tiene por índice el número 0.

A la hora de utilizar los elementos de una colección debemos tener especial cuidado al referenciarlos pues podríamos incurrir en errores muy comunes como llamar a un objeto que no existe. Dado que el índice de elementos de cualquier colección empieza por 0 debemos tener en cuenta que el último índice de esa colección es el tamaño de la colección-1, por ejemplo en un vector de 3 elementos, el último índice será el 2 (3-1) y así con cualquier colección.

¿Qué pasa cuando intentamos acceder a un elemento que está fuera de los índices de la colección? Pues se produce un error llamado IndexOutBoundsException que es un error de desbordamiento por intentar acceder a un elemento que no existe, por ejemplo si tenemos un vector de 3 elementos e intentamos acceder al tercer elemento del vector deberíamos poner el índice número 2 ya que empieza en 0 y sus elementos serían (0,1,2), si usamos el número 3 para usarlo no mostraría ese error y el programa dejaría de funcionar, por ello debemos tener especial cuidado a la hora de usar los índices de nuestras colecciones y no incurrir así en estos errores.

Este tipo de errores es muy común cuando usamos ciclos como for para recorrer una colección y no tenemos en cuenta el tamaño de la colección e intenemos recorrer índices que se salen de los límites de la colección.

Por ejemplo si tenemos un vector de nombre Vector de 3 elementos y lo intentamos recorrer con un ciclo for de la siguiente forma:

for(int i=0; i<=3;i++)

{

    Operar(Vector[i]);

}

Al llamarlo de esta forma tendríamos un IndexOutBoundsException pues cómo vemos el for se repetirá mientras la i sea menor o igual que 3, por lo que al llegar a 3 intentará realizar Operar(Vector[3]) y cómo no existe ese elemento dará error, ese error se solucionaría cambiando el <= por < por lo que la i solo podría llegar a 2.

Tener mucho cuidado a la hora de usar índices pues un uso inadecuado o incorrecto os podría llevar a tener grandes quebraderos de cabeza a la hora de realizar vuestras aplicaciones.