Download Elementos básicos de Java

Elementos Básicos de Programación en Java
Consideraciones generales
Todo “programa” Java está formado por varias clases (un concepto que se explicará en detalle más
adelante), y cada clase tiene la siguiente estructura:
[modificadores] class NombreClase {
[atributos]
[métodos]
}
Los métodos son bloques de código (es decir, una secuencia de instrucciones) encargados de realizar
alguna función, y existe un método en particular, llamado main, que es el que permite iniciar la ejecución
de un programa Java. Un programa muy sencillo, por lo tanto, está formado por una clase que tiene un
método main, y dentro de este método está el código que se desea ejecutar.
Los bloques de código están enmarcados por llaves (por ejemplo, para enmarcar todo lo que está en la
clase o todo lo que está en un método), de manera que el “esqueleto” para un programa simple es:
public class NombreClase {
public static void main(String[] args) {
// Aquí va el código
}
}
Por ejemplo:
public class ProgramaSencillo {
public static void main(String[] args) {
System.out.println(“Este es un programa Java”);
}
}
Comentarios
Para insertar comentarios en un programa se utiliza:
//
Para comentarios de una línea
/* … */
Para comentarios de varias líneas (llamado comentario tradicional)
/** … */
Para comentarios de varias líneas, que deseen ser incluidos en la documentación HTML
que se genera con una herramienta llamada javadoc (llamado comentario de
documentación)
Tipos de datos
En Java se habla de dos grandes grupos de tipos de datos: los primitivos y los referenciados. Los tipos
de datos primitivos se refieren a datos que son comunes a todos los sistemas, y que se manejan como
valores simples, y son los se tratarán en esta parte.
Elementos básicos de programación en Java - Página 1 de 13
Los tipos de datos primitivos, o básicos, en Java, son:
Nombre
boolean
byte
short
int
long
char
float
double
Descripción
Para guardar valores lógicos
Es un tipo numérico entero, para valores muy
pequeños
Tipo numérico entero, con capacidad media
Tipo entero (el más usado)
Tipo numérico para enteros muy grandes
Para representar un carácter utilizando el formato
UNICODE (http://www.unicode.org/). Java
también lo considera numérico (por la
representación que hace internamente del
carácter)
Tipo numérico decimal, con precisión simple (de
7 dígitos aproximadamente)
Tipo numérico decimal, con precisión doble (de
15 dígitos aproximadamente)
Rango (o valores)
true / false
-128 a 127
-32.768 a 32.767
-2.147’483.648 a 2.147.483.647
-9'223.372'036.854'775.808 a
9'223.372'036.854'775.807
\u0000 a \uFFFF (65536
posibles caracteres)
Literales
Es un valor constante de alguno de los tipos de datos descritos anteriormente, por ejemplo:
120  Es un entero (int), pero también se puede asignar a variables byte, short o long.
3456  En un int. Si se intenta asignar a una variable byte sale un error (por el rango de valores).
789L  Es un long porque termina con la letra L (también se puede usar la l minúscula). Si se intenta
asignar a cualquier otra variable entera se generará un error.
0x12 Es un entero, pero expresado con notación hexadecimal (equivale al 19 en decimal)
‘c’  Es un char, que contiene el carácter c, en la tabla UNICODE \u0063
13.4  Es un double.
13.5F  Es un float porque termina con la letra F.
“Esta es una cadena”  Es de tipo String (no es un tipo básico, pero tiene algunas características que lo
hacen parecido a los tipos básicos).
En general Java toma los valores sin decimales como tipo int, a menos que se indique con la letra L al
final que son long, y toma los valores con decimales como double, a menos que se indique con la letra F
al final que son float. Un carácter (char) está encerrado entre comillas simples y una cadena (String) entre
comillas dobles.
Identificadores
Para los nombres de las clases, los métodos y las variables (entre otros elementos en Java) se deben
seguir las siguientes recomendaciones:




Puede contener letras, números, el símbolo de subrayado y el símbolo de $ (aunque no es
recomendable usarlo).
Sólo pueden comenzar con letra o símbolo de subrayado.
No se pueden usar como identificadores las palabras reservadas del lenguaje
Java es sensible a mayúsculas y minúsculas, es decir una variable llamada “primera” será diferente a
otra llamada “Primera”.
Elementos básicos de programación en Java - Página 2 de 13

Convenciones:
o Los nombres de las clases empiezan en mayúscula. Las demás letras son minúsculas, excepto si
es el comienzo de otra palabra. Ejemplo: Casa, TeatroPrincipal
o Los nombres de los métodos y las variables empiezan en minúscula. Las demás letras son
minúsculas, excepto si es el comienzo de otra palabra, por ejemplo: contador, cuentaVeces
o Las constantes deben ir en mayúscula sostenida, y cada palabra se separa de la anterior por el
símbolo de subrayado, por ejemplo: IVA, VALOR_TOTAL
Palabras reservadas
abstract
boolean
break
byte
case
catch
char
class
const
continue
default
do
double
else
extends
final
finally
float
for
goto
if
implements
import
instanceof
int
interface
long
native
new
package
private
protected
public
return
short
static
strictfp
super
switch
synchronized
this
throw
throws
transient
try
void
volatile
while
true, false y null no son palabras reservadas, sino que son literales predefinidos, por lo cual tampoco
pueden ser utilizados como identificadores.
Variables
Es la unidad básica de almacenamiento en Java (es decir, permite guardar y manipular un valor). Toda
variable debe ser de un tipo definido, y debe ser declarada antes de ser utilizada. La sintaxis para
declarar las variables es:
[modificadores] tipo nombreVariable [= valorInicial];
Se pueden declarar varias variables del mismo tipo en la misma línea, separadas por comas. Ejemplos:
int valor;
// Declara una variable llamada valor, de tipo entero, sin un valor inicial.
double precio = 35.6; // variable precio, de tipo double, con valor inicial 35.6
boolean resultadoUno, resultadoDos=true;
/* declara dos variables de tipo boolean: una llamada resultadoUno, sin valor inicial, y
otra llamada resultadoDos, con valor inicial true.
*/
char letraUno = ‘c’;
char letraDos = letraUno;
/* declara dos variables de tipo char: a la primera le asigna el carácter ‘c’, y a la
segunda el valor que tiene la primera variables, es decir, también ‘c’.
*/
Es posible declarar variables en cualquier parte del programa, pero hay que tener en cuenta:
- Hay que declararlas y darles algún valor inicial antes de incluirlas en alguna expresión.
- Las variables sólo son conocidas dentro del bloque de código en el cual son definidas, y no es
posible declarar dos variables con el mismo nombre dentro del mismo bloque de código.
Ejemplo:
class Alcance {
public static void main (String args [ ]) {
int valorUno = 10;
Elementos básicos de programación en Java - Página 3 de 13
if ( valorUno == 10) {
int valorDos = 20;
//declarada dentro del bloque del if
System.out.print (valorUno + ” “ + valorDos);
}
valorDos = 100; // error, aquí no se conoce la variable valorDos
}
}
Constantes
El valor asignado a las constantes no puede ser modificado en el transcurso del programa. Para declarar
constantes se utiliza la misma sintaxis que para las variables, pero adicionando al comienzo la palabra
reservada final, ejemplo:
final double IVA = 15.3;
Conversión de tipos
La conversión de tipos, que se produce cuando se tienen expresiones que combinan valores o variables
de diferentes tipos, puede darse de dos formas:
-
Automática (o promoción): Se produce cuando los tipos son compatibles y el destino es más grande
que el origen (como asignar un short a un entero, o un entero a un double). Ejemplo:
byte pequeño = 123;
int entero = pequeño;
-
Explícita (cast): Cuando los tipos son compatibles pero el destino es más pequeño que el origen (se
corre el riesgo de perder información). En este caso el programador debe escribir el tipo al cual desea
la conversión entre paréntesis, por ejemplo:
int valor = (int)12.3; // En este caso sólo se toma la parte entera (12): es un cast a entero
int numeroEntero = 43;
byte valorPequeno = (byte) numeroEntero;
// Para poder asignar un int a un byte
Las conversiones entre tipos incompatibles (por ejemplo, de boolean a entero) no son permitidas por el
compilador.
Operaciones
Cada tipo de dato tiene un conjunto de operaciones que pueden realizarse, por ejemplo, los enteros,
como en matemáticas, pueden sumarse, restarse, multiplicarse, etc. A continuación se presentan las
principales operaciones que están disponibles en Java:

Asignación:
Para asignar un valor a una variable se usa el operando =, por ejemplo:
int numero;
numero = 34;
// A la variable número se le asigna el valor 34.
double decimal = numero + 3.5;
/* A la variable decimal se le asigna el resultado de la operación que hay al lado derecho
(en este caso, 37.5) */

Aritméticas:
Operaciones básicas entre dos operandos de tipo numérico:
Elementos básicos de programación en Java - Página 4 de 13
+
*
/
%
Suma
Resta
Multiplicación
División
Módulo (residuo de la división)
Cuando se realiza una expresión que incluye operaciones aritméticas el resultado será del tipo de dato
con mayor precisión involucrado en la expresión. Por ejemplo, si todos los operandos son enteros el
resultado será entero (¡incluso en una división!), pero si algún operando es double el resultado será
double.
Ejemplo:
int operandoUno = 9, operandoDos = 4;
int multiplicacion = operandoUno * operandoDos;
// en multiplicación queda 36
int residuo = operandoUno % operandoDos;
// en residuo queda 1
double division = operandoUno / operandoDos;
// en división queda 2.0 (división entera)
division = operandoUno / 4.0;
// en división queda 2.25 (porque ya hay un double)
Estas operaciones se pueden combinar con la asignación si uno de los operandos es el mismo donde se
desea guardar el resultado. Es decir, si se tiene una operación de la forma a = a + b, se puede cambiar
por: a+=b. Ejemplo:
double valorDecimal = 34.5;
valorDecimal*=3;
// Es equivalente a: valorDecimal = valorDecimal * 3;
Operaciones que aplican sobre un operando:
++
Incremento en uno. Si este operando está ANTES se llama pre-incremento, y significa que
primero se incrementa la variable antes de hacer otras operaciones que involucren a esa
variable en la misma expresión.
Si este operando está DESPUÉS se llama pos-incremento, y significa que primero realiza las
operaciones (con el valor anterior de la variable) en la expresión y luego incrementa el valor de la
variable en uno.
-Decremento en uno. Funciona igual que el incremento.
Ejemplo:
int valorInicial = 5;
int evaluacion = valorInicial++;
// valorInicial queda con valor 6, y evaluación con valor 5
int valorInicialDos = 5;
int evaluacionDos = ++valorInicialDos;
// valorInicialDos queda con valor 6, lo mismo que evaluacionDos.

Relacionales:
Comparan dos operandos numéricos, y el resultado es un valor de tipo boolean. Son:
>
Mayor que
<
Menor que
==
Igual
!=
Diferente
>=
Mayor o igual
<=
Menor o igual
Ejemplo:
Elementos básicos de programación en Java - Página 5 de 13
int número = 45;
boolean comparación = número > 50;

// el resultado es false
Lógicas:
Permiten realizar operaciones entre operandos de tipo boolean, y son:
!
Es la negación (es un operador unitario)
&
AND
&&
AND cortocircuito (si el primer operador es false no evalúa el segundo)
|
OR
||
OR cortocircuito (si el primer operador es true no evalúa el segundo)
^
OR excluyente
Ejemplo:
int valorA = 3, valorB = 4;
boolean resultado = (valorA != valorB) || (valorB < valorA);

?:
Condicional:
Evalúa la expresión (que debe ser boolean) que está antes de la interrogación, y si es verdadera
toma el valor que está justo después de la interrogación (y antes de los dos puntos), pero si es
falsa toma el valor que hay después de los dos puntos. Por ejemplo:
byte numero = 46;
int resultado = (numero > 20) ? numero - 11 : numero;
// En este caso, como la expresión es verdadera, en resultado queda 35 (número no se afecta)
char par = (resultado % 2 == 0) ? ‘s’ : ‘n’;
// En este caso, como la expresión es falsa, en par queda el carácter n

Concatenación:
El operador + cuando se usa entre cadenas de caracteres (String) da como resultado una nueva cadena
que es la unión de las dos anteriores. Por ejemplo:
String texto = “Este es “;
String otroTexto = “ un texto”;
String textoFinal = texto + otroTexto; //en textoFinal queda “Este es un texto”
También se puede concatenar una cadena con un tipo básico, dando como resultado una nueva cadena.
Por ejemplo:
int valor = 3456;
String mensaje = “El valor es: ” + valor;

//en mensaje queda “El valor es 3456”
Precedencia
Es importante tener en cuenta la precedencia de los operadores en Java, ya que esta define la forma de
evaluar una expresión cuando no hay paréntesis. Por ejemplo, la expresión: 3 – 6 / 3 * 4 + 8, es
equivalente a: (3 – ( (6 / 3) * 4) ) + 8.
La precedencia de los operadores es:
Nivel
1
2
Aclaración
Operadores sufijos
Operadores unarios
Operadores
expr++ expr-++expr --expr
+ -
!
Elementos básicos de programación en Java - Página 6 de 13
3
4
5
6
7
8
9
10
11
12
13
14
Conversión explícita
Multiplicativos
Aditivos
Relacionales
De igualdad
Y
O exclusivo
O
Y cortocircuito
O cortocircuito
Condicional
De asignación
(tipo)
* / %
-+
instanceof < <=
>
>=
== !=
&
^
|
&&
||
?:
= *= /=
%=
+= -=
&= ^= |=
Si en una expresión hay varios operadores con la misma precedencia las operaciones se realizan de
izquierda a derecha. Sin embargo, cuando hay una expresión muy compleja lo más recomendado es
usar paréntesis para que se efectúe en el orden deseado.
Estructuras secuenciales
Instrucciones que se ejecutan una después de la otra. Las instrucciones de este tipo terminan en punto y
coma. Ejemplos:
a) Calcular el valor a pagar a un empleado, dado el número de horas trabajadas y el valor por hora. Se
sabe que hay que hacer un descuento del 15%.
Análisis:
- Se piden los datos: horas trabajadas, valor de la hora y nombre del empleado
- Se calcula el salario bruto (horas * valor hora)
- Se calcula el descuento (salario bruto * 0.15)
- Se calcula el salario neto (salario bruto – descuento) y se muestra
Código:
import corejava.*;
// necesario para poder leer valores por consola
public class SalarioSecuencial {
public static void main (String[] arg) {
final double DESCUENTO = 0.15;
// la instrucción Console.readInt permite leer un valor entero:
int numeroHoras = Console.readInt("Número de horas trabajadas");
// la instrucción Console.readDouble permite leer un valor double:
double valorHora = Console.readDouble ("Valor de la hora");
// la instrucción Console.readLine permite leer una cadena de caracteres:
String nombre = Console.readLine("Nombre del trabajador");
double salarioBruto = numeroHoras * valorHora;
double valorDescuento = salarioBruto * DESCUENTO;
double salarioNeto = salarioBruto - valorDescuento;
// la instrucción System.out.println le permite mostrar una cadena de texto.
System.out.println ("El trabajador "+nombre+" tiene un salario neto de "+salarioNeto);
}
}
b) Elaborar un programa que permita convertir una temperatura, dada en grados centígrados, a grados
Fahrenheit. La fórmula es: F = (9/5)C + 32.
Elementos básicos de programación en Java - Página 7 de 13
Análisis:
- Se pide la temperatura en grados centígrados
- Se calcula la temperatura en grados Fahrenheit: ((9 / 5)* temperatura en C) + 32. Sin embargo, si se
realiza la división 9/5 en Java no dará el resultado esperado porque es una división entre enteros
(daría 1 y no 1.8), por lo tanto se puede escribir alguno de los elementos como un double (por
ejemplo: 9.0/5) o se puede hacer la fórmula como (9* temperatura en C) / 5 ) +32
- Se muestra el valor
Código:
import corejava.*;
public class ConvertirTemperatura {
public static void main(String[] args) {
double centigrados = Console.readDouble("Temperatura");
double fahrenheit = (( 9 * centigrados) / 5 ) + 32;
System.out.println("En grados Fahrenheit es: "+ fahrenheit);
}
}
Estructuras de decisión
Muchas veces en un programa es necesario hacer algunas operaciones sólo si se cumple una condición.
Para esto se tienen las siguientes estructuras en Java:

Selección simple y doble (If)
La sintaxis para esta instrucción es:
if (condición) {
// instrucciones que se ejecutan si se cumple la condición
}
else {
// instrucciones que se ejecutan si no se cumple la condición
}
La condición, que siempre debe ir entre paréntesis, puede ser cualquier expresión cuyo resultado final
sea un valor booleano (true o false). La sentencia else (con sus instrucciones) es opcional.
Si sólo hay una instrucción en el if, las llaves son opcionales, pero se recomienda tenerlas siempre para
evitar confusiones.
Ejemplos:
a) Calcular el salario de un trabajador dadas las horas trabajadas y el valor de la hora. Se aplica un
descuento del 15% solo si el salario es superior a 500.000.
Análisis:
- Se piden los datos al usuario: horas trabajadas, valor hora y nombre del trabajador
- Se calcula el salario (horas * valor hora)
- Si el salario es superior a 500000
o Se calcula el descuento y se resta del salario
- Se muestra el salario
Código:
import corejava.*;
public class SalarioConDecision {
public static void main (String[] arg) {
Elementos básicos de programación en Java - Página 8 de 13
final double DESCUENTO = 0.15;
int numeroHoras = Console.readInt("Número de horas trabajadas");
double valorHora = Console.readDouble ("Valor de la hora");
String nombre = Console.readLine("Nombre del trabajador");
double salario = numeroHoras * valorHora;
if (salario > 500000 ) {
double valorDescuento = salario * DESCUENTO;
salario -= valorDescuento;
}
System.out.println ("El trabajador "+nombre+" tiene un salario Neto de "+salario);
}
}
b) Para un viaje en una aerolínea cada pasajero tiene derecho a llevar hasta 80 kilos de equipaje, sin
costo adicional. Si un pasajero lleva más de este peso se le cobra un recargo, que varía dependiendo
de la ciudad de destino: si es Cali, Bogotá o Medellín se le cobran $2000 (una tarifa fija) y si es para
otra ciudad se le cobran $400 por cada kilo adicional (por ejemplo, si lleva 90 kilos debe pagar
$4000).
Análisis:
- Se pide el peso del equipaje que lleva el pasajero
- Si el peso es menor o igual a 80 se muestra un mensaje indicando que no hay costo
- Sino (si el peso es superior)
o Se pide la ciudad de destino
o Si la ciudad es Cali, Bogotá o Medellín se muestra que el costo es 2000
o Sino (si es otra ciudad)
 Se obtienen los kilos adicionales (restando 80) y se multiplica por 400
 Se muestra el valor obtenido
Código:
import corejava.*;
public class CostoEquipaje{
public static void main(String[] arg) {
double TOPE = 80;
double pesoEquipaje = Console.readDouble("Peso del equipaje");
if (pesoEquipaje <= TOPE)
System.out.println("No tiene sobrecosto");
else {
int destino = Console.readInt("1 - Cali, 2 - Bogotá, 3 - Medellín, 4 - Otra ciudad");
if (destino == 1 || destino == 2 || destino == 3) {
System.out.println("Debe pagar 2000");
// Puede ir sin llaves si se desea
}
else {
double valor = (pesoEquipaje - TOPE) * 400;
System.out.println("Debe pagar "+valor);
}
}
}
}
Nótese que en el primer if no se tienen llaves porque sólo hay una instrucción (aunque no es
recomendable), sin embargo en el else –como hay más de una instrucción – si hay llaves. Dentro del else
se tiene de nuevo otra estructura de decisión, pues después de preguntar por el peso hay que preguntar
la ciudad de destino para saber el valor que debe cobrarse.

Selección múltiple (switch)
Elementos básicos de programación en Java - Página 9 de 13
Se utiliza cuando las operaciones a realizar dependen del valor que pueda tomar una variable. La sintaxis
para esta instrucción es:
switch (variable) {
case valorUno : // instrucciones que se ejecutan si la variable tiene el valorUno
break;
case valorDos : // instrucciones que se ejecutan si la variable tiene el valorDos
break;
default :
// instrucciones que se ejecutan si la variable tiene cualquier otro valor
}
La variable que se evalúa solo puede ser de un tipo numérico entero (byte, short, int, long o char), y cada
caso es para un único valor (no importa el orden). El caso “default” es opcional.
Si se omite la palabra break se seguirán ejecutando las instrucciones que hay después del caso
seleccionado, es decir, continúa ejecutando las de los siguientes casos.
Ejemplos:
a) Los descuentos para calcular el salario dependen de la categoría salarial, así: para la categoría 1 no
hay descuento, para la 2 hay 7%, para la 3 el descuento es 10% y para todas las demás es 15%.
Análisis:
- Se preguntan los datos iniciales: horas trabajadas, valor hora, nombre trabajador y categoría salarial
- Se calcula el salario base (horas * valor hora)
- Dependiendo de la categoría:
o Si es 1 no se hace nada (no hay descuento) y termina este caso
o Si es 2 se le resta al salario el descuento (que es salario*0.07) y termina este caso
o Si es 3 se le resta al salario el descuento (salario * 0.1) y termina este caso
o Si es otra categoría se le resta al salario el descuento (salario * 0.15)
- Se muestra el salario
Código:
import corejava.*;
public class SalarioDecisionMultiple {
public static void main (String arg[] ) {
int numeroHoras = Console.readInt("Número de horas trabajadas");
int valorHora = Console.readInt ("Valor de la hora");
int categoria = Console.readInt("Categoría salarial:");
String nombre = Console.readLine("Digite el nombre del trabajador");
double salario = numeroHoras * valorHora;
switch (categoria) {
case 1: break;
case 2: salario=salario - (salario*0.07);
break;
case 3: salario=salario - (salario*0.1);
break;
default: salario=salario - (salario*0.15);
}
System.out.println ("El trabajador "+nombre+" tiene un salario Neto de "+salario);
}
}
b) Un médico determina el nivel de estrés de los pacientes como 1, 2 o 3. Si es nivel 1 le debe ordenar
hacer ejercicio. Si es nivel 2 le debe ordenar, además de hacer ejercicio, cambiar su rutina diaria. Si
es nivel 3, además de lo anterior debe recomendarle que tome vacaciones.
Análisis:
Elementos básicos de programación en Java - Página 10 de 13
-
Se pide el nivel de estrés del paciente
Dependiendo del nivel
o Si es 3 se muestra que debe tomar vacaciones y continúa con lo que hay en el siguiente caso
o Si es 2 se muestra que debe cambiar su rutina diaria y continúa con lo del siguiente caso
o Si es 1 se muestra que debe hacer ejercicio
Código:
import corejava.*;
public class NivelEstres {
public static void main (String arg[] ) {
int estres = Console.readInt("Nivel de estrés:");
switch (estres) {
case 3: System.out.println("Tomar vacaciones");
case 2: System.out.println("Cambiar de rutina");
case 1: System.out.println("Hacer ejercicio");
}
}
}
Se puede notar que en el último ejemplo no se utilizó el break, de manera que si el nivel de estrés del
paciente es, por ejemplo, 3 hace lo indicado para ese caso y continúa con lo indicado para los casos 2 y
1, lo cual corresponde a lo presentado en el análisis.
Estructuras repetitivas
Estas estructuras son utilizadas cuando se requiere repetir un conjunto de instrucciones varias veces. Es
muy importante, cuando se tienen este tipo de estructuras, definir muy bien la condición que hace que el
ciclo continúe, pues en algún momento debe terminar para continuar con el resto del programa. Por
ejemplo, si es un ciclo que se debe hacer 5 veces, se puede tener un contador que se inicializa en 1 y
cada vez se incrementa en uno. El ciclo continuará mientras el contador sea menor o igual a 5, y de esta
forma, cuando el contador llegue a 6 el ciclo se detendrá.

while
Ciclo que se repite mientras alguna condición (que va entre paréntesis) sea verdadera. La condición se
evalúa antes de entrar a las instrucciones del ciclo. La sintaxis es:
while (condición) {
// instrucciones
}
Cuando hay una sola instrucción dentro del while las llaves son opcionales, pero se recomienda usarlas
siempre.
Ejemplo: Mostrar los primeros 10 números enteros.
Análisis:
- Se inicializa un contador en 1
- Se repiten las siguientes instrucciones mientras el contador sea menor o igual a 10:
o Mostrar el contador
o Incrementar el contador en 1
Código:
public class Numeros {
public static void main (String arg[] ) {
int número = 1;
Elementos básicos de programación en Java - Página 11 de 13
while (número <= 10) {
System.out.println(número);
número ++;
}
}
}

do-while
Ciclo que se repite mientras alguna condición sea verdadera, pero a diferencia del while siempre se
ejecuta por lo menos una vez (porque la condición se evalúa al final del conjunto de instrucciones, no al
comienzo). La sintaxis es:
do {
// instrucciones
} while (condición);
Ejemplo: Pedir varios números al usuario, hasta que se escriba un múltiplo de 5, y al final mostrar el
promedio de los números ingresados.
Análisis:
- Se inicializa (en 0) una variable para llevar la suma de los números que se van ingresando
- Se inicializa (en 0) una variable para contar los números ingresados
- Se repiten las siguientes instrucciones mientras el usuario no ingrese un número múltiplo de 5 (como
esta condición es compleja, se usará una variable booleana)
o Se pide un número al usuario
o Se suma este número a la variable que lleva la suma
o Se incrementa en uno el contador
o Se evalúa si el número es múltiplo de 5 para cambiar la variable booleana
- Se calcula el promedio (suma / contador) y se muestra
Código:
import corejava.*;
public class Promedio {
public static void main(String[] arg) {
double suma = 0;
int contador = 0;
boolean seguir;
// Esta variable indicará si se continúa o no en el ciclo
do {
int número = Console.readInt("Número ");
suma += número;
contador++;
seguir = ((número % 5) == 0);
// Si el residuo es 0 es múltiplo de 5
}
while (!seguir);
// Mientras no sea múltiplo de 5 seguirá el ciclo
double promedio = suma / contador;
System.out.println("El promedio es: "+ promedio);
}
}

for
Elementos básicos de programación en Java - Página 12 de 13
Permite incluir en el encabezado, además de la condición, una instrucción de inicialización (que solo se
hace una vez antes de iniciar el ciclo) y una de iteración (que se ejecuta al finalizar cada bucle). Aunque
estas instrucciones no son obligatorias, si deben incluirse los punto y comas que las separan. Sintaxis:
for (incialización; condición; iteración) {
// instrucciones
}
Ejemplo: Pedir N números al usuario, y guardarlos en un arreglo unidimensional.
Análisis:
- Se inicializa el arreglo con un tamaño de N.
- Se repiten las siguientes instrucciones N veces
o Se pide un número al usuario
- Se muestra finalmente el arreglo lleno.
Código:
import corejava.*;
public class NumerosArr {
public static void main (String arg[] ) {
int n = Console.readInt("Número de elementos del arreglo: "); //Se pide el tamaño del arreglo
int[] numeros = new int[n]; //Se crea el arreglo con un tamaño de n
for (int i = 0; i < n; i++){ //Se piden los datos del arreglo:
numeros[i] = Console.readInt("Valor "+(i+1)+": ");
}
System.out.print("El arreglo: ["); //Se muestra el arreglo:
for (int i = 0; i < n-1; i++){
System.out.print(numeros[i]+",");
}
System.out.print(numeros[n-1]+"]");
}
}
Elementos básicos de programación en Java - Página 13 de 13