TIPS EN JAVA

Declaración y Tipos de Variables en Java

La siguiente manera es como se declara una variable en Java. También veremos los tipos de
variables: locales, de instancia y estáticas; con ejemplos.

1. ¿Qué es una Variable?

Una variable es el nombre dado a una ubicación de memoria. Es la unidad básica de
almacenamiento en un programa. El valor almacenado en una variable se puede cambiar
durante la ejecución del programa.

En Java, todas las variables deben declararse antes de que puedan ser utilizadas.
×El valor almacenado puede cambiarse (variar) a medida que el programa ejecuta sus
instrucciones, de ahí el término “variable“.

2. ¿Cómo declarar variables?

Podemos declarar las variables en Java de la siguiente manera:

Cómo declarar variables en Java

 tipo de dato: tipo de datos que se pueden almacenar en esta variable.

 nombre_variable: nombre dado a la variable.
 valor: es el valor inicial almacenado en la variable.
Ejemplos:

float simpleInterest; //Declarando variable float

int time = 10, speed = 20; //Declarando e Inicializando la variable
integer
char var = 'h'; // Declarando e Inicializando la variable character

Por ejemplo, el tipo de dato String se puede especificar para permitir que una variable
llamada “mensaje” contenga texto con esta declaración:

String mensaje;
class PrimeraVariable
{
public static void main ( String[] args ) {
String mensaje = "Valor inicial";
System.out.println(mensaje);
mensaje = "Valor modificado" ;
System.out.println(mensaje);
}
}

Salida:

Valor inicial
Valor modificado

Los nombres de variables también deben evitar las palabras clave de Java, ya que tienen un
significado especial en el lenguaje Java.

 Lista de palabras reservadas en Java

Conoce cuales son las reglas para definir identificadores y qué son las palabras reservadas
en Java, así como ejemplos de identificadores validos.

En los lenguajes de programación, los identificadores (como su nombre lo indica) se utilizan

con fines de identificación. En Java, un identificador puede ser un nombre de clase, un
nombre de método o un nombre de variable. Por ejemplo:

public class Test

{
public static void main(String[] args)
{
int a = 28;
}
}

En el código java anterior, tenemos 5 identificadores, a saber:

 Test: nombre de clase.

 main: nombre del método.
 String: nombre de clase predefinido.
 args: nombre de la variable.
 a: nombre de la variable.

1. Reglas para definir identificadores de

Java
Existen ciertas reglas para definir un identificador java válido. Estas reglas deben seguirse, de
lo contrario obtenemos un error en tiempo de compilación. Estas reglas también son válidas
para otros lenguajes como C, C++.

 Los únicos caracteres permitidos para los identificadores son todos los caracteres
alfanuméricos (, , ), “$” (signo de dólar) y ‘_’ (guión bajo). Por ejemplo, “java@” no es
un identificador de Java válido ya que contiene “@” – carácter especial.
 Los identificadores no deben comenzar con dígitos (). Por ejemplo, “123java” no
es un identificador de Java válido.
 Los identificadores de Java distinguen entre mayúsculas y minúsculas.
 No hay límite en la longitud del identificador, pero es aconsejable usar solamente
una longitud óptima de 4 a 15 caracteres.
 Las palabras reservadas no se pueden usar como un identificador. Por ejemplo, es
una declaración inválida ya que es una palabra reservada. Hay 53 palabras
reservadas en Java.

2. Ejemplos de identificadores válidos

MyVariable
MYVARIABLE
myvariable
x
i
x1
i1
_myvariable
$myvariable
sum_of_array
javadesdecero

3. Ejemplos de identificadores inválidos

My Variable // Contiene un espacio
123java // Comienza con un dígito
a+c // El signo más (+) no es un carácter alfanumérico
variable-2 // El guión (-) no es un carácter alfanumérico
sum_&_difference // ampersand (&) no es un carácter válido

4. Palabras reservadas en Java

Cualquier lenguaje de programación reserva algunas palabras para representar
funcionalidades definidas por ese lenguaje. Estas palabras se llaman palabras reservadas.
Estas pueden ser categorizadas brevemente en dos partes: palabras clave/keywords (50) y
literales (3).

3. Tipos de variables
Hay tres tipos de variables en Java:

 Variables locales
 Variables de instancia
 Variables estáticas

Ahora aprendamos sobre cada una de estas variables en detalle.

3.1. Variables locales

Una variable definida dentro de un bloque, método o constructor se llama variable local.

 Estas variables se crean cuando el bloque ingresado o método se llama y destruye

después de salir del bloque o cuando la llamada regresa del método.
  El alcance de estas variables solo existe dentro del bloque en el que se declara la
variable, es decir, podemos acceder a estas variables solo dentro de ese bloque.

public class StudentDetails

{
public void StudentAge()
{ //variable local age
int age = 0;
age = age + 5;
System.out.println("La edad del estudiante es : " + age);
}

public static void main(String args[])

{
StudentDetails obj = new StudentDetails();
obj.StudentAge();
}
}

Salida:

La edad del estudiante es : 5

En el programa anterior, la variable age (edad) es una variable local para el método . Si

usamos la variable age fuera del método , el compilador producirá un error como se muestra a
continuación en el programa.

Ejemplo 2:

public class StudentDetails

{
public void StudentAge()
{ //variable local age
int age = 0;
age = age + 5;
}
 public static void main(String args[])
{
//utilizando la variable local age fuera de su alcance
System.out.println("La edad del estudiante es : " + age);
}

Salida:

error: cannot find symbol

" + age);

3.2. Variables de instancia

Las variables de instancia son variables no estáticas y se declaran en una clase fuera de
cualquier método, constructor o bloque.

 Como las variables de instancia se declaran en una clase, estas variables se crean
cuando un objeto de la clase se crea y se destruye cuando se destruye el objeto.
 A diferencia de las variables locales, podemos usar especificadores de acceso para
variables de instancia. Si no especificamos ningún especificador de acceso, se
utilizará el especificador de acceso predeterminado.

Ejemplo:

import java.io.*;
class Points
{
//Estas variables son variables de instancia.
//Estas variables están en una clase y no están dentro de ninguna
función/método
int engPoints;
int mathsPoints;
int phyPoints;
}

class PointsDemo
{
 public static void main(String args[])
{ //primer objeto
Points obj1 = new Points();
obj1.engPoints = 50;
obj1.mathsPoints = 80;
obj1.phyPoints = 90;

//segundo objeto
Points obj2 = new Points();
obj2.engPoints = 80;
obj2.mathsPoints = 60;
obj2.phyPoints = 85;

//mostrando puntos para el primer objeto

System.out.println("Puntos para el primer objeto:");
System.out.println(obj1.engPoints);
System.out.println(obj1.mathsPoints);
System.out.println(obj1.phyPoints);

//mostrando puntos para el segundo objeto

System.out.println("Puntos para el segundo objeto:");
System.out.println(obj2.engPoints);
System.out.println(obj2.mathsPoints);
System.out.println(obj2.phyPoints);
}
}

Salida:

Puntos para el primer objeto:

50
80
90
Puntos para el segundo objeto:
80
60
85

Como puede ver en el programa anterior, las variables engPoints, mathsPoints, phyPoints;

son variables de instancia. En caso de que tengamos varios objetos como en el programa
anterior, cada objeto tendrá sus propias copias de variables de instancia. Del resultado
anterior se desprende que cada objeto tendrá su propia copia de la variable de instancia.

3.3. Variables estáticas

Las variables estáticas también se conocen como variables de clase. 

 Estas variables se declaran de forma similar a las variables de instancia, la diferencia

es que las variables estáticas se declaran utilizando la palabra clave dentro de una
clase fuera de cualquier constructor o bloque de métodos.
 A diferencia de las variables de instancia, solo podemos tener una copia de una
variable estática por clase, independientemente de cuántos objetos creemos.
 Las variables estáticas se crean al inicio de la ejecución del programa y se destruyen
automáticamente cuando finaliza la ejecución.

Para acceder a variables estáticas, no necesitamos crear ningún objeto de esa clase,
simplemente podemos acceder a la variable como:

nombre_clase.nombre_variable;

Ejemplo:

import java.io.*;
class Emp {

// salario como variable estatica

public static double salary;
public static String name = "Alex";
}

public class EmpDemo

{
public static void main(String args[]) {
 //acceder a la variable estatica sin objeto
Emp.salary = 1000;
System.out.println(Emp.name + " tiene un salario promedio de: " +
Emp.salary);
}

Salida:

Alex tiene un salario promedio de: 1000.0

4. Variable de instancia vs Variable

estática
 Cada objeto tendrá su propia copia de la variable de instancia, mientras que solo
podemos tener una copia de una variable estática por clase, independientemente de
cuántos objetos creemos.
 Los cambios realizados en una variable de instancia utilizando un objeto no se
reflejarán en otros objetos, ya que cada objeto tiene su propia copia de la variable de
instancia. En caso de estática, los cambios se reflejarán en otros objetos ya que las
variables estáticas son comunes a todos los objetos de una clase.
 Podemos acceder a variables de instancia a través de referencias de objetos y se
puede acceder directamente a las variables estáticas usando el nombre de clase.

En resumen, la sintaxis para variables estáticas y de instancia es:

class Example
{
static int a; //variable estatica
int b; //variable de instancia
}

5. Creando constantes
La palabra clave “final” es un modificador que se puede usar al declarar variables para evitar
cualquier cambio posterior en los valores que inicialmente se les asignaron.
Esto es útil cuando se almacena un valor fijo en un programa para evitar que se altere
accidentalmente.
Las variables creadas para almacenar valores fijos de esta manera se conocen como
“constantes“, y es convencional nombrar constantes con todos los caracteres en
mayúsculas, para distinguirlas de las variables regulares. Los programas que intentan
cambiar un valor constante no se compilarán, y el compilador javac generará un mensaje de
error.

Ejemplo:

class Constants
{
public static void main ( String[] args ) {
//inicializamos tres constantes enteras
final int CONSTANTE1 = 6 ;
final int CONSTANTE2 = 1 ;
final int CONSTANTE3 = 3 ;

//declaramos variables regulares del tipo int

int td,pat,fg,total;

//Inicializamos las variables regulares

td = 4*CONSTANTE1;
pat = 3*CONSTANTE2;
fg = 2*CONSTANTE3;

total = (td+pat+fg) ;

System.out.println("Resultado: " + total);

}
}

Salida:

Resultado: 33
×Nota: El carácter * significa una multiplicación. No se preocupe de momento, a
continuación, en este enlace, conocerá todos los Operadores en Java.

Estructuras Condicionales Java: if, if-else, switch, break,

continue, jump

estructuras condicionales en Java: if, if-else, switch, break, continue, jump. Muchos

ejemplos con explicación para que aprendas de manera rápida.

La toma de decisiones en la programación es similar a la toma de decisiones en la vida real.

En la programación también enfrentamos algunas situaciones en las que queremos que se
ejecute cierto bloque de código cuando se cumple alguna condición.

Un lenguaje de programación utiliza instrucciones de control para controlar el flujo de

ejecución del programa en función de ciertas condiciones. Estos se utilizan para hacer que el
flujo de ejecución avance y se ramifique en función de los cambios en el estado de un
programa.

Declaraciones de selección de Java:

 if
 if-else
 nested-if
 if-else-if
 switch-case
 jump – break, continue, return

Estas declaraciones le permiten controlar el flujo de la ejecución de su programa en función de

condiciones conocidas solo durante el tiempo de ejecución.

1. if
La sentencia if es la declaración de toma de decisiones más simple. Se usa para decidir si una
determinada declaración o bloque de enunciados se ejecutará o no; es decir, si una
determinada condición es verdadera (true), se ejecutará un bloque de enunciado y, de ser
falsa (false), no.

Sintaxis:

if (condición)
{
// Declaraciones para ejecutar si
// la condición es verdadera
}

Aquí, la condición después de la evaluación será verdadera o falsa. if acepta valores

booleanos: si el valor es verdadero, ejecutará el bloque de instrucciones debajo de él. OJO: Si
no proporcionamos las llaves ‘{‘ y ‘}’ después del if (condición), entonces de forma
predeterminada la sentencia if considerará que la declaración inmediata está dentro de su
bloque.

Por ejemplo:

if (condicion)
declaracion1;
declaracion2;

// Aquí si la condición es verdadera, el bloque if

// solo  considerará que la declaracion1 está dentro
// de su bloque.

Ejemplo:

// Programa Java para ilustrar la declaración If

class IfDemo
{
public static void main(String args[])
{
int i = 10;

if (i > 15)
System.out.println("10 es menor que 15");

// Esta declaración se ejecutará

        // como si considerara una declaración por defecto
System.out.println("No estoy en IF");
 }
}

Salida: No estoy en IF

2. if-else
La declaración if solo nos dice que, si una condición es verdadera ejecutará un bloque de
instrucciones y si la condición es falsa, no lo hará. Pero, ¿y si queremos hacer otra cosa
cuando la condición sea falsa? Aquí viene la declaración else. Podemos usar la
instrucción else con la instrucción if para ejecutar un bloque de código cuando la condición es
falsa.

Sintaxis:

if (condición)
{
// Ejecuta este bloque si
// la condición es verdadera
}
else
{
// Ejecuta este bloque si
// la condición es falsa
}

Ejemplo:

// Programa Java para ilustrar la declaración if-else

class IfElseDemo
{
public static void main(String args[])
{
int i = 20;
 if (i < 15)
System.out.println("Soy menor que 15");
else
System.out.println("Soy mayor de 15");
}
}

Salida:

Soy mayor de 15

3. Anidación-if
Una if anidado (nested-if) es una declaración if que se deriva de otro if o else. Las
declaraciones if anidadas significan una instrucción if dentro de una declaración if. Sí, Java
nos permite anidar las declaraciones if con if, es decir, podemos colocar una
instrucción if dentro de otra instrucción if.

Sintaxis:

if (condicion1)
{
// Ejecuta cuando condicion1 es verdadero
if (condition2)
{
// Ejecuta cuando condicion2 es verdadero
}
}

Ejemplo:

// Programa Java para ilustrar declaraciones anidadas

class NestedIfDemo
{
public static void main(String args[])
{
 int i = 10;

if (i == 10)
{
// Primera declaración if
if (i < 15)
System.out.println("soy menor que 15");

// Declaración if anidada
            // Solo se ejecutará si la instrucción anterior
            // es verdad
if (i < 12)
System.out.println("yo también soy menor que 12");
else
System.out.println("soy mayor que 15");
}
}
}

Salida:

soy menor que 15

yo soy menor que 12

4. Escalera if-else-if
Aquí, un usuario puede decidir entre múltiples opciones. Las sentencias if se ejecutan desde
arriba hacia abajo. Tan pronto como una de las condiciones que controlan el if sea verdadera,
se ejecuta la instrucción asociada con ese if, y el resto de la escalera se pasa por alto. Si
ninguna de las condiciones es verdadera, se ejecutará la sentencia final else.

if (condición)
declaración;
else if (condición)
declaración;
.
.
declaración
else ;

Ejemplo:

// Programa Java para ilustrar if-else-if ladder

class ifelseifDemo
{
public static void main(String args[])
{
int i = 20;

if (i == 10)
System.out.println("i es 10");
else if (i == 15)
System.out.println("i es 15");
else if (i == 20)
System.out.println("i es 20");
else
System.out.println("i no está presente");
}
}

Salida:

i es 20

5. switch-case
La instrucción switch es una declaración de bifurcación de múltiples vías (selección múltiple).
Proporciona una forma sencilla de enviar la ejecución a diferentes partes del código en función
del valor de la expresión.

Sintaxis:
switch (expresión)
{
case valor1:
declaracion1;
break;
case value2:
declaracion2;
break;
.
.
case valorN:
declaracionN;
break;
default:
declaracionDefault;
}

 La expresión puede ser de tipo byte, short, int, char o  una enumeración. A partir de
JDK7, la expresión también puede ser de tipo String.
 Los valores duplicados de case no están permitidos.
 La declaración predeterminada es opcional.
 La declaración de interrupción  se usa dentro del switch para finalizar una secuencia
de instrucción.
 La declaración es opcional. Si se omite, la ejecución continuará en el siguiente case.

Ejemplo:

// Java program to illustrate switch-case

class SwitchCaseDemo
{
public static void main(String args[])
{
int i = 9;
switch (i)
{
case 0:
 System.out.println("i es cero.");
break;
case 1:
System.out.println("i es uno.");
break;
case 2:
System.out.println("i es dos.");
break;
default:
System.out.println("i es mayor que 2.");
}
}
}

Salida:

i es mayor que 2.

6. jump o saltos
Java admite tres declaraciones de salto: break, continue y return. Estas tres declaraciones
transfieren el control a otra parte del programa.

6.1. break
En Java, break se utiliza principalmente para:

1. Terminar una secuencia en una instrucción switch (discutida arriba).

2. Para salir de un bucle

3. Como una forma “civilizada” de goto.

 Usar break para salir de un bucle

Utilizando el break, podemos forzar la terminación inmediata de un bucle, evitando la

expresión condicional y cualquier código restante en el cuerpo del bucle.
Nota: break, cuando se utiliza dentro de un conjunto de bucles anidados, solo saldrá
del bucle más interno.
// Programa Java para ilustrar usando
// break para salir del bucle
class BreakLoopDemo
{
public static void main(String args[])
{
// Inicialmente, el bucle está configurado para ejecutarse desde 0-9
for (int i = 0; i < 10; i++)
{
// termina el bucle cuando llega a 5.
if (i == 5)
break;

System.out.println("i: " + i);

}
System.out.println("Bucle completo.");
}
}

Salida:

i: 0
i: 1
i: 2
i: 3
i: 4
Bucle completo.

 Usar break como una forma de Goto

Java no tiene una declaración goto porque proporciona una forma de bifurcar de manera

arbitraria y no estructurada. Java usa etiquetas. Una etiqueta se usa para identificar un
bloque de código.
Sintaxis:

etiqueta:
{
declaracion1;
declaracion2;
declaracion3;
.
.
}

Ahora, la instrucción break se puede utilizar para saltar fuera del bloque objetivo. Así:

Nota: No puede romper ninguna etiqueta que no esté definida para un bloque
envolvente.
Ejemplo:

// Programa Java para ilustrar el uso de break con goto

class BreakLabelDemo
{
public static void main(String args[])
{
boolean t = true;

// etiqueta first
first:
{
// Declaración de la etiqueta second
second:
{
third:
{
// Antes de break
System.out.println("Antes de la sentencia break");
 // break tomará el control de
// la etiqueta second
if (t)
break second;
System.out.println("Esto no se ejecutará.");
}
System.out.println("Esto no se ejecutará.");
}

// Tercer bloque
System.out.println("Esto es después del segundo bloque.");
}
}
}

Salida:

Antes de la sentencia break

Esto es después del segundo bloque.

6.2. Continue
A veces es útil forzar una iteración temprana de un bucle. Es decir, es posible que desee
continuar ejecutando el bucle, pero deje de procesar el resto del código (en su cuerpo) para
esta iteración en particular. Esto es, en efecto, un goto pasando del cuerpo del bucle, al final
del bucle. La instrucción continue realiza tal acción.

Ejemplo:

// Programa Java para ilustrar usando

// continue en una declaración if
class ContinueDemo
{
public static void main(String args[])
{
for (int i = 0; i < 10; i++)
 {
// Si el número es par
// omitir y continuar
if (i%2 == 0)
continue;

// Si el número es impar, imprímalo

System.out.print(i + " ");
}
}
}

Salida:

1 3 5 7 9

6.3. Return
la declaración return se usa para regresar explícitamente de un método. Es decir, hace que
un control de programa se transfiera nuevamente a quién llama del método.

Ejemplo:

// Programa Java para ilustrar usando return

class Return
{
public static void main(String args[])
{
boolean t = true;
System.out.println("Antes de return.");

if (t)
return;

// El compilador eludirá todas las declaraciones

 // después de return
System.out.println("Esto no se ejecutará.");
}
}

Salida:

Antes de return.

Bucles en Java: for, while, do while

Estructura repetitiva en Java. Conceptos y ejemplos sobre bucles for, while, do while para
aprender Java en instantes.

Un bucle en lenguajes de programación es una característica que facilita la ejecución de un

conjunto de instrucciones/funciones repetidamente, mientras que algunas condiciones se
evalúan como verdaderas.

Java proporciona tres formas de ejecutar los bucles. Si bien todas las formas proporcionan
una funcionalidad básica similar, difieren en su sintaxis y el tiempo de comprobación de la
condición. Veamos las 3 formas:

1. Bucle while
Un bucle while es una sentencia de control de flujo que permite que el código se ejecute
repetidamente en función de una condición booleana dada. El bucle while se puede
considerar como una instrucción if repetitiva.

Sintaxis:

while (condición booleana)

{
declaraciones del bucle ...
}
  El while comienza con la verificación de la condición. Si se evalúa como verdadero,
las instrucciones del cuerpo del bucle se ejecutan; de lo contrario, se ejecuta la
primera instrucción que le sigue al bucle. Por esta razón, también se llama bucle de
control de entrada.
 Una vez que la condición se evalúa como verdadera, se ejecutan las instrucciones en
el cuerpo del bucle.
 Normalmente, las declaraciones contienen un valor de actualización para la variable
que se procesa para la siguiente iteración.
 Cuando la condición se vuelve falsa, el ciclo finaliza y marca el final de su ciclo de
vida.

Ejemplo:

// Programa Java para ilustrar el bucle while

class whileLoopDemo
{
public static void main(String args[])
{
int x = 1;

// Salir cuando x llega a ser mayor que 4

while (x <= 4)
{
System.out.println("Valor de x: " + x);

//incrementa el valor de x para la siguiente iteración

 x++;
}
}
}

Salida:

Valor de x: 1
Valor de x: 2
Valor de x: 3
Valor de x: 4

2. Bucle for
El bucle for proporciona una forma concisa de escribir la estructura de bucle. A diferencia de
un ciclo while, una sentencia for consume la inicialización, la condición y el
incremento/decremento en una línea, proporcionando así una estructura de bucle más corta y
fácil de depurar.

Sintaxis:

for (condición de inicialización, condición de prueba;

incremento / decremento)
{
declaracion(es)
}
1. Condición de inicialización: Aquí, inicializamos la variable en uso. Marca el inicio de
un ciclo for. Se puede usar una variable ya declarada o se puede declarar una variable, solo
local para el bucle.

2. Condición de prueba: se usa para probar la condición de salida de un bucle. Debe

devolver un valor booleano. También es un bucle de control de entrada cuando se verifica la
condición antes de la ejecución de las instrucciones de bucle.

3. Ejecución de instrucción: una vez que la condición se evalúa como verdadera, se

ejecutan las instrucciones en el cuerpo del bucle.

4. Incremento/Decremento: se usa para actualizar la variable para la siguiente iteración.

5. Terminación de bucle: cuando la condición se vuelve falsa, el bucle termina

marcando el final de su ciclo de vida.

Ejemplo:

// Programa Java para ilustrar el bucle for.

class forLoopDemo
{
public static void main(String args[])
{
// bucle for comienza cuando x=2
 // y corre hasta x <=4
for (int x = 2; x <= 4; x++)
System.out.println("Valor de x: " + x);
}
}

Salida:

Valor de x: 2
Valor de x: 3
Valor de x: 4

2.1. Bucle for mejorado (for each)

Java también incluye otra versión del bucle for introducido en Java 5. La mejora del
bucle for proporciona una forma más sencilla de iterar a través de los elementos de una
colección o matriz. Es inflexible y debe usarse solo cuando existe la necesidad de recorrer los
elementos de forma secuencial sin conocer el índice del elemento procesado actualmente.

Sintaxis:

for (Elemento T:Colección de obj/array)

{
declaraciones)
}

Tomemos un ejemplo para demostrar cómo se puede utilizar “enhanced for” para simplificar el
trabajo. Supongamos que hay una matriz de nombres y queremos imprimir todos los nombres
en esa matriz. Veamos la diferencia con estos dos ejemplos:

El bucle mejorado (enhanced) de for simplifica el trabajo de la siguiente manera:

// Programa Java para ilustrar bucle for mejorado

public class Enhancedforloop
{
public static void main(String args[])
{
String array[] = {"Ron", "Harry", "Hermoine"};
 //mejorado para for
for (String x:array)
{
System.out.println(x);
}

/*bucle for para la misma función

for (int i = 0; i < array.length; i++)
{
System.out.println(array);
}
*/
}
}

Salida:

Ron
Harry
Hermoine

Veamos algunos puntos importantes sobre el bucle for en Java. Inicialización de múltiples

variables, re-declaración de una variable, entre otras cosas.

La estructura del bucle for básico:

for(Inicialización; expresión booleana; declaración de actualización)

{
//Cuerpo
}

Veamos algunos ejemplos básicos de cómo usar el bucle for y las trampas comunes al usarlo:
1. Proporcionar expresión en for es
obligatorio
El bucle for debe consistir en una expresión válida en la declaración, sino puede conducir a un
bucle infinito. La declaración es similar a

Ejemplo:

// Programa Java para ilustrar

// bucle infinito
public class Example1
{
public static void main(String[] args)
{
for( ; ; )
{
System.out.println("Este es un ciclo infinito");
}
}

Salida:

Este es un ciclo infinito

Este es un ciclo infinito
...

2. Inicialización de múltiples variables

En Java, se pueden inicializar múltiples variables en el bloque de inicialización del bucle for,
independientemente de si lo usa en el bucle o no.

// Programa Java para ilustrar

// Inicializando múltiples variables
// en el bloque de inicio
public class Example2
{

public static void main(String[] args)

{
int x = 2;
for(long y = 0, z = 4; x < 10 && y < 10; x++, y++)
{
System.out.println(y + " ");
}

System.out.println(x);
}
}

Salida:

0
1
2
3
4
5
6
7
10

En el código anterior, hay una variación simple en el bucle for. Dos variables son declaradas e
inicializadas en el bloque de inicialización. La variable “z” no se está utilizando. Además, los
otros dos componentes contienen una variable adicional. Entonces, se puede ver que los
bloques pueden incluir variables adicionales que no pueden ser referenciadas entre sí.
3. Redeclaración de una variable en el
bloque de inicialización
Supongamos que una inicialización de variable ya está declarada como un entero. ¿Podemos
volver a declararlo en un bucle for como otro tipo de dato? No, mira el ejemplo:

Ejemplo:

// Programa Java para ilustrar

// redeclarar una variable
// en el bloque de inicialización
public class Example3
{
public static void main(String[] args)
{
// x es integer
int x = 0;

// redeclarando x como long no trabajará

for(long y = 0, x = 1; x < 5; x++)
{
System.out.print(x + " ");
}

}
}

Salida:

Example3.java:12: error: variable x is already defined in method main(String[])

for(long y = 0, x = 1; x < 5; x++)

Aquí, x ya se inicializó a cero como número entero y se vuelve a declarar en el bucle con el
tipo de datos long.
Pero este problema se puede solucionar modificando ligeramente el código. Aquí, las
variables x y y se declaran de una  manera diferente.

Ejemplo:

// Programa Java para ilustrar

// redeclar una variable
// en el bloque de inicialización
public class Example3
{
public static void main(String[] args)
{
// x es integer
int x = 0;
long y = 10;

for (y = 0, x = 1; x < 5; x++)

{
System.out.print(x + " ");
}

}
}

Salida:

1 2 3 4

4. Las variables declaradas en el bloque

de inicialización deben ser del mismo
tipo
Es simplemente un sentido común que cuando declaramos una variable como  ambas
variables son del mismo tipo. Lo mismo sucede en el bloque de inicialización.

Ejemplo:
// Programa Java para ilustrar
// declarando una variable
// en el bloque de inicialización
public class Example4
{
public static void main(String[] args)
{
// Esto causará error;
// int x;

// redeclarando x no long no funcionará

for (long y = 0, x = 1; x < 5; x++)
{
System.out.print(x + " ");
}

}
}

5. Las variables en el bucle solo son

accesibles en su interior
Las variables declaradas en el bloque de inicialización solo se puede acceder dentro del
bucle. Para más información sobre el alcance o ámbito de las variables, consulte aquí.

Ejemplo:

// Programa Java para ilustrar el

// alcance de Inicializar variables
// dentro del bucle
public class Example5
{
public static void main(String[] args)
{
 // "x" y "y" solo son de alcance
// dentro del bucle for
for(int x = 0, y = 0; x < 3 && y < 3; x++, y++)
{
System.out.println(y + " ");
}

System.out.println(x);
}
}

Salida:

Example5.java:13: error: cannot find symbol

System.out.println(x);

En el ejemplo anterior, la variable x no es accesible fuera del bucle. La declaración que se

comenta da error de compilación.

3. Bucle do while
El bucle do while es similar al while con la única diferencia de que comprueba la condición
después de ejecutar las instrucciones, y por lo tanto es un ejemplo de Exit Control Loop (Salir
del bloque de control).
1. El bucle do while comienza con la ejecución de la(s) declaración(es). No hay
verificación de ninguna condición la primera vez.

2. Después de la ejecución de los enunciados, y la actualización del valor de la variable,

la condición se verifica para el valor verdadero o falso. Si se evalúa como verdadero,
comienza la siguiente iteración del ciclo.

3. Cuando la condición se vuelve falsa, el ciclo finaliza y marca el final de su ciclo de

vida.

4. Es importante tener en cuenta que el bucle do-while ejecutará sus declaraciones al

menos una vez antes de que se verifique cualquier condición, y por lo tanto es un ejemplo
de bucle de control de salida.

Ejemplo:

// Programa Java para ilustrar el bucle do-while

class dowhileloopDemo
{
public static void main(String args[])
{
int x = 21;
do
{
//El código dentro del do se imprime incluso
//si la condición es falsa
System.out.println("Valor de x :" + x);
x++;
}
while (x < 20);
}
}

Salida:

Valor de x: 21

4. Errores de bucles: Bucle infinito

Uno de los errores más comunes al implementar cualquier tipo de bucle es que nunca puede
salir, es decir, el bucle se ejecuta durante un tiempo infinito. Esto sucede cuando la condición
falla por alguna razón.

Ejemplo:

//Programa Java para ilustrar varias trampas de bucles.

public class LooppitfallsDemo
{
public static void main(String[] args)
{

// bucle infinito porque la condición no es apta

// la condición; debería haber sido i>0.
 for (int i = 5; i != 0; i -= 2)
{
System.out.println(i);
}

int x = 5;
// bucle infinito porque la actualización
// no se proporciona
while (x == 5)
{
System.out.println("En el bucle");
}
}
}

Otro inconveniente es que puede estar agregando algo en su objeto de colección a través de
un bucle y puede quedarse sin memoria. Si intenta ejecutar el siguiente programa, después
de un tiempo, se producirá una excepción de falta de memoria.

//Programa Java para la excepción de falta de memoria.

import java.util.ArrayList;
public class Integer1
{
public static void main(String[] args)
{
ArrayList<Integer> ar = new ArrayList<>();
for (int i = 0; i < Integer.MAX_VALUE; i++)
{
ar.add(i);
}
}
}

Salida:
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
at java.util.Arrays.copyOf(Unknown Source)
at java.util.Arrays.copyOf(Unknown Source)
at java.util.ArrayList.grow(Unknown Source)
at java.util.ArrayList.ensureCapacityInternal(Unknown Source)
at java.util.ArrayList.add(Unknown Source)
at article.Integer1.main(Integer1.java:9)