INTRODUCCIÓN A JAVA

Por: MCC. Claudia Patricia Orta Palacios

CONTENIDO
1. TIPOS DE DATOS ....................................................................................................................................... 2
1.1 Tipos de datos simples.............................................................................................................................. 2
1.1.1 Tipos de datos enteros ....................................................................................................................... 2
1.1.2 Tipos de datos en coma flotante ........................................................................................................ 2
1.1.3 Tipos de datos bolean ........................................................................................................................ 2
1.1.4 Tipos de datos carácter ...................................................................................................................... 3
1.2 Tipos de datos compuestos ....................................................................................................................... 3
1.2.1 Vectores y matrices............................................................................................................................ 3
1.2.2 Cadenas.............................................................................................................................................. 3
2. OPERADORES............................................................................................................................................. 5
2.1 Categorías de los operadores .................................................................................................................... 5
2.1.1 Operadores aritméticos ...................................................................................................................... 5
2.1.2 Operadores de comparación y condicionales .................................................................................... 5
2.1.3 Operadores a nivel de bits y lógicos .................................................................................................. 6
2.1.3.1 Operadores de desplazamiento de bits........................................................................................ 6
2.1.3.2 Operadores de lógica de bits....................................................................................................... 7
2.1.4 Operadores de asignación .................................................................................................................. 8
2.2 Precedencia de operadores........................................................................................................................ 8
3. ELEMENTOS FUNDAMENTALES DE UN PROGRAMA EN JAVA ............................................... 10
3.1 Clases...................................................................................................................................................... 10
3.2 Variables ................................................................................................................................................. 10
3.3 Métodos .................................................................................................................................................. 11
3.4 Constructores .......................................................................................................................................... 12
4. ESTRUCTURAS......................................................................................................................................... 13
4.1 ESTRUCTURA SELECTIVA ............................................................................................................... 13
4.1.1 if…else............................................................................................................................................. 13
4.2 ESTRUCTURAS REPETITIVAS.......................................................................................................... 14
4.2.1 while ................................................................................................................................................ 14
4.2.2 do…While........................................................................................................................................ 14
4.2.3 for..................................................................................................................................................... 15
4.3 ESTRUCTURA DE SELECCIÓN MÚLTIPLE .................................................................................... 16
4.3.1 switch............................................................................................................................................... 16
5. ARREGLOS ................................................................................................................................................ 18
5.1 ARREGLOS UNIDIMENSIONALES................................................................................................... 18
5.2 ARREGLOS MULTIDIMENSIONALES ............................................................................................. 19
5.3 OPERACIONES CON MATRICES Y VECTORES............................................................................. 21
5.4 APLICACIONES UTILIZANDO ARREGLOS UNIDIMENSIONALES ........................................... 21
5.4 APLICACIONES UTILIZANDO ARREGLOS MULTIDIMENSIONALES...................................... 22
6. EJERCICIOS.............................................................................................................................................. 25
REFERENCIAS.............................................................................................................................................. 26

1
1. TIPOS DE DATOS
Los tipos de datos en Java pueden dividirse en dos categorías: simples y compuestos. Los simples son tipos
nucleares que no se derivan de otros tipos, como los enteros, de coma flotante, booleanos y de carácter. Los
tipos compuestos se basan en los tipos simples e incluyen las cadenas, las matrices y tanto las clases como las
interfaces, en general.

1.1 Tipos de datos simples

Para crear una variable (de un tipo simple) en memoria debe declararse indicando su tipo de variable y su
identificador que la identificará de forma única. La sintaxis de declaración de variables es la siguiente:

TipoSimple Identificador1;

Esta sentencia indica al compilador que reserve memoria para la variable del tipo simple TipoSimple con
nombre Identificador1.

Cada tipo de datos simple soporta un conjunto de literales que le pueden ser asignados, para darles valor. En
este apartado se explican los tipos de datos simples (o primitivos) que presenta Java, así como los literales
que soporta (sintaxis de los valores que se les puede asignar).

1.1.1 Tipos de datos enteros

Se usan para representar números enteros con signo. Hay cuatro tipos: byte, short, int y long (veáse tabla 1).

Tipo Tamaño
byte 1Byte (8 bits)
short 2 Bytes (16 bits)
int 4 Bytes (32 bits)
long 8 Bytes (64 bits)

Tabla 1. Tipos de datos enteros.

1.1.2 Tipos de datos en coma flotante

Se usan para representar números con partes fraccionarias. Hay dos tipos de coma flotante: float y double. El
primero reserva almacenamiento para un número de precisión simple de 4 bytes y el segundo lo hace para un
número de precisión doble de 8 bytes (véase tabla 2).

Tipo Tamaño
float 4 Byte (32 bits)
double 8 Bytes (64 bits)

Tabla 2. Tipos de datos en coma flotante.

1.1.3 Tipos de datos bolean

Se usa para almacenar variables que presenten dos estados, que serán representados por los valores true y
false. Representan valores bi-estado, provenientes del denominado álgebra de Boole.

2
Para declarar un dato del tipo booleano se utiliza la palabra reservada boolean:

boolean reciboPagado = false; // ¡¿Aun no nos han pagado?!

1.1.4 Tipos de datos carácter

Se usa para almacenar caracteres Unicode simples. Debido a que el conjunto de caracteres Unicode se
compone de valores de 16 bits, el tipo de datos char se almacena en un entero sin signo de 16 bits.

Las variables de tipo char se declaran de la siguiente forma:

char letraMayuscula = 'A'; // Observe la necesidad de las ' '

1.2 Tipos de datos compuestos

Los tipos compuestos se basan en los tipos simples e incluyen las cadenas, las matrices y tanto las clases
como las interfaces, en general.

1.2.1 Vectores y matrices

Una matriz es una construcción que proporciona almacenaje a una lista de elementos del mismo tipo, ya sea
simple o compuesto. Si la matriz tiene solo una dimensión, se la denomina vector.

En Java los vectores se declaran utilizando corchetes ( [ y ] ), tras la declaración del tipo de datos que
contendrá el vector. Por ejemplo, esta sería la declaración de un vector de números enteros (int):

int vectorNumeros[ ]; // Vector de números

Se observa la ausencia de un número que indique cuántos elementos componen el vector, debido a que Java
no deja indicar el tamaño de un vector vacío cuando le declara. La asignación de memoria al vector se realiza
de forma explícita en algún momento del programa.

Para ello o se utiliza el operador new:

int vectorNumeros = new int[ 5 ]; // Vector de 5 números

O se asigna una lista de elementos al vector:

int vectorIni = { 2, 5, 8};

1.2.2 Cadenas

En Java se tratan como una clase especial llamada String. Las cadenas se gestionan internamente por medio
de una instancia de la clase String. Una instancia de la clase String es un objeto que ha sido creado siguiendo
la descripción de la clase.

Cuando Java encuentra una constante de cadena, crea un caso de la clase String y define su estado, con los
caracteres que aparecen dentro de las comillas dobles.

Vemos un ejemplo de cadena declarada con la clase String de Java:

3
String capitalUSA = "Washington D.C.";

String nombreBonito = "Amelia";

4
2. OPERADORES
Los operadores son un tipo de tokens que indican una evaluación o computación para ser realizada en objetos
o datos y en definitiva sobre identificadores o constantes.

Además de realizar la operación, un operador devuelve un valor, ya que son parte fundamental de las
expresiones. El valor y tipo que devuelve depende del operador y del tipo de sus operandos.

2.1 Categorías de los operadores

Los operadores de Java se pueden dividir en las siguientes cuatro categorías:

• Aritméticos.
• De comparación y condicionales.
• A nivel de bits y lógicos.
• De asignación.

2.1.1 Operadores aritméticos

El lenguaje Java soporta varios operadores aritméticos para los números enteros y en coma flotante. Se
incluye + (suma), - (resta), * (multiplicación), / (división), y % (módulo, es decir, resto de una división
entera). Por ejemplo:

sumaEste + aEste; //Suma los dos enteros

divideEste % entreEste; //Calcula el resto de dividir 2 enteros

El tipo de los datos devueltos por una operación aritmética depende del tipo de sus operandos; si se suman
dos enteros, se obtiene un entero como tipo devuelto con el valor de la suma de los dos enteros.

Estos operadores se deben utilizar con operandos del mismo tipo, o si no realizar una conversión de tipos de
uno de los dos operandos al tipo del otro.

En la tabla 3 se muestran los operadores aritméticos que utiliza java.

Operador Uso Descripción

+ op1 + op2 Suma op1 y op2
- op1 - op2 Resta op2 de op1
* op1 * op2 Multiplica op1 por op2
/ op1 / op2 Divide op1 por op2
% op1 % op2 Calcula el resto de dividir op1 entre op2

Tabla 3. Operadores aritméticos.

2.1.2 Operadores de comparación y condicionales

Un operador de comparación compara dos valores y determina la relación existente entre ambos. Por
ejemplo, el operador != devuelve verdadero (true) si los dos operandos son distintos. La tabla 4 resume los
operadores de comparación de Java:

5
 Operador Uso Devuelve verdadero si
> op1 > op2 op1 es mayor que op2
>= op1 >= op2 op1 es mayor o igual que op2
< op1 < op2 op1 es menor que op2
<= op1 <= op2 op1 es menor o igual que op2
== op1 == op2 op1 y op2 son iguales
!= op1 != op2 op1 y op2 son distintos

Tabla 4. Operadores de comparación.

Los operadores de comparación suelen ser usados con los operadores condicionales para construir
expresiones complejas que sirvan para la toma de decisiones. Un operador de este tipo es &&, el cual realiza
la operación booleana and. Por ejemplo, se pueden utilizar dos operaciones diferentes de comparación con
&& para determinar si ambas relaciones son ciertas. La siguiente línea de código utiliza esta técnica para
determinar si la variable index de una matriz se encuentra entre dos límites (mayor que cero y menor que la
constante NUMERO_ENTRADAS):

( 0 < index ) && ( index < NUMERO_ENTRADAS )

Java soporta cinco operadores condicionales, mostrados en la tabla 5.

Operador Uso Devuelve verdadero si...

&& op1 && op2 op1 y op2 son ambos verdaderos, condicionalmente evalúa
op2
& op1 & op2 op1 y op2 son ambos verdaderos, siempre evalúa op1 y op2
|| op1 || op2 op1 o op2 son verdaderos, condicionalmente evalúa op2
| op1 | op2 op1 o op2 son verdaderos, siempre evalúa op1 y op2
! ! op op es falso

Tabla 5. Operadores condicionales.

2.1.3 Operadores a nivel de bits y lógicos

Un operador de bit permite realizar operaciones de bit sobre los datos. Existen dos tipos: los que
desplazan (mueven) bits, y operadores lógicos de bit.

2.1.3.1 Operadores de desplazamiento de bits

En la tabla 6 se muestran los operadores de desplazamiento de bits.

Operador Uso Operación

>> op1 >> op2 Desplaza los bits de op1 a la derecha op2 veces
<< op1 << op2 Desplaza los bits de op1 a la izquierda op2 veces
>>> op1 >>> op2 Desplaza los bits de op1 a la derecha op2 veces (sin
signo)

Tabla 6. Operadores de desplazamiento.

6
Los tres operadores de desplazamiento simplemente desplazan los bits del operando de la parte izquierda el
número de veces indicado por el operando de la parte derecha. El desplazamiento ocurre en la dirección
indicada por el operador. Por ejemplo, la siguiente sentencia, desplaza los bits del entero 13 a la derecha una
posición:

13 >> 1;

La representación en binario del número 13 es 1101. El resultado de la operación de desplazamiento es 1101

desplazado una posición a la derecha, 110 o 6 en decimal. Se debe tener en cuenta que el bit más a la derecha
se pierde en este caso.

El desplazamiento sin signo >>> funciona de la siguiente manera:

• Si se desplaza con signo el número -1 (1111), seguirá valiendo -1, dado que la extensión de signo
sigue introduciendo unos en los bits más significativos.
• Con el desplazamiento sin signo se consigue introducir ceros por la izquierda, obteniendo el número 7
(0111).

2.1.3.2 Operadores de lógica de bits

La lógica de bits (lógica de Bool) se utiliza para modelizar condiciones biestado y trabajar con ellas
(cierto/falso, true/false, 1/0).

En Java hay cuatro operadores de lógica de bits (véase tabla 7).

Operador Uso Operación

& op1 & op2 AND
| op1 | op2 OR
^ op1 ^ op2 OR Exclusivo
~ ~op2 Complemento

Tabla 7. Operadores de lógica de bits.

El operador & realiza la operación AND de bit. Aplica la función AND sobre cada par de bits de igual peso
de cada operando. La función AND es evaluada a cierto si ambos operandos son ciertos.

Por ejemplo vamos a aplicar la operación AND a los valores 12 y 13:

12 & 13

El resultado de esta operación es 12. ¿Por qué?. La representación en binario de 12 es 1100, y de 13 es 1101.
La función AND pone el bit de resultado a uno si los dos bits de los operandos son 1, sino, el bit de resultado
es 0:

1101
& 1100
------
1100

7
2.1.4 Operadores de asignación

El operador de asignación básico es el =, que se utiliza para asignar un valor a otro. Por ejemplo:

int contador = 0;

Inicia la variable contador con un valor 0.

Java además proporciona varios operadores de asignación que permiten realizar un atajo en la escritura de
código. Permiten realizar operaciones aritméticas, lógicas, de bit y de asignación con un único operador.

Supongamos que necesitamos sumar un número a una variable y almacenar el resultado en la misma variable,
como a continuación:

i = i + 2;

Se puede abreviar esta sentencia con el operador de atajo +=, de la siguiente manera:

i += 2;

La tabla 8 muestra los operadores de atajo de asignación y sus equivalentes largos:

Operador Uso Equivalente a

+= op1 += op2 op1 = op1 + op2
-= op1 -= op2 op1 = op1 - op2
*= op1 *= op2 op1 = op1 * op2
/= op1 /= op2 op1 = op1 / op2
%= op1 %= op2 op1 = op1 % op2
&= op1 &= op2 op1 = op1 & op2

Tabla 8. Operadores de atajo de asignación.

2.2 Precedencia de operadores

Cuando en una sentencia aparecen varios operadores el compilador deberá de elegir en qué orden aplica los
operadores. A esto se le llama precedencia.

Los operadores con mayor precedencia son evaluados antes que los operadores con una precedencia relativa
menor.

Cuando en una sentencia aparecen operadores con la misma precedencia:

• Los operadores de asignación son evaluados de derecha a izquierda.

• Los operadores binarios, (menos los de asignación) son evaluados de izquierda a derecha.

Se puede indicar explícitamente al compilador de Java cómo se desea que se evalúe la expresión con
paréntesis balanceados ( ). Para hacer que el código sea más fácil de leer y mantener, es preferible ser
explícito e indicar con paréntesis que operadores deben ser evaluados primero.

8
La tabla 9 muestra la precedencia asignada a los operadores de Java. Los operadores de la tabla están listados
en orden de precedencia: cuanto más arriba aparezca un operador, mayor es su precedencia. Los operadores
en la misma línea tienen la misma precedencia:

Tipo de operadores Operadores de este tipo

Operadores posfijos [ ] . (parametros) expr++ expr--
Operadores unarios ++expr --expr +expr -expr ~ !
Creación o conversión new (tipo) expr
Multiplicación */%
Suma +-
Desplazamiento <<
Comparación < <= = instanceof
Igualdad == !=
AND a nivel de bit &
OR a nivel de bit ^
XOR a nivel de bit |
AND lógico &&
OR lógico ||
Condicional ?:
Asignación = += -= *= /= %= &= ^= |= <<= = =

Tabla 9. Precedencia de operadores en Java.

Por ejemplo, la siguiente expresión produce un resultado diferente dependiendo de si se realiza la suma o
división en primer lugar:

x + y / 100

Si no se indica explícitamente al compilador el orden en que se quiere que se realicen las operaciones,
entonces el compilador decide basándose en la precedencia asignada a los operadores. Como el operador de
división tiene mayor precedencia que el operador de suma el compilador evaluará y/100 primero.

Así:

x + y / 100

Es equivalente a:

x + (y / 100)

9
3. ELEMENTOS FUNDAMENTALES DE UN PROGRAMA EN JAVA

3.1 Clases

La forma básica de una declaración de una clase en java es la siguiente:

[modificador de acceso] class nombre_clase

{
Cuerpo de la clase
}

Los modificadores de acceso utilizados para las clases en java se describen a continuación.

• public Una clase pública puede ser usada en cualquier programa de java sin ninguna restricción.
• final Una clase final no puede ser modificada ni heredada.
• abstract Una clase abstracta no puede ser instanciada. Sólo puede ser accesada por medio de la
herencia.

El cuerpo de una clase puede contener los siguientes elementos:

• Variables
• Métodos
• Constructores

3.2 Variables

En el diagrama que se muestra en la figura 1 se enlistan los tipos de datos primitivos más comúnmente
usados para la declaración de variables dentro de una clase en java.

10
 boolean

char

byte

Tipos de datos short

primitivos
int

long

float

double

Figura 1. Tipos de datos primitivos de Java.

A continuación se muestran algunos ejemplos de declaración de variables en java.

private int acct_no;

private double acct_bal;

3.3 Métodos

Un método es un procedimiento de cálculo definido en una clase, puede contener instrucciones y variables.
La estructura básica de un método es la siguiente:

Modificador de acceso Tipo de retorno nombre (tipo arg1, tipo arg2,… )

{
Declaraciones e Instrucciones
}

Los modificadores de acceso para métodos son los siguientes:

• public
• private
• protected
• static
• final
• abstract

11
 • syncronized
• native
• default

Los más comunes se describen a continuación:

• public.- Un método público es accesado desde cualquier método, dentro o fuera de la clase.
• Private.- Un método privado es accesado por métodos miembros de la misma clase.
• Protected.- Un método protegido es accesado por métodos miembros de la misma clase o clase
derivada.

A continuación se muestran las declaraciones de algunos métodos en java (sumar, mostrar,calcular).

Class Ejemplo
{
//Variables
public int x;
protected long y;
private boolean z;
//métodos
public int sumar(int a, int b){…}
protected void mostrar( ){…}
}

3.4 Constructores

Un constructor es un método miembro que tiene el mismo nombre que la propia clase, se utiliza para realizar
inicializaciones cuando se crea un objeto.

La estructura básica de un constructor se muestra a continuación.

Modificador de acceso nombre de la clase (tipo arg1, tipo arg2,… )

{
}

Los modificadores de acceso para constructores son los siguientes:

• public
• private
• protected
• default

12
4. ESTRUCTURAS

4.1 ESTRUCTURA SELECTIVA

4.1.1 if…else

La sentencia if-else es probablemente la manera más básica de controlar el flujo de un programa. El else es
opcional, por lo que puede usarse if de dos formas:

if (expresión condicional)
sentencia
if (expresión condicional)
sentencia
else
sentencia

La expresión condicional debe producir un resultado boolean. La sentencia equivale bien a una sentencia simple
acabada en un punto y coma, o a una sentencia compuesta, que es un conjunto de sentencias simples encerradas
entre llaves. Cada vez que se use la palabra sentencia, siempre implicará que ésta puede ser simple o compuesta.

He aquí un método prueba( ) como ejemplo de if-else. Se trata de un método que indica si un número dicho en un
acertijo es mayor, menor o equivalente al número solución:

public class IfElse {

static int prueba(int intento, int solucion) {
int resultado = 0;
if (intento > solucion)
resultado = +l;
else if (intento < solucion)
resultado = -1;
else
resultado = 0; / / Coincidir
return resultado;
}

public static void main(String[] args) {

System.out.println (prueba (10, 5) ) ;
System.out.println (prueba (5, 10) ) ;
System.out.println (prueba (5, 5) ) ;
}
}

Es frecuente alinear el cuerpo de una sentencia de control de flujo, de forma que el lector pueda determinar
fácilmente dónde empieza y dónde acaba.

13
4.2 ESTRUCTURAS REPETITIVAS

Las sentencias while, do..while y for son para el control de bucles y en ocasiones se clasifican como sentencias
de iteración. Se repite una sentencia hasta que la expresión Condicional controladora se evalúe a falsa.

4.2.1 while

La forma de un bucle while es:

while (Expresión-
Condicional)
sentencia

La expresión condicional se evalúa al comienzo de cada iteración del bucle y de nuevo antes de cada iteración
subsiguiente de la sentencia.

He aquí un ejemplo sencillo que genera números aleatorios hasta que se dé una condición determinada:
public class PruebaWhile {
public static void main(String[] args) {
double r = 0;
while(r < 0.99) {
r = Math.random() ;
System.out.println(r);
}
}
}

Este ejemplo usa el método estático random( ) de la biblioteca Math, que genera un valor double entre O y 1.
(Incluye el O, pero no el 1.) La expresión condicional para el while dice "siga haciendo este bucle hasta que el
número sea 0,99 o mayor". Cada vez que se ejecute este programa, se logrará un listado de números de distinto
tamaño.

4.2.2 do…While

La forma del do-while es

do
sentencia
while (Expresión condicional);

La única diferencia entre while y do-while es que la sentencia del do-while se ejecuta siempre, al menos, una
vez, incluso aunque la expresión se evalúe como falsa la primera vez. En un while, si la condicional es falsa la
primera vez, la sentencia no se ejecuta nunca. En la práctica, do-while es menos común que while.

A continuación se muestra un ejemplo que utiliza esta estructura para calcular la suma de dos números.

package instrucciondowhile;

14
import javax.swing.*;

public class InstrDowhile {

public InstrDowhile() {
}
public int sumar(int a, int b){
int sum;
sum=a+b;
return sum;
}

public static void main(String[] args) {

int num1,num2,suma,resp=1;
InstrDowhile obj=new InstrDowhile();
do{
num1=Integer.parseInt(JOptionPane.showInputDialog("Introduzca el primer
número"));
num2=Integer.parseInt(JOptionPane.showInputDialog("Introduzca el segundo
número"));
suma=obj.sumar(num1,num2);
JOptionPane.showMessageDialog(null,"La suma de ambos números es: "+suma);
resp=Integer.parseInt(JOptionPane.showInputDialog("Desea sumar otros
números (0 no/1 si)?"));
}while(resp==1);
JOptionPane.showMessageDialog(null,"Finalización del programa ");
}
}

En este ejemplo se usa la biblioteca javax.swing.* para poder utilizar los métodos showInputDialog y
showMessageDialog.

4.2.3 for

Un bucle for lleva a cabo la inicialización antes de la primera iteración. Después, lleva a cabo la comprobación
condicional y al final de cada iteración, hace algún tipo de "paso". La forma del bucle for es:

for(inicia1ización; Expresión condicional; paso)

sentencia

Cualquiera de las expresiones inicialización, expresión condicional o paso puede estar vacía. Dicha expresión se
evalúa antes de cada iteración, y en cuanto el resultado sea falso, la ejecución continuará en la línea siguiente a la
sentencia for. Al final de cada iteración se ejecuta paso.

Los bucles for suelen utilizarse para crear contadores:

public class Listacaracteres {

public static void main (String[] arqs) {
for( char c = 0; c < 128; c++)
if (c != 26 ) // Limpiar pantalla ANSI
System.out.println("valor: " + (int) c +"caracter: " + c) ;

}
}

15
Fíjese en que la variable c está definida en el punto en que se usa, dentro de la expresión de control del bucle for,
en vez de al principio del bloque delimitado por la llave de apertura. El ámbito de c es la expresión controlada por
el for.

A continuación se muestra otro ejemplo donde se utiliza el bucle for. El funcionamiento de este programa
consiste en obtener el cuadrado de un número dado.

package instruccfor;
import javax.swing.*;

public class InstFor {

public InstFor() {
}

public double contar(double a)

{
double cuadrado=1;
for(int i=0;i<2;++i)
{
cuadrado*=a;
}
return cuadrado;
}
public static void main(String[] args) {

double num,cuadrado;
num=Double.parseDouble(JOptionPane.showInputDialog("Introduzca el número que
desea elevar al cuadrado"));
InstFor a=new InstFor();
cuadrado=a.contar(num);
JOptionPane.showMessageDialog(null,"El Cuadrado de "+num+" es "+cuadrado);

}
}

4.3 ESTRUCTURA DE SELECCIÓN MÚLTIPLE

4.3.1 switch

La orden switch suele clasificarse como sentencia de selección. La sentencia switch selecciona de entre
fragmentos de código basados en el valor de una expresión entera. Es de la forma:
switch (selector-entero) {
case valor-entero1 : sentencia; break;
case valor-entero2 : sentencia; break;
case valor-entero3 : sentencia; break;
case valor-entero4 : sentencia; break;
case valor-entero5 : sentencia; break;
// ...
default : sentencia;
}

16
El selector entero es una expresión que produce un valor entero. El switch compara el resultado de selector
entero con cada valor entero. Si encuentra un valor que coincida, ejecuta la sentencia (simple o compuesta)
correspondiente. Si no encuentra ninguna coincidencia, ejecuta la sentencia default. Observese en la
definición anterior que cada case acaba con break, lo que causa que la ejecución salte al final del cuerpo de
la sentencia switch. Ésta es la forma convencional de construir una sentencia switch, pero el break es
opcional. Si no se pone, se ejecutará el código de las sentencias "case" siguientes, hasta encontrar un break.
Aunque este comportamiento no suele ser el deseado, puede ser útil para un programador experimentado.
Hay que tener en cuenta que la última sentencia, la que sigue a default, no tiene break porque la ejecución
llega hasta donde le hubiera llevado el break. Se podría poner un break al final de la sentencia default sin
que ello causara ningún daño, si alguien lo considerara importante por razones de estilo.

La sentencia switch es una forma limpia de implementar una selección de múltiples caminos (por ejemplo,
seleccionar un camino de entre cierto número de caminos de ejecución diferentes), pero requiere de un selector
que se evalúe a un valor como int o char. Si se desea utilizar, por ejemplo, una cadena de caracteres o un número
de coma flotante como selector, no se podrá utilizar una sentencia switch. En el caso de tipos no enteros, es
necesario utilizar una serie de sentencias if.

A continuación se muestra un ejemplo que intenta simular un juego donde se intente adivinar un número.

package instruccionswitch;
import javax.swing.*;

public class InstrSwitch {

public InstrSwitch() {
}

public static void main(String[] args) {

int num;
num=Integer.parseInt(JOptionPane.showInputDialog("Introduzca un número entre 0
y 4:"));
switch(num){
case 1:
JOptionPane.showMessageDialog(null,"Vuelve a intentarlo");
break;
case 2:
JOptionPane.showMessageDialog(null,"!!Le atinaste!!");
break;
case 3:
JOptionPane.showMessageDialog(null,"Vuelve a intentarlo");
break;
case 4:
JOptionPane.showMessageDialog(null,"Vuelve a intentarlo");
break;
default:
JOptionPane.showMessageDialog(null,"Debe ser un número entre 1 y 4");
JOptionPane.showMessageDialog(null,"Fin del juego");
break;
}
}

17
5. ARREGLOS
Los arreglos proporcionan una forma fácil de gestionar un conjunto de datos por medio de un índice, lo que
es fácil para los ordenadores, ya que se puede manipular el índice en el código. Java soporta arreglos
unidimensionales y multidimensionales.

5.1 ARREGLOS UNIDIMENSIONALES

Para tener un arreglo preparado es necesario ejecutar dos pasos. Primero, se debe declarar el arreglo. A
continuación se indica cómo se declara, en general, un arreglo unidimensional:

tipo nombre [ ];

Por ejemplo, así es como se declara un arreglo de valores double, que se llama cuenta.

public class app{

public static void main (String [ ]args)
{
double cuenta[ ];
}
}

Al igual que al declarar variables sencillas, la declaración de un arreglo no reserva memoria, ya que Java no
sabe exactamente que tamaño va a tener. Esto quiere decir que es necesario otro paso en este proceso, la
creación del arreglo.

Después de que se ha declarado un arreglo unidimensional, el siguiente paso es crear ese arreglo alocando
memoria para el.

public class app{

public static void main (String [ ]args)
{
double cuenta [];
cuenta=new double [100];
cuenta[3]=1335.67;
System.out.println(“La cuenta 3 debe $”+cuenta[3]);
}
}

En el código anterior se ha creado un arreglo de exactamente 100 valores double, que Java inicializa a 0. El
límite inferior de todo arreglo de Java es 0, por lo que el primer elemento del arreglo es cuenta[0] y el
superior es cuenta[99]. Si el índice del arreglo está fuera del rango del 0 al 99, Java devolverá un error fatal y
el programa se parara.

Este es el resultado del programa:

La cuenta 3 debe $ 1335.67

De hecho se puede combinar el proceso de declaración y creación de un arreglo en un solo paso:

public class app{

18
 public static void main (String [ ]args)
{
double cuenta []=new double [100];
cuenta[3]=1335.67;
System.out.println(“La cuenta 3 debe $”+cuenta[3]);
}
}

Por otro lado, para inicializar un arreglo unidimensional, únicamente hay que poner los valores entre llaves,
un valor detrás de otro, separados por comas, empezando con el primer valor del arreglo. Este es un ejemplo
que inicializa los primeros cuatro elementos del arreglo cuenta [ ] con datos:
public class app{
public static void main (String [ ]args)
{
double cuenta []={238.45, 999.33, 0, 1335.67}
}
}

5.2 ARREGLOS MULTIDIMENSIONALES

Se pueden declarar arreglos multidimensionales de la misma forma que se declaran los unidimensionales,
sólo con incluir un par de corchetes para cada dimensión del arreglo.

tipo nombre [ ] [ ];

Así funcionan los arrays de dos dimensiones: el índice izquierdo específica la fila y el derecho, la columna.
Por supuesto, no tiene por qué limitarse a las dos dimensiones.

public class app{

public static void main (String [ ]args)
{
double cuenta [][]=new double cuenta[2][100];
}
}

Los arreglos multidimensionales son realmente arreglos de arreglos, lo que significa que si se tiene un arreglo
de dos dimensiones (arreglo [ ][ ]), se puede tratar como un arreglo de arreglos unidimensionales, al que se
puede acceder con arreglo[0], arreglo[1], arreglo[2] y así sucesivamente.

Los arreglos multidimensionales se pueden inicializar cuando se los declara de la misma forma que se
inicializan los unidimensionales: basta con incluir un par de corchetes para cada dimensión y poner los
valores con los que se quiere inicializar el arreglo dentro de los mismos. Por ejemplo, aquí vemos cómo se
inicializa un arreglo de dos dimensiones:
public class app{
public static void main (String [ ]args)
{
double cuenta [][]={{10.11,19,564343.93,43.95},
{11.23,54.23,543.62,2345.06}};
System.out.println(“La cuenta corriente 3 tiene $”+cuenta[1][3]);
}
}

19
Como en otros muchos lenguajes de programación en Java, los arreglos multidimensionales son arreglos de
arreglos. Esto quiere decir que se pueden construir arreglos como se quiera, como en el ejemplo en el que
cada fila de un arreglo de dos dimensiones tiene un diferente número de elementos.

public class app{

public static void main (String [ ]args)
{
double cuenta [][]=new double[5][];
cuenta[0]=new double[500];
cuenta[1]=new double[400];
cuenta[2]=new double[300];
cuenta[3]=new double[200];
cuenta[4]=new double[100];

cuenta[3][3]=1335.67;
System.out.println(“La cuenta 3 tiene $”+cuenta[3][3]);
}
}

Con frecuencia es útil conocer la longitud de un arreglo, especialmente si se está iterando sobre todos los
elementos de arreglo dentro del código. Para saber el número de elementos de un arreglo llamado arreglo1, se
puede usar el término arreglo1.length. El siguiente es un ejemplo que utiliza el bucle for para calcular el
promedio de un estudiante entre un grupo de seis calificaciones (en este caso grades.length devuelve el valor
de 6).

public class app{

public static void main (String [ ]args)
{
double grades[]={88,99,56,37,64};
double sum,promedio;
sum=0;
for(int index=0;index<grades.length;index++)
{
sum+=grades[index];
}
promedio=sum/grades.length;
System.out.println("Grado medio="+promedio);
}

20
5.3 OPERACIONES CON MATRICES Y VECTORES

Las operaciones fundamentales con matrices y vectores son: suma, resta y multiplicación. En la tabla 10 se
presentan algunos ejemplos de dichas operaciones.

OPERACIONES EJEMPLO RESULTADO

VECTORES
SUMA (2,3,4)+(2,5,2) (4,8,6)
RESTA (6,7,4)+(2,5,2) (4,2,2)
MULTIPLICACIÓN (6,7,4)*(2,5,2) (12,35,8)
MATRICES
SUMA 1 − 2 3  1 5 3  2 3 6 
 4 5 − 6 + 3 6 − 6 7 11 − 12
    
2 4 1  2 9 1  4 13 2 
RESTA 1 − 2 3  1 5 3  0 − 7 0
 4 5 − 6 − 3 6 − 6 1 − 1 0
    
2 4 1  2 9 1  0 − 5 0
MULTIPLICACIÓN 3 1  5 1 
1 0 2     4 2
− 1 3 1 × 2 1  
  1 0 
 

Tabla 10. Operaciones con vectores y matrices.

5.4 APLICACIONES UTILIZANDO ARREGLOS UNIDIMENSIONALES

El siguiente programa muestra el uso de los arreglos en la resolución de operaciones con vectores.

public class Vectores {

public Vectores() {
}

public void imprimirVector(String mensaje,int vector[])

{
System.out.print(mensaje);
for(int p=0;p<3;++p)
{
if(p==0)
System.out.print("[");
System.out.print(vector[p]+" ");

}
System.out.print("]");
System.out.println();

}
public void suma(int vector1[], int vector2[])
{
int resultado[]=new int[3];

21
 for(int i=0;i<3;++i)
{
resultado[i]=vector1[i]+vector2[i];
}
imprimirVector("Resultado de la suma de ambos vectores",resultado);
}
public void resta(int vector1[], int vector2[])
{
int resultado[]=new int[3];
for(int j=0;j<3;++j)
{
resultado[j]=vector1[j]-vector2[j];
}
imprimirVector("Resultado de la resta de ambos vectores",resultado);
}
public void multiplicacion(int vector1[], int vector2[])
{
int resultado[]=new int[3];
for(int i=0; i<vector1.length;i++)
{
resultado[i]=vector1[i]*vector2[i];
}
imprimirVector("Resultado de la multiplicación de ambos vectores",resultado);
}

public static void main(String[] args) {

int []vector1=new int []{1,2,3};
int []vector2=new int []{2,5,4};
int resultado []=new int[3];
Vectores obj=new Vectores();
obj.imprimirVector("Vector 1:",vector1);
obj.imprimirVector("Vector 2:",vector2);
obj.suma(vector1,vector2);
obj.resta(vector1,vector2);
obj.multiplicacion(vector1,vector2);

5.4 APLICACIONES UTILIZANDO ARREGLOS MULTIDIMENSIONALES

El siguiente programa muestra el uso de los arreglos multidimensionales en la resolución de una suma de
matrices.

public class SumaMatrices {

public SumaMatrices() {
}

public void imprimir(String mensaje, int matriz[][])

{
System.out.println(mensaje);
for(int f=0;f<3;++f)
{
for(int c=0;c<4;++c)
{
22
 System.out.print(matriz[f][c]+" ");
}
System.out.println();
}
System.out.println();

}
public void suma(int matriz1[][], int matriz2[][])
{
int res_suma[][]=new int[3][4];
for(int f=0;f<3;++f)
{
for(int c=0;c<4;++c)
{
res_suma[f][c]=matriz1[f][c]+matriz2[f][c];

}
}
System.out.println();
imprimir("El resultado de la suma de ambas matrices es: ",res_suma);

}
public static void main(String[] args) {
int matriz1[][]={

{5,4,3,2},
{2,3,1,4},
{1,3,6,3}
};
int matriz2[][]={
{2,3,1,2},
{1,5,7,1},
{2,6,9,8},
};

SumaMatrices obj=new SumaMatrices();

obj.imprimir("Matriz1: ",matriz1);
obj.imprimir("Matriz2:",matriz2);
obj.suma(matriz1,matriz2);

}
}

El siguiente programa muestra el uso de los arreglos multidimensionales en la resolución de una

multiplicación de matrices.
public class app {

public app() {
}

public void imprimir(String mensaje, int matriz[][])

{
System.out.println(mensaje);

for(int f=0;f<4;++f)
{
for(int c=0;c<4;++c)
{
System.out.print(matriz[f][c]+" ");
23
 }
System.out.println();
}
}

public void multiplicar(int matriz1[][],int matriz2[][], int mul_ma[][]){

for(int f=0;f<4;++f)
{
for(int c=0;c<4;++c)
{
mul_ma[f][c]=0;
for(int d=0; d<4;++d)
{
mul_ma[f][c]+=matriz1[f][d]*matriz2[d][c];
}
}
}
imprimir("Resultado de la multiplicación",mul_ma);
}
public static void main(String[] args) {
int matriz1[][]={
{5,4,3,2},
{2,3,1,4},
{2,3,1,4},
{1,3,6,3}

};
int matriz2[][]={
{2,3,1,2},
{1,5,7,1},
{2,6,9,8},
{1,3,5,2}

};

int mul_ma[][]=new int[4][4];

app obj=new app();
obj.imprimir("Matriz 1",matriz1);
obj.imprimir("Matriz 2",matriz2);
obj.multiplicar(matriz1,matriz2,mul_ma);
}
}

24
6. EJERCICIOS
A continuación se plantean una serie de ejercicios que le ayudarán a comprender mejor el funcionamiento de
las estructuras básicas que emplea el lenguaje de programación JAVA.

1. Construya un programa que calcule el volumen de un prisma rectangular. Cabe mencionar que el
volumen de un prisma de este tipo se calcula mediante la siguiente formula:
Volumen = área de la base* altura del prisma.
Área de la base= base*altura;

2. Escriba una aplicación en java que utilice ciclos para imprimir la siguiente tabla de valores:

N 10*N 100*N| 10000*N

1 10 100 1000
2 20 200 2000
3 30 300 3000
4 40 400 4000
5 50 500 5000

3. Escriba un programa que calcule el salario de un trabajador con base en el número de horas trabajadas
y el salario por hora. Además, deberá indicar si el trabajador es de clasificación A, B o C.

CLASIFICACIÓN SUELDO
A Si su sueldo es mayor
que 100 pesos.
B Si su sueldo está
entre 99 y 70 pesos
C Si su sueldo es menor
que 69 pesos.

4. Escriba una aplicación que calcule el importe total de dos clientes si las compras de ambos fueron las
siguientes:

Cliente 1
4.50 14.56 67.89 56.99 100.00

Cliente 2
5.77 900.80 800.70 56.88 120.50

25
REFERENCIAS

Heller P. & Roberts S. “Complete Java 2 Certification”. SYBEX, Fifth Edition, San Francisco,
USA,2005.

Deitel H. & Deitel P. “Java How to Program”.Prentice Hall, Fourth Edition, New Jersey, USA,
2002.

Wang P. “Java con Programación Orientada a Objetos y Aplicaciones en la WWW”.International
Thomson Editores, First Edition,USA, 2000.

Lowe D. “Java ALL-IN-ONE-DESK Reference for Dummies”. WILEY, First Edition Indianapolis,
Indiana, 2005.

Eckel B. “Piensa en Java”. Prentice Hall, Segunda edición, Madrid, 2002.

26