Manual _introducción A Java

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 byte short int long

Tamaño 1Byte (8 bits) 2 Bytes (16 bits) 4 Bytes (32 bits) 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 float double

Tamaño 4 Byte (32 bits) 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 op1 + op2 op1 - op2 op1 * op2 op1 / op2 op1 % op2

Descripción Suma op1 y op2 Resta op2 de op1 Multiplica op1 por op2 Divide op1 por 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 op1 > op2 op1 >= op2 op1 < op2 op1 <= op2 op1 == op2 op1 != op2

Devuelve verdadero si op1 es mayor que op2 op1 es mayor o igual que op2 op1 es menor que op2 op1 es menor o igual que op2 op1 y op2 son iguales 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 && op1 && op2 & || | !

Devuelve verdadero si... op1 y op2 son ambos verdaderos, condicionalmente evalúa op2 op1 y op2 son ambos verdaderos, siempre evalúa op1 y op2 op1 o op2 son verdaderos, condicionalmente evalúa op2 op1 o op2 son verdaderos, siempre evalúa op1 y op2 op es falso

op1 & op2 op1 || op2 op1 | op2 ! op

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 op1 >> op2 op1 << op2 op1 >>> op2

Operación Desplaza los bits de op1 a la derecha op2 veces Desplaza los bits de op1 a la izquierda op2 veces 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 op1 & op2 op1 | op2 op1 ^ op2 ~op2

Operación AND OR OR Exclusivo 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 op1 += op2 op1 -= op2 op1 *= op2 op1 /= op2 op1 %= op2 op1 &= op2

Equivalente a op1 = op1 + op2 op1 = op1 - op2 op1 = op1 * op2 op1 = op1 / op2 op1 = 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 posfijos Operadores unarios Creación o conversión Multiplicación Suma Desplazamiento Comparación 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

Operadores de este tipo [ ] . (parametros) expr++ expr-++expr --expr +expr -expr ~ ! new (tipo) expr */% +<< < <= = instanceof == != & ^ | && || ?: = += -= *= /= %= &= ^= |= <<= = =

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 primitivos

short 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[] System.out.println (prueba System.out.println (prueba System.out.println (prueba

args) { (10, 5) ) ; (5, 10) ) ; (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ónCondicional) 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; case valor-entero2 : sentencia; case valor-entero3 : sentencia; case valor-entero4 : sentencia; case valor-entero5 : sentencia; // ... default : sentencia;

break; break; break; break; break;

}

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
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
} }

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 1 2 3 4 5

10*N 10 20 30 40 50

100*N| 100 200 300 400 500

10000*N 1000 2000 3000 4000 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