Programacion java basica

Programación Java básica 7 - 1
CAPITULO 7
Programación Java básica
Objetivos
•••• Establecer cómo pasar del modelo de Objetos al lenguaje de
programación.
•••• Identificar los componentes de un programa en Java.
•••• Representar en código Java las principales relaciones de
asociación de clases
•••• Identificar y definir los diferentes tipos de datos primitivos.
•••• Identificar, definir y realizar operaciones con los operadores
disponibles en Java.
•••• Definir y manejar arreglos unidimensionales y
bidimensionales.
•••• Identificar, definir y caracterizar las instrucciones de control de
flujo en Java.
•••• Aplicar las instrucciones selección y de ciclos o repeticiones
en la solución de problemas.
•••• Aplicar las instrucciones de selección múltiple en la solución
de problemas.
•••• Aplicar las instrucciones para manejo de saltos.
•••• Uso de los componentes JOPtionPane, ScrollPane y JTextArea
para la entrada y salida.

Programación Java básica: Programación Java básica 7 - 2
Introducción
En los capítulos anteriores se han presentado ejemplos y ejercicios que
involucran la utilización de variables que almacenan tipos específicos de datos,
así como constantes y operadores para realizar operaciones tanto aritméticas
como relacionales.
Para tal efecto se han diseñado aplicaciones que le dan forma a las clases
asociadas con cada uno de los problemas a resolver. Aunque no se ha dado la
estructura formal de las clases, tanto las aplicaciones como las applets ilustradas
le dan al lector estudioso una idea de la estructura general que tienen estos tipos
de programas en Java.
Java es un lenguaje orientado a objetos, todo en Java se maneja como objetos.
En las interacciones de los objetos se precisa el intercambio de mensajes y la
realización de determinadas tareas, que involucran variables y operaciones a
realizar entre estas. La manera como la información pueda ser almacenada en
un campo o en una variable, está relacionada con el tipo de información que
dicha variable almacena, para diferenciar una variable de otra en cuanto a lo que
puede almacenar se utiliza el término tipo de dato. Java como lenguaje de
programación, maneja varios tipos de datos, que se pueden utilizar al declarar
variables y arreglos o matrices, definir también el tipo de dato (valores) que
puede almacenar dicha variable, arreglo o matriz}.
En este capítulo se tratará en detalle el tema de los tipos de datos, así como sus
rangos(valores que puede tomar un dato un tipo dado) y operaciones para su
manipulación.
Dentro de los tipos de datos estructurados se encuentran los arreglos o vectores
que son conjuntos de elementos de un tipo dado a cada uno de los cuales se
puede acceder mediante un nombre y un indice que indica la posición del
elemento dentro del arreglo. Los arreglos tanto unidimensionales como
bidimensionales se tratarán, junto con algunas aplicaciones para la
manipulación este tipo de datos.
Se plantea una serie de ejercicios que el lector debe realizar a fin de desarrollar
las habilidades necesarias para incursionar con propiedad en el desarrollo de
aplicaciones en Java.
Se utilizará componentes Swing para denotar la entrada/salida. En contraste con
la entrada salida de datos vía linea de comandos,presentada en algunos ejemplos
de los capítulos anteriores.

Programación Java básica: Introducción 7 - 3
En ausencia de instrucciones de control del flujo en un programa, su ejecución
se realiza en una sola dirección, de arriba a abajo, como está escrito el programa
en lenguaje fuente.
En el desarrollo de algoritmos mediante el lenguaje algorítmico, se presentaron
las instrucciones para su control de flujo, fundamentalmente para selecciones,
repeticiones y selecciones múltiples, las cuales hacen que el flujo se desvíe de
su sentido natural de arriba-abajo.
En el lenguaje de programación, a las instrucciones que se encargan de
controlar el flujo de la ejecución de un programa se les denomina instrucciones
de control. Este control se hace de la misma manera o similar, en todos los
lenguajes de programación actuales.
Las instrucciones de control en Java corresponden a las mismas instrucciones
de control definidas en el lenguaje algorítmico: selección, repetición o iteración
y de salto. Las instrucciones de selección permiten que el programa en su
ejecución seleccione distintos caminos en función del resultado de una
expresión lógica o del estado de una variable. Las de repetición o iteración
permiten que el programa repita una serie de instrucciones hasta que se cumpla
una condición dada. Las instrucciones de salto permiten que el flujo del
programa salte incondicionalmente a otro lugar del mismo.
Se presenta ademas en este capítulo las instrucciones de control en Java,
acompañadas de sus definiciones sintácticas, así como de los ejemplos
ilustrativos según sea el caso, a fin de que el estudiante se familiarice con su
utilización y pueda enfrentar la codificación de programas para resolver
problemas en el computador, utilizando el lenguaje Java.
A lo largo del capítulo se presenta un número considerable de ejemplos
resueltos, que acompañados de las explicaciones del caso, le permiten al lector
resolver en Java de una manera práctica, virtualmente cualquiera de los
problemas presentados hasta ahora.
De la representación de objetos a Java
Ya se ha indicado que, las clases representan generalizaciones de objetos con
características y comportamiento similares. Las clases se definen o especifican
con un nombre, atributos y métodos. Los objetos como instancias de una clase
llevan nombre, atributos y métodos.
Así, al modelar el dominio de un problema, se procede a identificar los objetos
y su agrupación en clases, a su vez las clases se organizan jerárquicamente para
identificar su estructura.

Programación Java básica: De la representación de objetos a Java 7 - 4
El desarrollo de la estructura y el comportamiento de una clase a partir de la
cual se crean los diferentes objetos a utilizar en la solución de un problema es el
trabajo de la programación orientada a objetos (POO), la cual implica
obviamente el desarrollo en el lenguaje de programación, de los diferentes
algoritmos que serán incluidos en cada uno de los métodos de las clases y que
serán utilizados por los objetos que se creen a partir de estas clases.
En Java todo son objetos, con lo cual, un programa es un objeto, que se crea a
partir de la clase que lo representa cuando esta se ejecuta en un computador.
Nótese que al ser compilado un programa en lenguaje fuente, se genera un
archivo .class con el nombre de la respectiva clase. El objeto de la clase de
un programa compilado, se crea a partir de la ejecución de esa clase, lo cual
hace que, cada vez que se ejecute el archivo .class se crea en la memoria del
computador una instancia de esta clase, o sea un objeto. Los datos o mensajes
que se suministren a este objeto en tiempo de ejecución, harán que éste arroje
los resultados esperados.
Para responder a la pregunta de cómo pasar de la representación de objetos a su
representación como un programa en Java o sea como un objeto en Java, vamos
a resolver la siguiente situación alrededor de un problema a resolver.
En el mundo de los objetos, “un problema” es un objeto. También puede
suceder que, un objeto, tenga un problema. En cualquier caso, la solución a ese
problema, no es otra cosa que un objeto también. Modelar una solución en
términos de uno o varios objetos y su ejecución mediante un lenguaje de
programación orientado a objetos, es la línea conductora del desarrollo de
sistemas contemporáneo.
Se presentan a continuación unos ejemplos, que persiguen ilustrar de manera
muy general, la conversión del modelo de objetos de aplicaciones sencillas a su
forma codificada en lenguaje Java.
Problema No. 1: Desarrollar un programa en Java que permita calcular el
área y el volumen de un cilindro, dados el radio de la base y la altura. Los
valores a radio y altura se leen por el teclado. El área y el volumen se escriben
en la pantalla.
Suponemos en primer lugar que se han realizado los pasos de la Metodología
para solución de problemas en el computador hasta el algoritmo y su prueba
respectiva. Para efectos de ilustración se presenta el algoritmo respectivo:
inicio
/*variables de entrada, entero: radio, altura;
variables de salida, real area, volumen.*/

escriba(“Digite el valor del radio del la base”);
lea(radio);
escriba(“Digite el valor de la altura”);
lea(altura);
/* pre: se han leido el radio y la altura como enteros
mayores que cero*/
volumen = 3.1416*radio*radio*altura;
area = 2*3.1416*radio*radio + 2*3.1416*radio*altura;
escriba(“El volumen del cilindro es “, volumen);
escriba(“El area del cilindro es “, area);
/* post: se ha calcula y escrito los valores de area y
volúmen*/
fin;
Aunque en un lenguaje procedimental, se puede codificar el algoritmo
directamente, convirtiendo las instrucciones casi que literalmente a las
instrucciones correspondientes del lenguaje de programación, el trabajo bajo
objetos es algo diferente y la codificación del programa pasa por el diseño de la
solución en su representación de objetos.
En otros términos, la solución del problema anterior bajo el enfoque de objetos,
significa que se debe diseñar un objeto que resuelva el problema propuesto.
Como objeto debe tener nombre, atributos (que pueden ser también los objetos
que tiene), así como los métodos correspondientes a su comportamiento.
La clase solución podrá tener como nombre AreaVolCilindro, como
atributos el radio, la altura, el área y el volumen. Se utilizará un sólo método,
dentro del cual se llevarán a cabo los procesos de lectura, cálculos y generación
de resultados. La clase puede tener, por ejemplo, la estructura según la clase
definida en seguida:
El algoritmo desarrollado para el problema, pasa a ser el método de la clase, ya
que los métodos son los que definen el comportamiento de estas. De esta
manera, los métodos contienen lo que lo que los objetos realizan y es el lugar
Figura 1 Clase AreaVolCilindro
AreaVolCilindro
entero radio,altura;
real area, volumen;
metodo1();

donde se codificarán, con algunas modificaciones, los algoritmos que se han
desarrollado para la solución a un problema en particular. Puede afirmarse que,
la denominación de funciones, dada en algoritmos, corresponde a métodos
dentro de un objeto.
Ejecutando la clase AreaVolCilindro, una vez se la haya compilado, se
podrá resolver el problema indicado. Veamos la codificación de la clase
AreaVolCilindro en lenguaje Java:
1.import javax.swing.JOptionPane;
2.public class AreaVolCilindro{
3.static int radio, altura;
4.static float area, volumen;
5. public static void main(String args[]){
6. String dato1, dato2;
7. dato1 = JOptionPane.showInputDialog("Digite valor
radio de la base:");
8. radio = Integer.parseInt(dato1);
9. dato2 = JOptionPane.showInputDialog("Digite valor
altura:");
10. altura = Integer.parseInt(dato2);
11. area = (float)((2*3.1416*radio)*altura +
2*3.1416*radio*radio);
12. volumen = (float)(3.1416*radio*radio)*altura;
13. JOptionPane.showMessageDialog(null, "El area es =
"+ area +"nEl volumen es = "+volumen );
14. }
15. }
Linea 1: indica que se está importando la clase JoptionPane del paquete
javax.swing. Esta clase es del paquete Swing que se utilizará en adelante en
el texto para la lectura y generación de resultados.
Linea 2-15. es el cuerpo de la clase AreaVolCilindro, de acuerdo al diseño
establecido antes.
Lineas 3-4: es la declaración de las variables o atributos de la clase
AreaVolCilindro.
Lineas 5-14: es el cuerpo del método principal de la clase, cuyo nombre es
main(); es el único método de la clase.
Linea 6: es la declaración de dos variables de tipo String(cadena) para
almacenar los caracteres leidos mediante el componente JoptionPane.
Linea 7: aquí se utiliza el método showInputDialog de la clase

JoptionPane, para generar la siguiente salida en la pantalla, en la cual se
ilustra que se están digitando los caracteres 12 (uno y dos) para la base. Se
debe presionar OK una vez se digite el valor indicado.
Linea 8: se convierte la cadena leída a un valor entero, asignado al radio
mediante Integer.parseInt(dato1). A partir de esta linea, en la variable radio
queda almacenado el valor numerico de tipo entero 12.
Lineas 9-10: hacen lo mismo que las anteriores, pero esta vez para la altura:
Lineas 11-12: calcula los valores para area y volumen.
Linea 13: genera los resultados en la pantalla utilizando el método
showMessageDialog, de la clase JoptionPane. Obsérvese cómo se ha
construido la salida de los resultados, combinando tanto títulos como valores de
las variables a escribir.
Figura 2 Lectura de la base
Figura 3 Lectura de la altura

Vemos cómo se ha desarrollado en Java una clase solución al problema
planteado. Cada vez que se ejecute esa clase en un computador, se generará un
objeto solución para un problema en particular.
valor de la siguiente serie para sus N(N>0 y N< 20) primeros términos. El
valor de N se deberá leer por el teclado y verificar que cumple la condición
indicada. El resultado se debe mostrar por la pantalla.
S = 1 - 2! + 3! +4! - 5! + 6! + 7! ...
Se supone nuevamente que se ha desarrollado el algoritmo y su respectiva
prueba de escritorio, correspondiente a los pasos de la Metodología para la
Solución de problemas en el Computador. Ahora la clase con la cual se
resolverá el problema tendrá la siguiente estructura:
El nombre de la clase es SumaFactorial, tiene dos atributos de tipo entero:
suma para el resultado y n para el número de términos de la serie; tiene un
método en este caso el método principal main(), que denota una aplicación o
clase principal. Puede desde luego crearse una clase SumaFactorial que no
tenga un método principal, es decir que no sea una clase principal, sino que para
su uso se requiera de otra clase, esta si principal. El mecanismo de utilización
de los métodos de la clase SumaFactorial, podrá ser mediante la creación de
un objeto del tipo SumaFactorial, o utilizando sus métodos haciendo
SumaFactorial
int suma, n;
void main();
Figura 4 Resultados del área y volumen

referencia al nombre de la clase. La solución presentada aquí es como una clase
principal.
Una forma sencilla de codificar la clase SumaFactorial en el cuerpo de un
programa tipo aplicación es ilustrada a continuación:
/*
i variable indice del ciclo
suma donde se lleva la sumatoria
n el valor del numero de terminos
numMas numero de signos + antes del signo -
contSignos contador de signos + en cualquier momento
facto donde se lleva acumulado el factorial
*/
import javax.swing.JOptionPane; // importa class
JOptionPane
public class SumaFactorial{
static int suma, n;
public static void main(String dato[]){
int numMas, contSignos, facto;
String entrada;
suma = 0;
numMas = 1;
contSignos =0;
do{
entrada= JOptionPane.showInputDialog("Digite un valor
para n:”);
n= Integer.parseInt(entrada);}
while(n<1 || n >19)
facto = 1;
for (i = 1; i<= n; i++){
facto=facto*i;
if(numMas == contSignos){
suma = suma - facto;
numMas = numMas +1;
contSignos = 0;}
else{
suma = suma + facto;
contSignos = contSignos +1;}
}
JOptionPane.showMessageDialog(null, "La serie da: " +
suma, "Resultados", JOptionPane.PLAIN_MESSAGE );
}
}
Para este caso, el método main() contiene el desarrollo en Java del algoritmo
respectivo para el cálculo de la sumatoria solicitada y la entrada y salida de
valores por medio del componente JoptionPane, como en el problema

anterior.
Cuando se ejecuta el archivo .class correspondiente a la clase SumaFactorial,
según el programa Java anterior, se crea un objeto el cual operará según los
datos que se suministren. Los resultados al ejecutar la clase se ilustran a
continuación:
Problema No.3: Desarrollar un programa en Java que permita calcular el
valor de la serie indicada en el problema anterior, pero esta vez utilizando
una clase con la siguiente estructura:
Figura 5 Entrada de n
Figura 6 Resultados de SumaFactorial
SumaFactorial
int n;
int sumatoria();
void main();

Aquí se puede observar que la clase principal SumaFactorial tiene un
atributo n, o sea el valor correspondiente al número de términos a calcular y dos
métodos: uno para el cálculo de la sumatoria llamado sumatoria(), el cual
devuelve o retorna un valor entero y el principal main(), para la lectura,
llamado al método sumatoria() y escritura de resultados. A continuación se
presenta la codificación de la clase SumaFactorial:
1.import javax.swing.JOptionPane;// importa JOptionPane
2. public class SumaFactorial{
3. static int n;
4. static int sumatoria() {
5. int i, facto;
6. int suma = 0;
7. int numMas = 1;
8. int contSignos = 0;
9. facto = 1;
10. for (i = 1; i<= n; i++){
11. facto=facto*i;
12. if(numMas == contSignos){
13. suma = suma - facto;
14. numMas = numMas +1;
15. contSignos = 0;}
16. else {
17. suma = suma + facto;
18. contSignos = contSignos +1;
19. }
20. }
21. return suma;
22. }
23.public static void main(String arg[]){
24. String entrada;
25. int resultado;
26. do{
27. entrada= JOptionPane.showInputDialog( "Digite un valor
para n:" );
28. n= Integer.parseInt(entrada);}
29. while(n<1 || n>19);
30. resultado= sumatoria();
31. JOptionPane.showMessageDialog(null, "La serie da: " +
resultado, "Resultados",JOptionPane.PLAIN_MESSAGE );
32. }
33. }
La ejecución de la clase anterior arrojará los mismos resultados que los
obtenidos anteriormente. Se presenta a continuación algunas explicaciones al
código de la clase anterior:
Lineas 2-33: es el cuerpo de la clase SumaFactorial.

Linea 3: declaración de la variable entera n como atributo de la clase.
Lineas 4-22: cuerpo del método sumatoria, donde se calcula la sumatoria de
los n primeros términos de la serie. Obsérvese que este método no tiene
parámetros ya que el valor de n al ser declarado como atributo de clase
(también puede entenderse como una variable global), puede ser accedido desde
el interior del método. Así mismo este método retorna un valor entero, por eso
el tipo del método es entero.
Línea 21:instrucción mediante la cual el método sumaserie() devuelve el
valor calculado, el cual es el resultado de la sumatoria y es un valor entero.
Líneas 23-32: cuerpo del método principal main().
Linea 30: llamado al método sumaserie() y almacenamiento del valor
devuelto en la variable resultado.
Veamos a continuación una modificación de la versión anterior en donde se ha
desarrollado la clase SumaFactorial1, con su atributo n, de tal manera que
pueda ser usada por cualquier otra clase que se desarrolle, por ejemplo por la
clase PruebaSumaFac, en donde se suministrará un valor para el atributo n y
se llamará a la clase SumaFac mediante la creación de un objeto sumatoria. La
clase PruebaSumaFac usa a la clase SumaFac. Obsérvese que en la clase
SumaFac, se tiene un método sumatoria, que es el encargado de hacer las
operaciones del algoritmo del cálculo de la serie dada
valor de la serie indicada en el problema anterior, pero esta vez utilizando la
siguiente estructura de clases:
En este diagrama se está indicando que la clase SumaFactorial ahora no será
una clase principal, pues no contiene el método main(), sin embargo contiene
SumaFactorial
int n;
int sumatoria();
PruebaSumaFac
void main();

un método para la sumatoria y un atributo como en el problema anterior. Por
tanto la utilización de la clase SumaFactorial se deberá hacer mediante su
llamado dentro del cuerpo de otra clase, en este caso PruebaSumaFac que es
una clase principal pues contiene el método main(). Dicho en terminología de
objetos, “la clase PruebaSumaFac usa la clase SumaFactorial”, o sea que entre
estas dos clase hay una relación de uso, en el sentido explicado antes.
En esta situación dentro del cuerpo de la clase PruebaSumaFac se deberá crear
una instancia u objeto del tipo SumaFactorial, con el cual se podrá invocar el
método sumatoria(), para el cálculo de la serie según el número de términos
indicado.
A continuación el código fuente en Java tanto de la clase SumaFactoial como
de la clase PruebaSumaFac que usa a la primera. Se debe compilar cada una
por separado y dejándo los archivos PruebaSumafac.class y
SumaFactorial.class en el mismo directorio.
1.public class SumaFactorial{
2. static int n;
3. int sumatoria() {
4. int i, facto;
5. int suma = 0;
6. int numMas = 1;
7. int contSignos = 0;
8. facto = 1;
9. for (i = 1; i<= n; i++){
10. facto=facto*i;
11. if(numMas == contSignos){
12. suma = suma - facto;
13. numMas = numMas +1;
14. contSignos = 0;}
15. else {
16. suma = suma + facto;
17. contSignos = contSignos +1;
18. }
19. }
20. return suma;
21. }
22.}
Lineas 1-22: cuerpo de la clase SumaFactorial. El cálculo del valor de la
sumatoria se hace ahora mediante una clase sencilla, o no principal, que tiene
un atributo de clase n y un método sumatoria(). Obsérvese que ya no existe
dentro de esta clase el método main().

1.import javax.swing.JOptionPane; // importa class
JOptionPane
2.class PruebaSumaFac{
3. public static void main(String arg[]){
4. String entrada;
5. int numero, resultado;
6. SumaFactorial sumaSerie = new SumaFactorial();
7. do{
8. entrada= JOptionPane.showInputDialog( "Digite un
valor para n:" );
9. numero= Integer.parseInt(entrada);}
10. while(numero<1 || numero>19);
11. sumaSerie.n = numero;
12. resultado= sumaSerie.sumatoria();
13. JOptionPane.showMessageDialog(null, "La serie da: "
+ resultado, "Resultados", JOptionPane.PLAIN_MESSAGE );
14. }
15. }
Lineas 1-15: cuerpo de la clase principal PruebaSumaFac que usa el método
sumatoria() de la clase SumaFactorial, mediante la creación de una
instancia u objeto de esta, llamado sumaSerie.
Linea 6: se crea un objeto llamado sumaSerie del tipo SumaFactorial,
invocando un método constructor SumaFactorial() mediante la cláusula
new. En otros términos, crea una nueva instancia de SumaFactorial con el
nombre sumaSerie.
Linea 11: le asigna a la variable o atributo n, del objeto sumaSerie, el valor
leído y almacenado en numero.
Linea 12: invoca el método sumatoria() del objeto sumaSerie, para
calcular el valor de la serie. El resultado es almacenado en la variable
resultado.
Los resultados obtenidos al ejecutar la clase PruebaSumaFac son los mismos
que los obtenidos en las versiones anteriores. Debe anotarse que, la clase
SumaFactorial en su última versión, podrá ser utilizada por cualquier otra
clase para el cálculo de la serie indicada.
Con estos ejemplos se ilustra de manera general el proceso de pasar de la
representación de objetos al lenguaje de programación Java.

Componentes de un programa Java
En los ejemplos presentados se ha visto que la estructura de un programa Java
se forma a partir de una o más clases. Cada una de estas clases tienen sus
atributos y los métodos propios. En cada programa Java hay una clase principal,
a partir de la cual se ejecuta éste.
Un programa se puede conformar de más de una clase, en cuyo caso las demás
clases diferentes a la clase principal se deben compilar por separado y
almacenarse en el mismo directorio donde se ha compilado la clase principal.
Cada clase está formada por atributos, los cuales pueden ser variables de algún
tipo u objetos, así como de métodos, los cuales están formados por
instrucciones tanto aritméticas, lógicas y relacionales, de instrucciones de
control de flujo como son los ciclos y las repeticiones. Dentro del cuerpo de los
métodos se encuentran además las variables, que pueden ser de tipo entero,
lógico, carácter, booleano, la invocación de métodos y objetos y el manejo de
funciones.
Las relaciones entre clases
Cada una de las relaciones entre objetos señaladas en la Unidad anterior,
herencia, uso y composición, se pueden representar dentro del código de un
programa Java.
Codificación de la relación es-un
La relación es-un dada entre clases, es la relación de especialización de una en
otra, es decir, aquella que implementa las relaciones de herencia. La forma más
común de representar esta relación es mediante subclases de una clase. Por
ejemplo, si se tiene una clase AnimalMamifero, una subclase de ésta es
Carnivoros. Dado que un Carnivoro es un AnimalMamifero, su codificación
quedaría de la siguiente manera:
public class Carnívoro extends AnimalMamifero{
.....
}
Cualquier característica de tipo public, tanto atributos como métodos de la clase
AnimalMamifero, es también una característica de Carnívoro, es decir la clase
Carnívoro, hereda todas las carcterísticas públicas de AnimalMamifero. Solo
bastaría agregarle a Carnívoro las características propias, atributos y métodos
que lo caracterizan, en este caso que lo especializan como animal carnívoro.

Codificación de la relación tiene-un
Esta relación se da por en la composición de un objeto a partir de otros, por
ejemplo, la mayoría de objetos en su habitación están formados por otros
objetos. La LamparaDeMesaDeNoche, se compone del objeto bombillo, del
objeto portaLampara y otros. El perrito Lucas de su vecina, tiene un collar de
dientes de Tiburón, etc
Sea por ejemplo la clase LamparaDeMesa, la cual tiene un bombillo, un
suiche y un porta lámpara, su codificación quedaría de la siguiente manera:
public class LamparaDeMesa {
private Bombillo bombilloLampara;
private Suiche interruptorLampara;
.....
}
Indica que la clase LamparaDeMesa tiene un objeto bombilloLampara del
tipo Bombillo y un objeto interruptorLampara de tipo Suiche.
Obviamente puede contener más objetos.
Codificación de la relación utiliza-una
En el desarrollo de una clase puede verse la necesidad de utilizar instancias
provistas por otras clases, por ejemplo la clase Persona, requerirá de una
instancia RelojDespertador, a fin de fijar la hora para su alarma. En este
caso la siguiente codificación ilustra la relación Persona usa-un
RelojDespertador:
public class Persona{
RelojDespertador miRelojDespertador = new
RelojDespertador();
miRelojDespertador.fijarHoraAlarma(laHora);
....
}
En el código anterior se crea un objeto miRelojDespertador a partir de la
clase relojDespertador, luego se usa el método fijarHoraAlarma
(laHora), que está contenido dentro de la clase RelojDespertador, para
fijar la hora de la alarma en laHora, valor suministrado como argumento de
este método.
Identificadores en Java
Por identificadores se entiende los nombres dados a variables, métodos, clases,
paquetes e interfaces (que se definirán más adelante). Los identificadores no son

cosas u objetos, justamente son la forma de llamar esas cosas u objetos. A lo
largo del texto, a través de los diferentes ejercicios y ejemplos se ha manejado
identificadores como System.out.println, String, args, variable1, grabadora,
Ejemplo01 y otros.
Los identificadores, se pueden formar de letras, números, el símbolo _
(subrayado) y el símbolo $. Los identificadores se deben iniciar con una letra,
con el símbolo _ (subrayado) ó con el signo $. Cada variable u objeto toma un
nombre o identificador con el cual se identifican en el programa, aplicación o
applet. Una buena práctica es asignar nombres significativos y mnemotécnicos
para los identificadores, lo más cercanos a los significados que ellas tienen o
representan en el dominio del problema.
Un nombre de variable no puede contener espacios, tampoco se puede iniciar
con un número. Los siguientes son nombre válidos de identificadores:
variable
miVariable
MIVARIABLE
x
i
_mivariable
$mivariable
_9pins
andronauta
OClaroEsta
Los siguientes son nombres inválidos de identificadores:
Mi Variable // Contiene espacio en blanco
9pines // Inicia con un dígito
a+c // El signo + no es un carácter alfanumérico
chequeo1-2-3 // El signo menos no es un carácter
alfanumérico
O'Reilly // El apóstrofe no es un carácter alfanumérico
OReilly_&_Associates // El símbolo ampersand no es
alfanumérico
Si se desea que un identificador se inicie con un número, anteponga el símbolo
_ (subrayado) al nombre o identificador, por ejemplo, si se desea usar como
identificador 8Ciclos, el nombre válido sería _8Ciclos.
Como norma de codificación en Java, se recomienda que cada palabra de las
que conforman el nombre de un identificador se inicie con una letra mayúscula
y las demás letras con minúsculas. Para el caso de variables, métodos y objetos,
la primera palabra se iniciará con minúscula, en el caso de las clases, el

identificador se inicia con mayúscula , notación que se ha propuesto y utilizado
en los capítulos anteriores. Los siguientes ejemplos ilustran este sistema de
codificación de identificadores:
pesoEspecifico // para una variable
volumenTotalLago// para el nombre de un método
FiguraGeometrica // para denotar la clase FiguraGeometrica
cuadradoRojo // puede denotar un objeto
El espacio en blanco
El espacio en blanco corresponde al carácter que se produce cuando se presiona
la barra de espaciamiento en el teclado del computador y que se utiliza para
separar palabras. Existen en Java otros cuatro espacios en blanco: la tabulación
horizontal (horizontal tab), la alimentación de formas (form feed), el retorno de
carro o enter (carriage return) y la alimentación de una línea (line feed). Cuando
se presiona la tecla de enter o de retorno, se produce la inserción de una línea o
un retorno de carro, lo cual se refleja en el código fuente como una nueva línea.
Aparte del uso de espacios en blanco en las literales de caracteres (String), Java
sin importar cuantos espacios se utilicen los toma como uno. Se usa también
para separar operandos, símbolos, palabras. El número de espacios que utilice
es solamente para una mejor presentación visual a quien lee el programa en
lenguaje fuente.
Dentro del cuerpo de una literal tipo carácter de los caracteres mencionados que
Java toma como un solo espacio en blanco, sólo se permite escribir
directamente el carácter espacio en blanco. Retornos de carro, tabulaciones,
lineas y formas de alimentación, pueden ser insertadas utilizando las secuencias
de escape:
Secuencia de escape Descripción
ddd Carácter octal (ddd)
uxxxx Carácter UNICODE hexadecimal (xxxx)
' Comilla simple
” Comilla doble
Barra invertida
r Retorno de carro
n Nueva línea (salto a nueva línea)
f Alimentación de página (salto a nueva
página)

Secuencia de escape Descripción
t Tabulación
b Retroceso
No se puede cortar una cadena (String) de carácteres a través de una línea,
como por ejemplo en el siguiente caso:
String verso = “No llores por amor,
alza la cara
que no digan tus ojos
que se te ha acabado
la paz en el alma.”;
En lugar de esa construcción se debe utilizar la secuencia de escape n y el
operador de concatenación de carácteres +, de la siguiente manera:
String verso = “No llores por amorn” +
“alza la caran” +
“que no digan tus ojosn” +
“que se te ha acabadon” +
“la paz en el alma.”;
Obsérvese que, una instrucción sí se puede cortar a través de múltiples líneas,
sin embargo una literal de carácteres (String) no es permitido.
Tipos de datos
Los tipos de datos hacen referencia tanto al tipo de contenido, como a la forma
como es almacenado en la memoria del computador. Accesar al contenido de un
tipo de datos en particular se hace mediante nombres o identificadores.
Los tipos de datos disponibles en Java, también denominados primitivos, son
muy similares a los tratados en el Capítulo 2, sobre Lenguaje Algorítmico y
obviamente similares a la mayoría de los lenguajes de programación, como en
el caso los lenguajes C y C++. Estos tipos de datos son: los lógicos (booleanos),
de formato corto (short), enteros(int), de formato largo (long), de punto flotante
(float), de formato extendido (double) y para manejo de caracteres (char), cabe
anotar que en su implementación se encuentran algunas diferencias según el
lenguaje de programación.
Veamos algunos aspectos generales sobre los tipos de datos, comparando C++ y
Java:

Programación Java básica: Tipos de datos 7 - 20
• En C y C++ la manipulación de tipos de datos es dependiente del compilador
y la máquina, por ejemplo en el tamaño de los enteros. En Java se especifica
cada tipo de dato de manera independiente.
• Java previene acerca de la conversión arbitraria entre variables con tipos de
datos no similares. Únicamente se permite la conversión entre variables de
tipo numérico, así como la conversión entre superclases y subclases del
mismo objeto.
• Todas las variables numéricas en Java tienen signo.
En Java cada variable, cada expresión, tienen un tipo de dato. Así mismo cada
tipo está definido estrictamente. El compilador Java comprueba todas las
asignaciones, bien explícitas o mediante paso de parámetros en llamadas de
métodos, todas las conversiones, expresiones y parámetros, para asegurar la
compatibilidad de los tipos de datos.
Dependiendo de la tarea a realizar, se requerirá definir clases, entendidas como
plantillas en Java, con las cuales se pueden crear instancias de objetos de la
aplicación del mundo real. Como se vio antes, tanto aplicaciones como applets
se diseñan sobre la base de la estructura o jerarquía de clases, cuyos datos
miembros pueden ser a su vez clases, o tener la forma de instancias de clases
que vienen incorporadas en el lenguaje Java.
Sea el caso de una clase denominada CamionDeCarga que puede contener,
entre otros, los siguientes tipos de datos miembros o atributos:
Atributos de la Clase
CamionDeCarga
Valores de atributos para el
objeto miCamion
marca Ford 7000
fabricante Ford Motor Co.
color Rojo ladrillo
numeroMotor SF987005643
capacidadMotor 7,000 cc
placaNumero NOC 890
numeroEjes 2
dueño Federico García
combustible Diesel
En esa lista se observa que fabricante, puede ser a su vez una clase y
contendría entonces la información sobre su dirección, nombre, teléfono,

página web, métodos para vender, financiar, hacer mantenimiento y otros. Los
demás atributos hacen referencia a tipos simples que pueden contener
información numérica o alfanumérica.
Los atributos capacidadMotor y numeroEjes al hacer referencia a un valor
numérico, deberán tener la forma de almacenamiento numérico sin decimal. La
identificación mediante la placaNumero hace referencia a una cantidad de tipo
alfa-numérico, entendida como una cadena de caracteres.
En el caso del objeto miCamion se encuentran tipos de datos que hacen
referencia a cantidades numéricas y de cadenas de caracteres, consideradas del
tipo de dato simple, o tipo de datos primitivos.
Veamos ahora el caso de un objeto miRelojDespertador, el cual es una
instancia de la clase RelojDespertador, con entre otros, los siguientes
atributos, y sus valores:
Atributos de la Clase
RelojDespertador
Valores de atributos para el
objeto miRelojDespertador
marca Pony
color Azul Cielo
serie Ax-12345
tipoMaterial Metal-Plástico
precio $5,000.00
tipoFunciones Alarma
nombreDueño Usted
horaActual 8:00 p.m.
horaAlarmaActual 5:00 a.m.
operacion De cuerda
Se puede identificar que entre sus atributos hay uno con información numérica
con decimales como es el caso del precio y de contenido alfabético como es el
color y alfanumérico como la serie. Todos ellos son tipos de datos
primitivos, como se explica a continuación.
Tipos de Datos primitivos
Java trae definidos los siguientes tipos de datos primitivos :

• Para manejo de cantidades enteras, o sea aquellas que no tienen decimales:
byte, short, int, long.
• Para manejo de cantidades de punto flotante, o con decimales: float, double.
• Manejo de los símbolos de un conjunto de caracteres como por ejemplo
letras, números y caracteres especiales: char.
• Para cantidades con valores lógicos, falso o verdadero: boolean.
Enteros
Los enteros representan las cantidades que no tienen parte decimal o
fraccionara. Gran parte del trabajo computacional se fundamenta en la
manipulación de cantidades enteras con signo, es decir que pueden tomar
valores positivos o negativos.
El tamaño, es una cantidad expresada en número de bits (dígitos binarios)
asignados en la memoria del computador para almacenar un valor. Representa
el comportamiento para las variables y expresiones del respectivo tipo,
haciendo referencia al rango de valores que se pueden almacenar en las
variables de ese tipo.
Hay cuatro tipos de datos enteros, dependiendo de las necesidades de rangos de
almacenamiento por parte las variables a utilizar. La siguiente lista indica los
tamaños en bits y rangos para los tipos de datos enteros:
Tipo de dato Tamaño en bits Rango de valores permitido
long 64 -9.223.372.036.954.775.808 a
9.223.372.036.854.775.807
int 32 -2.147.483.648 a 2.147.483.647
short 16 -32.768 a 32.767
byte 8 -128 a 127
La memoria del computador se mide en bytes u octetos de bits. Un dígito
binario o bit, puede almacenar un uno o un cero. Es decir que la máxima
cantidad entera almacenada en un bit es el entero 1. Si hay dos bits, el máximo
valor es 11 binario que corresponde al decimal 3, si hay 7 bits el máximo valor
es 1111111 binario que corresponde al decimal 127. Como en Java una

cantidad numérica tiene signo, para el caso de los enteros uno de los bits se deja
para el signo. De esta manera, la capacidad de almacenamiento de valores
enteros en 8 bits (de los cuales toma uno para el signo, el de la izquierda por
ejemplo) será uno para el signo y en los siete restantes 1111111 binario que
corresponde al decimal 127. Igual calculo se puede hacer para el
almacenamiento en tamaño de 16, 32 o 64 bits.
Declaración de variables enteras
Para decidir si se debe crear una variable entera es necesario conocer el tamaño
máximo y mínimo que se espera deba contener el dato representado por dicha
variable y asignarle un nombre con el cual se haga referencia.
Si se desea un contador que tome valores entre 1 y 100, de acuerdo a la tabla
anterior el tipo recomendado es el byte ya que su rango comprende los valores
del contador a utilizar. Con la siguiente instrucción se declara una variable
contador con el tipo byte.
byte contador;
Los índices de arreglos, como por ejemplo el arreglo arg[] usado como
argumento en el método main(String arg[]) puede ser de tipo int , ya que
su rango difícilmente superaría los 128 elementos. Pero si se requiere un arreglo
con mayor numero de indices, se utilizaría el tipo short.
Para el caso de tres variables cuyos valores están dentro del rango del tipo int
su declaración se puede hacer con
short numeroVehiculos, numeroEstudiantes, cantidadPedida;
Si se desea usar variables enteras de tamaño de 64 bits, o sea de tipo long la
siguiente declaración lo establece para las variables indicadas:
long variableLarga, otraLarga, unaGrandota;
Valores reales
Los valores reales o de punto flotante se utilizan para cálculos que requieran
mayor precisión, la cual se define como la cantidad de dígitos significativos que
maneja el computador exactamente para un tipo de datos dado. Por ejemplo, la
raíz cuadrada y las funciones trigonométricas como el seno y el coseno. Estos
tipos de datos almacenan los bits mas significativos, o sea la mantisa, aparte
del exponente. Todas las funciones matemáticas trascendentes como sin(),
cos(), sqrt() devuelven valores de doble precisión.

Como en el caso de los valores enteros, en los de coma flotante se presentan en
dos tamaños: float y double, que representan números de precisión simple y
de precisión doble.
• float almacena sus valores en 32 bits y se denomina precisión sencilla, su
rango de valores es establecido de acuerdo a :
mínimo valor negativo -3.40282347 10+38
máximo valor negativo -1.40239846 10-45
mínimo valor positivo 1.40239846 10-45
máximo valor positivo 3.40282347 10+38
Los valores en precisión float o simple, requieren la mitad del espacio que
la precisión doble, siendo más rápida, sin embargo es imprecisa cuando los
valores son muy grandes o muy pequeños. Las variables float son útiles
cuando no se requiere mucha precisión.
• double almacena sus valores en 64 bits y se denomina de precisión doble, su
rango de valores es establecido de acuerdo a:
mínimo valor negativo -1.7976931348623147 10+308
máximo valor negativo -4.94065645841246544 10-324
mínimo valor positivo 4.94065645841246544 10-324
máximo valor positivo 1.7976931348623147 10+308
Los valores en precisión double son muy útiles cuando se hacen cálculos con
números de gran valor o tras de muchos cálculos iterativos o repetitivos, por
ejemplo para el cálculo de convergencia de funciones. Las funciones
matemáticas trascendentes, como sin(), cos() y sqrt() por ejemplo,
devuelven valores del tipo double.
En ambos casos, float y double, una parte del tamaño en bits se toma para el
signo de la mantisa, otro para la mantisa, otro para el signo del exponente y otra
parte para el exponente. Dando así los rangos de valores indicados. Nótese que
aunque el rango cubierto es muy grande, la precisión se limita al número de
dígitos significativos de cada tipo.
Declaración de variables reales
Ejemplo 1: En el siguiente programa se calcula el área de un círculo mediante
la clase AreaCirculo.

// calculo del area de un circulo
import javax.swing.JOptionPane; // importa class JOptionPane
class AreaCirculo {
public static void main(String args[]) {
double pi, radio, area;
radio = 10.8;
pi = 3.1416;
area = pi*radio*radio;
JOptionPane.showMessageDialog(null, "El area del circulo
con radio "+radio+" es "+area, "Resultados",
JOptionPane.PLAIN_MESSAGE );
}
}
Cuyo resultado se presenta enseguida:
Valores char
El tipo de datos para almacenar caracteres es el char. Java utiliza el código
Unicode para representar caracteres. Este sistema define un conjunto de
caracteres completamente internacional, que puede representar todos los
caracteres encontrados en todos los idiomas y lenguas. Es la unificación de
docenas de conjuntos de caracteres como latino, griego, arábigo y muchos mas.
Para lograr esto el tipo de dato char utiliza 16 bits, por tanto el rango de
caracteres es de 0 a 65.536 (1111111111111111 en binario). Tiene sentido la
utilización del sistema unicode ya que Java esta diseñado apara permitir que los
applets se puedan utilizar en todo el mundo. Información sobre unicode está
disponible en
http://www.unicode.org y en http://www.stonehand.com/unicode.html
Declaración de variables char
Los siguientes son algunos ejemplos de declaración de variables tipo char,
char ca1;
Figura 7 Salida de la clase AreaCirculo

char ca2 = “carácter 2”; [] {????????}
char ca3 = ´n´;
Ejemplo 2: En el siguiente programa se usan variables tipo char:
// uso de variables char
import javax.swing.JOptionPane; // importa class JOptionPane
class AgregaCaracteres{
char parte1, parte2;
parte1 = 88; // código que representa x
parte2 = 'Y';
JOptionPane.showMessageDialog(null, "parte1 y parte2:
"+parte1+" "+parte2,"Resultados",JOptionPane.PLAIN_MESSAGE);
}
}
Se obtiene el siguiente resultado:
Valores Booleanos
Por definición, los valores booleanos tienen un bit de almacenamiento, solo
pueden tomar uno de dos valores, true (verdadero) o false (falso). Este es el
tipo que devuelven los operadores de comparación relacionales, como en la
expresión area1 < area2 , o el requerido en las expresiones condicionales que
controlan el flujo como if , for , do, while. Una variable de este tipo, al ser
creada toma como valor predeterminado false.
Declaración de variables booleanas
Ejemplo 3: En el siguiente programa se utilizan variables booleanas,
// Utilización de variables booleanas
class ChequeaBooleana{
Figura 8 Resultados clase AgregaCaracteres

public static void main(String args[]){
boolean vara, varb;
varb = false;
vara = true;
System.out.println(“ varb tiene el valor “ + varb);
varb = true;
System.out.println(“ varb tiene el valor “ + varb);
// expresion booleana para controlar una selección
if (vara){
System.out.println(“ Se ejecuta esta instrucción”);
}
}
}
Al ejecutarse el programa generara el siguiente resultado por la línea de
comandos:
varb tiene el valor false
varb tiene el valor true
Se ejecuta esta instrucción
Literales en Java
Literales son código fuente de Java que significan justamente lo que ellas dicen
en su asignación literalmente. Una literal es una constante, por ejemplo, “Soy
una Applet”, es una literal tipo String y significa que tiene almacenado el
mensaje o cadena Soy una Applet. Para el compilador aunque tiene mas de un
carácter, representa una sola cosa: una literal tipo String. Así mismo 9.86
aunque tiene mas de un dígito o carácter, es considerado como una literal
numérica. Cada tipo de datos permite la manipulación del mismo tipo de
literales según el tipo.
Literales de tipo entero
Los enteros son el tipo más utilizado en el trabajo en el computador, cualquier
valor numérico entero es un literal entero. Por ejemplo los valores, 1, 2, 45, 67,
98, son valores literales enteros los cuales son valores decimales por cuanto
están en base 10, aunque hay otras bases como la octal en base 8 y la
hexadecimal en base 16, con las cuales también se pueden definir literales
numéricas enteras.
Los valores octales en Java van precedidos por un 0 (cero), por lo cual el valor
06 representa una literal entera en base octal. El rango de los dígitos octales van
del 0 al 7.
La base hexadecimal es una base común para los números utilizados por los

programadores que coincide con el tamaño de palabra en módulo 8, como el
almacenamiento en 8, 16, 32 o 64 bits visto antes. Una literal hexadecimal se
representa con el prefijo 0X, seguido de los dígitos hexadecimales cuyo rango
es de 0 al 15, por lo que hay que utilizar las letras de la A a la F para representar
a los números decimales 10 al 15.
Los literales enteros crean por defecto un valor tipo int, que en Java tiene un
tamaño de 32 bits. Cuando se asigna un valor literal a una variable entera
byte o short, no se genera error alguno si el literal esta dentro del rango del
tipo destino. Para las literales o constantes enteras a especificar como long es
necesario decirle de forma explícita al compilador que el valor literal es de tipo
long, mediante la adición de la letra L (mayúscula o minúscula) al final de la
literal. Los siguientes son algunos ejemplos de asignación de constantes enteras
a variables:
Constante1 = 9456748378L; // entero decimal en 64 bits
Constante2 = 0X6785ABL; // hexadecimal entero en 64 bits
Constante3 = 30567; // entero decimal en 32 bits
Constante4 = 067543; // entero octal en 32 bits
Constante5 = 0786545678L; // entero octal en 64 bits
Literales en coma flotante o de números reales
Los valores literales de coma o punto flotante representan cantidades
decimales con una componente fraccionaria, en notación estándar o sea la cifra
entera seguida de un punto decimal y un conjunto de dígitos expresando la parte
fraccionaria, o en notación científica al expresar el número en notación
estándar con un sólo dígito entero y adicionalmente con una componente que
expresa la potencia que debe elevarse el valor 10 como factor multiplicador del
número. El exponente se indica con E, o e, seguido de un número decimal con
signo. Por ejemplo 2.345 en notación estándar y 2345 E-3 en notación
científica.
Las literales de coma flotante son almacenadas por defecto en doble precisión
(double) o sea en 64 bits. Si se desea especificar una literal tipo float en 32
bits, se le debe añadir a la constante una F, o f al final. Los siguientes son
algunos ejemplos de literales de coma flotante:
Constante1 = 7.98768 E 23;
Constante2 = 3.3657 E-21;
Constante3 = 4.6543F;
Constante4 = 56878.4328;

Literales Booleanos
Un valor booleano se expresa solamente con uno de los dos valores lógicos,
true (verdadero) y false (falso). Los valores true y false, no son
equivalentes a representación o expresión numérica alguna, es decir no
equivalen a 1 y 0 respectivamente como en C o C++ . Las siguientes son
asignaciones literales booleanos a dos variables, obviamente del tipo de datos
booleano.
Respuesta1 = true;
Respuesta2 = false;
Literales Char
Estas literales se almacenan en 16 bits sin signo, y corresponden a índices del
conjunto de caracteres Unicode. Estos literales se pueden convertir a enteros y
ser manipulados con los operadores de los enteros. Un carácter literal tipo
char se representa dentro de un par de comillas simples ( ´ ´ ). Los
caracteres visibles en ASCII se introducen directamente entre el par de
comillas. Aquellos que no se los puede representar directamente se utilizan
secuencias de escape, como por ejemplo ´n´ , para el carácter cuyo función es
crear una nueva línea, o ´r´ para el retorno de carro. Las siguientes son algunas
secuencias de escape:
ddd carácter octal
uxxxx caracter UNICODE hexadecimal (xxxx)
´ comilla simple
´´ comilla doble
barra invertida
rretorno de carro
nnueva linea
falimentar página
ttabulador
bretroceso
Literales String o de cadena de caracteres
Este tipo de literales son similares a las usadas en todos los lenguajes de
programación, cualquier cosa colocada “entre un par de comillas dobles”.
Una literal String es una coleción de carácteres (letras, dígitos, signos de
puntuación, etc.) que se escribe en una sola linea, ya que Java no tiene carácter
de escape para indicar continuación de línea.
Cadena1= “Soy toda una cadena “;
CadenaOtra = “ Soy otra cadena y que?”;

Programación Java básica: Operadores en Java 7 - 30
Operadores en Java
Un operador es un símbolo que representa una operación que toma uno o mas
argumentos u operandos y opera sobre ellos a fin de generar un resultado.
Típicamente los operadores en un programa están entre identificadores y
literales de tipo numérico. Algunos están antes del operando y se denominan
prefijos, otros después y se denominan posfijos, algunos toman un solo
operando y se denominan operadores unitarios unarios, los que requieren dos
operandos se denominan binarios.
Java brinda un conjunto de 44 operadores, los cuales son como instrucciones
que le indican al compilador acerca de la realización de operaciones lógicas o
matemáticas. Se agrupan en cuatro grupos: aritméticos, relacionales, lógicos y
a nivel de bit.
Operadores aritméticos
Los operadores aritméticos se utilizan para realizar operaciones matemáticas,
exactamente como están definidas en el Álgebra. La siguiente tabla ilustra la
lista de los operadores aritméticos:
Operador Resultado Operador Resultado
+ adición += asignación aditiva
- Substracción y
signo unitario
-= asignación de
substracción
* producto *= asignación de producto
/ división /= asignación de división
% módulo %= asignación de módulo
++ incremento -- decremento
Las cuatro operaciones
Las operaciones aritméticas de suma, resta, multiplicación y división se llevan a
cabo en la forma convencional. El operador unitario - (menos), se utiliza para
negar el signo del operando al cual precede.
Ejemplo 4: El siguiente ejemplo ilustra las cuatro operaciones entre literales y
variables:
import javax.swing.JOptionPane;
class CuatroOperaciones{

int var1, var2, var3, var4, var5, var6;
var1= 10;
var2= 20;
var3= var1+var2;
var4= var3-20;
var5=var4*var1;
var6=var2/var1;
JOptionPane.showMessageDialog(null,"valor de var1=
"+var1+
"nvalor de var2= " + var2+
"nvalor de var6= " + var6);
}
}
Cuando el programa se ejecuta producirá los siguientes resultados:
Operador módulo
Este operador permite calcular el residuo de una división tanto para tipos
enteros o de coma flotante.
Ejemplo 5: El siguiente ejemplo ilustra la utilización del operador para
encontrar el resíduo de 53 modulo 10 y de 52.150 modulo 10.
Figura 9 Resultados de la clase
CuatroOperaciones

class CalculoModulo{
int z = 53;
double w = 52.150;
JOptionPane.showMessageDialog(null,z+" modulo 10 = "+z %
10+
"n"+ w + " modulo 10 = " + w % 10);
}
}
Cuando se ejecute el programa deberá generar los siguientes resultados:
Operadores aritméticos de asignación
Cada uno de los cuatro operadores aritméticos tiene una forma asociada la cual
permite realizar la operación y la asignación. Por ejemplo, para incrementar el
valor de la variables valor en cuatro unidades.
valor = valor + 4;
Operación valida en Java, sin embargo la forma siguiente arroja el mismo
resultado mediante el operador de asignación respectivo de la suma:
valor += 4;
El significado de cada uno de los operadores de asignación se da a
continuación:
Figura 10 Resultados clase CalculoModulo

Operador Descripción
= Es el operador de asignación sencilla; coloca el valor de la
expresión del lado derecho en la variable de la parte izquierda del
signo igual.
+= Adiciona el valor de la derecha a la variable de la izquierda y
almacena el resultado en esta variable.
–= Sustrae el valor de la derecha a la variable del lado izquierdo y
*= Multiplica la variable del lado izquierdo por el valor de la parte
derecha y almacena el resultado en esta variable.
/= Divide la variable de la izquierda por el valor de la derecha y
%= Obtiene el residuo de la división de la variable del lado izquierdo por
el valor del lado derecho y almacena el resultado en la misma
variable.
Se presenta a continuación algunos ejemplos para estos operadores de
asignación aritmética:
// incrementa valorTotal en 4 y guarda el resultado en //
valorTotal
valorTotal += 4;
// le resta a valorTotal la cantidad 10 y guarda el
resultado en //valorTotal
valorTotal -= 10;
//multiplica productoFinal por 10 y guarda el resultado en
//productoFinal
productoFinal *= 10;
// divide partirProducto por 2 y guarda el resultado en
// partirProducto
partirProducto /= 2;
// obtiene el residuo de dividir residuoFinal por 10 y
guarda el // resultado en residuoFinal
residuoFinal %= 10;
Operadores de incremento y decremento
Permiten adicionar o substraer de una manera simplificada la unidad a una
variable dada. La forma tradicional de realizar el incremento de una unidad es la
siguiente:
variable1 = variable1 + 1;// incrementa en la unidad a

variable1
variable2 = variable2 - 1; //decrementa en la unidad a
variable2
Mediante los operadores aritméticos de asignación de incremento/decremento
(+= y -=) se pueden escribir de la siguiente manera:
variable1 += 1;// incrementa en la unidad a variable1
variable2 -= 1;//decrementa en la unidad a variable2
Java conserva la notación introducida por el C++, mediante los operadores ++ y
-- , para generar las siguientes instrucciones equivalentes a las indicadas arriba:
++variable1;// incrementa en la unidad a variable1
--variable2;//decrementa en la unidad a variable2
Los operadores ++ y -- pueden anteceder al operando, como en el ejemplo, o
preceder al operando como en el siguiente caso:
variable1++;// incrementa en la unidad a variable1
variable2--;//decrementa en la unidad a variable2
Cuando el operador antecede al operando, el operando es modificado antes de
que el valor sea obtenido para su asignación a la variable del lado izquierdo, o
en la expresión correspondiente. Cuando el operando antecede al operador, se
obtiene primero el valor del operando sin modificación para la variable del lado
izquierdo, y luego si se incrementa el operando. Esa diferencia se ilustra en el
siguiente ejemplo
variable1= 65;
variable2 =++variable1;
aquí variable1 toma el valor 66 y en variable2 el de 66. En el siguiente
ejemplo el operando antecede al operador y la variable2 toma el valor 65 y la
variable1 se incrementa a 66.
variable1= 65;
variable2 =variable1++;
Ejemplo 6: El siguiente ejemplo ilustra la utilización del operador de
incremento ++ para incrementar la variable controladora del ciclo de
repeticiones i , en el primer caso y el operador -- para decrementarla en el
segundo caso.

class ContCreceDecrece{
public static void main (String args[]) {
String salida1 ="Valores crecientes de i:";
String salida2 ="Valores decrecientes de i:";
// el siguiente segmento es creciente
for (int i = 0; i < 7; i++) {
salida1 = salida1+"nvalor de i = " + i;
}
JOptionPane.showMessageDialog(null,salida1);
// el siguiente segmento es decreciente
for (int i = 7; i > 0; i--) {
salida2=salida2+"nvalor de i = " + i;
}
JOptionPane.showMessageDialog(null,salida2);
}
}
Los siguientes son los resultados obtenidos:
Operadores Relacionales
Los operadores relacionales permiten establecer la relación de un operando
respecto de otro. Cualquier tipo de operandos, integer, float, char y
boolean, pueden ser comparados mediante el operador de igualdad lógica ==
y el de desigualdad lógica !=. Los operandos de tipo integer, float, char
ContCreceDecrece
ContCreceDecrece

pueden ser usados para efectos de comparación mayor que o menor que. El
resultado de una operación relacional es de tipo booleano.
Los siguientes son los operadores relacionales, los cuales se utilizan
frecuentemente en las expresiones que controlan los diferentes tipos de ciclos,
así como en las expresiones de selección.
Operador Descripción Operador Descripción
== Igual a. < Menor que.
!= No igual a. >= Mayor o igual que.
> Mayor que. <= Menor o igual que.
Ejemplo 7: Desarrollar un programa que permita leer cuatro valores, a, b, c, d
y determina, si es o no verdadero (true) que a sea mayor o igual que b, así
mismo si a es igual a d y si c es mayor o igual que d.
class OperacionesRelacionales{
int a, b, c, d;
String salida;
boolean resultado;
a=2;
b=3;
c=5;
d=2;
salida = "Valores de: a = "+a+"; b = "+b+"; c = "+c+
"; d = "+d;
resultado = a > b;
salida=salida + "nResultados: na > b: "+resultado;
resultado = a == d;
salida = salida +"n a == d: "+resultado;
resultado = c >= d;
salida=salida +"n c >= d: "+resultado;
JOptionPane.showMessageDialog(null,salida);
}
}
El cual dará los siguientes resultados:

Operadores lógicos booleanos
Frecuentemente los operadores relacionales se utilizan en conjunto con otro
conjunto de operadores, los operadores condicionales o lógicos booleanos.
Estos operan solamente sobre operandos booleanos, dando como resultado un
valor booleano. Los siguientes son los operadores lógicos booleanos:
Operador Resultado Operador Resultado
& AND lógico &= Asignación AND
| OR lógico |= Asignación OR
^ XOR lógico (OR
exclusivo)
^= Asignación XOR
|| OR en corto circuito == Igual a
&& AND en corto circuito != Distinto de
! NOT unitario lógico ?= If-then-else ternario
Operadores lógicos booleanos básicos
Los operadores lógicos booleanos básicos corresponden a AND (&), OR (|),
XOR (^) y NOT (!). La siguiente tabla ilustra el resultado de la operación de
cada operandor para dos operandos A y B de tipo lógico. La primera fila indica
los nombres de los operandos, A y B, seguidos de las operaciones lógicas a
evaluar. Los resultados de las operaciones, dependiendo de los valores que
tomen A y B, se ilustran en las filas siguientes. El valor verdadero (true) se
representa con V y el valor falso (false) con F:
OperacionesRelacionales

A B A | B A & B A ^ B ! A
F F F F F V
V F V F V F
F V V F V V
V V V V F F
Ejemplo 8: Desarrollar un programa que permita generar las tablas de verdad
para diferentes operadores logicos booleanos:
1. import javax.swing.*;
2. public class OperadoresLogicos {
3. public static void main( String args[] ) {
4. JTextArea areaSalida = new JTextArea( 17, 20 );
5. JScrollPane scroller = new JScrollPane( areaSalida );
6. String salida = "";
7. salida += " Operador logico AND (&&)" +
8. "n false && false: " + ( false && false ) +
9. "n false && true: " + ( false && true ) +
10. "n true && false: " + ( true && false ) +
11. "n true && true: " + ( true && true );
12. salida += "nn Operador logico OR (||)" +
13. "n false || false: " + ( false || false ) +
14. "n false || true: " + ( false || true ) +
15. "n true || false: " + ( true || false ) +
16. "n true || true: " + ( true || true );
17. salida += "nn Operador logico Booleano AND (&)" +
18. "n false & false: " + ( false & false ) +
19. "n false & true: " + ( false & true ) +
20. "n true & false: " + ( true & false ) +
21. "n true & true: " + ( true & true );
22. salida += "nn Operador logico Booleano OR inclusivo
(|)" +
23. "n false | false: " + ( false | false ) +
24. "n false | true: " + ( false | true ) +
25. "n true | false: " + ( true | false ) +
26. "n true | true: " + ( true | true );
27. salida += "nn Operador logico Booleano OR exclusivo
(^)" +
28. "n false ^ false: " + ( false ^ false ) +
29. "n false ^ true: " + ( false ^ true ) +
30. "n true ^ false: " + ( true ^ false ) +
31. "n true ^ true: " + ( true ^ true );
32. salida += "nn Operador logico NOT (!)" +
33. "n !false: " + ( !false ) +

34. "n !true: " + ( !true );
35. areaSalida.setText( salida );
36. JOptionPane.showMessageDialog( null, scroller,
37. " Tablas de verdad",
JOptionPane.INFORMATION_MESSAGE );
38. System.exit( 0 );
39. }
40.}
En este programa se construyen los resultados de evaluar las tablas de verdad,
mediante la variable salida de tipo String. Obsérvese cómo se van agregando
los diferentes mensajes y resultados en las líneas 7, 12, 17, 22, 27 y 32, a fin de
elaborar un reporte. El carácter de escape (n) permite como en otros ejemplos,
saltar a la siguiente línea. Veamos a continuación las explicaciones referidas a
los nuevos elementos involucrados en el programa:
Línea 4: se crea un objeto areaSalida del tipo JtextArea que es una clase
a partir de la cual se crean componentes para generar áreas de texto editable, es
decir, que se puede modificar en la pantalla. Al área de texto se le asigna 17
columnas, por 20 filas medidas en caracteres.
Linea 5: se crea un objeto scroller del tipo JScrollPane, que es una clase
a partir de la cual se crean componentes desplazables. Su desplazamiento es en
el sentido horizontal ( en la parte inferior del área) y en el sentido vertical (en la
parte derecha del área). Dentro de este componente se coloca como argumento
el componente areaSalida.
Linea 35: mediante el método setText() de la clase JtextArea, el objeto
areaSalida carga los resultados guardados en salida.
Línea 36: se utiliza el método showMessageDialog del componente
JoptionPane para mostrar los resultados que se han cargado en el
componente scroller.
Linea 38: para terminar la ejecución del programa se invoca el método exit
(0) de la clase System.
Los resultados que se obtienen al ejecutar el programa son los siguientes.
Observese el control desplazable del lado derecho, lo cual permite que el área
de texto pueda ser visualizada en su totalidad utilizando el ratón.

Operadores lógicos booleanos en cortocircuito
Son los operadores && y || que corresponde a versiones secundarias de los
operadores básicos AND (&) y OR (|), y se les denomina operadores lógicos en
cortocircuito.
Como se puede observar en la tabla de operadores booleanos, si el operando A
es falso (F) el operador AND (&) dará como resultado falso (F), independiente
del valor del operando B. De igual manera, el operador OR (|) dará como
resultado verdad (V) cuando A sea verdad (V) independiente del valor del
operando B.
Las formas de los operadores en cortocircuito && y ||, en lugar de las formas &
y | hará que Java no se preocupe en evaluar el operando o expresión del lado
derecho cuando el resultado de la operación ya este decidido a partir del
operando o expresión del lado izquierdo. En algunos casos esto puede no ser
deseable, refiérase a la discusión anterior sobre pre y post-incremento y
operadores de asignación.
OperadoresLogicos

Operadores lógicos de asignación
Los operadores &=, |= y ^=, permite hacer que la variable del lado izquierdo
tome el valor resultante de evaluar la expresión formada por esta variable con la
expresión del lado derecho del operador. La siguiente tabla lo ilustra:
Operador Uso Equivalencia
&= op1 &= op2 op1 = op1 & op2;
|= op1 |= op2 op1 = op1 | op2;
^= op1 ^= op2 op1 = op1 ^ op2;
Instrucciones de control de flujo: selección
La mayoría de los programas que usted realice requerirán que bajo ciertas
condiciones se ejecuten unas instrucciones mientras se evitan ó saltan otras.
Java permite este propósito mediante las instrucciones de selección (if - else) y
de selección múltiple (switch).
Instrucción if - else
Tal como se vio en el Capítulo 2, esta instrucción permite, con base a la
evaluación de un predicado o condición de tipo lógico, direccionar el flujo de
la ejecución de un programa hacia uno de dos caminos diferentes. La forma
general de esta instrucción en Java es como sigue:
if (expresión booleana) instrucción1;
else instrucción2;
expresión booleana es cualquier expresión de tipo lógico, es decir que su
resultado al ser evaluada da un valor lógico, true o false.
Instrucción1, instrucción2, puede ser una instrucción simple o un conjunto de
instrucciones, en cuyo caso se deben agrupar entre corchetes {} y formar un
bloque de instrucciones, como en el siguiente caso:
if (expresión booleana) {
instrucción11;
instrucción12;
....
}
else {

Programación Java básica: Instrucciones de control de flujo: selección 7 -
42
instrucción21;
instrucción22;
...
}
La instrucción opera de la siguiente manera: si expresión booleana toma el
valor true, se ejecutara la instrucción1 o el bloque de instrucciones en
caso de haber más de una (instruccion11, instrucción12,..) y no se
ejecutará la instrucción2 o bloque de instrucciones en caso de haber más de
una (instruccion11, instrucción12,..). Si la expresión booleana
toma el valor false, no se ejecutara instrucción1 o el bloque si es mas de
una instrucción, y se ejecutará la instrucción2 o el bloque en caso de ser
mas de una instrucción. En ningún caso se ejecutarán ambas instrucciones.
La claúsula else es de carácter opcional, lo que significa que puede no utilizarse,
en cuyo caso independiente de la ejecución o no de instrucción1, se
continuará con la siguiente instrucción después del if, como lo indica la
siguiente forma, tanto simple como en su forma con bloque de instrucciones:
if (expresión booleana) instrucción1;
instrucción3;
En la forma de bloque de instrucciones dentro del cuerpo del if:
if (expresión booleana){
instrucción1;
....
}
instrucción3;
Los siguientes ejemplos que ilustran diferentes situaciones:
// ejemplo del if-else con instrucciones simples
int a, b, c;
if(a > b)
c= a+b;
else
c= a*b;
En el anterior segmento de código si a es mayor que b, hace c= a+b, de lo
contrario hace c= a*b.
En el siguiente caso se tiene la forma del if simple, puesto que independiente
de la ejecución de c=a+b, se continuará con la instrucción d=a*b.

43
// ejemplo del if simple con instrucciones simples
int a, b, c, d;
if(a > b)
c= a+b;
d= a*b;
En el siguiente ejemplo la segunda instrucción if contiene dos bloques con
instrucciones en lugar de una sola como en el primer caso. Así mismo se
observa que la expresión booleana, esta formada por una sola variable,
obviamente del tipo boolean.
int a=1, b=2, c=3, e=4, f;
boolean d;
if(a > b)
d=true;
else
d=false;
if(d){
a=b+c+e;
f=b*c + a;
}
else{
a=b*c*e;
f= b+c+a;
}
Instrucciónes if anidadas
Es muy común que en los programas sea necesario que la evaluación del
predicado de una instrucción if o if-else sea el destino de otra instrucción if o
if-else, en cuyo caso se denominan if anidados. Cuando se utilizan if anidados,
es importante tener en cuenta que, una cláusula else se refiere a la instrucción if
mas cercana que esté dentro del mismo bloque y que no tenga asociación con
otro else. El siguiente segmento de programa ilustra esta situación:
1.int i, j, k, c, d, b;
2.if(i == 20){
3. if(j<i)
4. a=34;
5. if(k>200)
6. c=40;
7. else
8. d= 90;
9. }
10.else
11. b=c;

44
El cuerpo del primer if va entre la línea 2 y la línea 11. Si el predicado (i==20)
es falso, no ejecutará las lineas de la 3 a la 9, y ejecutará la línea 11. Ejecutará
las líneas 3 a la 9, si el predicado es verdadero y no ejecutará la línea 11. Si el
predicado (j<i) en la linea 3 es verdadero, ejecutará la línea 4 y continuará con
la línea 5. Si el predicado de la línea 3 es falso, no ejecutará la linea 4 y
continuará con la línea 5. Si el predicado de la línea 5 es verdadero, ejecutará la
línea 6 y no hará la línea 8. Si este predicado es falso, no ejecutará la línea 6 y
ejecutará la línea 8.
Como se estableció antes, la línea 8, d=90 correspondiente al else de la linea 7,
está asociado con el if(k>200), de la línea 5 ya que es el mas cercano y que se
encuentra en el mismo bloque. El ultimo else de la línea 10, y la instrucción b=c
en la línea 11 está asociado con el primer if(i==20), en la línea 2.
Instrucciónes if -else- if múltiples
Las instrucciones if -else- if múltiples constituyen también una práctica común
en la programación y se fundamentan en la utilización de secuencias de if
anidados. La siguiente es la forma general de estas instrucciones:
if(expresión booleana1)instrucción1;
else if(expresión booleana2) instrucción2;
else if(expresión booleana3) instrucción3;
else instrucción4;
En esta forma las instrucciones if se ejecutan de arriba hacia abajo, hasta que
alguna de las expresiones booleanas sea verdadera, en cuyo caso se ejecuta la
instrucción asociada y no se ejecuta ninguna de las siguientes. Ahora, si
ninguna de las expresiones booleanas es verdadera, se ejecutará la instrucción
asociada con el ultimo else. Recuerdese que, cada una de las instrucciones
puede ser formada a su vez por bloques encerrados entre corchetes, y estos a su
vez pueden contener otras instrucciones if como en la forma siguiente:
if(expresión booleana1){
instrucción1;
....
}
else if(expresión booleana2){
instrucción2;
....
}
else if(expresión booleana3){

45
instrucción3;
....
}
else {
instrucción4;
....
}
Ejemplo 9: Ilustra el caso de los if anidados para la situación de una
aplicación que lee un valor entero, correspondiente a la edad de una persona,
y determina el grupo de edad en el que se encuentra esa persona:
class GrupoEdad{
public static void main(String edadLeida[]) {
String entrada, grupo;
int edad;
entrada = JOptionPane.showInputDialog("Digite una
edad");
edad = Integer.parseInt(entrada);
/* en esta serie de if-else if se encuentra el grupo a que
pertenece esa edad */
if(edad <= 18)
grupo ="menor";
else if((edad > 18) && (edad < 60))
grupo = "adulto";
else if ((edad >= 60) && (edad < 100))
grupo="tercera edad";
else grupo = "cuarta edad";
JOptionPane.showMessageDialog(null, "La edad "+edad+"
corresponde a "+ grupo);
}
}
En este ejemplo se ilustra la utilización de expresiones booleanas compuestas
en los dos else if para determinar el rango en donde se encuentra la edad. La
ejecución de este programa arrojara el siguiente resultado:

46
Ejemplo 10: En el siguiente ejemplo se introduce un valor entero
correspondiente al número de un mes (entre 1 y 12) y permite encontrar la
estación que corresponde a ese mes en particular.
class CalculaEstacion{
public static void main(String argumento[]) {
String entrada, estacion;
int mes;
entrada=JOptionPane.showInputDialog("Digite el número
de un mes:");
mes = Integer.parseInt(entrada);
if(mes==12 ||mes==1||mes==2)
estacion = "invierno";
else if(mes==3||mes==4||mes==5)
estacion="primavera";
estacion="verano";
estacion="otoño";
else
estacion="valor invalido de mes";
JOptionPane.showMessageDialog(null, "El mes "+mes+" es
"+estacion);
}
Figura 15 Entrada de datos para la clase
GrupoEdad
Figura 16 Resultados de la clase GrupoEdad

47
}
Los resultados del programa se ilustran a continuación:
Ejemplo 11: Desarrollar un programa que permita leer dos valores enteros y
determinar sus relaciones entre ellos:
public class ComparaEnteros{
public static void main( String args[] ) {
String primerValor, segundoValor,resultado;
int valor1, valor2;
primerValor =
JOptionPane.showInputDialog( "Digite el primer valor
entero:" );
segundoValor =
JOptionPane.showInputDialog( "Digite el segundo
valor entero:" );
valor1 = Integer.parseInt( primerValor );
valor2 = Integer.parseInt( segundoValor );
resultado = "";
if ( valor1 == valor2 )
resultado = valor1 + " == " + valor2;
if ( valor1 != valor2 )
resultado = valor1 + " != " + valor2;
if ( valor1 < valor2 )
Figura 17 Lectura datos clase CalculaEstacion
Figura 18 Resultados clase CalculaEstacion

48
resultado = resultado + "n" + valor1 + " < " +
valor2;
if ( valor1 > valor2 )
resultado = resultado + "n" + valor1 + " > " +
valor2;
if ( valor1 <= valor2 )
resultado = resultado + "n" + valor1 + " <= " +
valor2;
if ( valor1 >= valor2 )
resultado = resultado + "n" + valor1 + " >= " +
valor2;
JOptionPane.showMessageDialog(
null, resultado, "Resultados de la comparacion",
System.exit( 0 );
}
}
Figura 19 Lectura datos ComparaEnteros
Figura 20 Lectura datos ComparaEnteros

49
Instrucción de selección múltiple switch
Esta instrucción permite transferir el control a diferentes partes del programa,
dentro de su cuerpo, dependiendo del valor de una variable o evaluación de una
expresión. En el lenguaje algorítmico se estableció la instrucción caso para
este tipo de situaciones.
La siguiente es la forma general de la instrucción switch :
switch(expresion) {
case valor1:
instruccion1;
break;
case valor2:
instruccion2;
break;
.
.
.
case valorN:
instruccionN;
break;
default:
instruccionM;
}
expresion es la expresión a evaluar cuyo valor resultante debe ser simple y
compatible con cada uno de los valores (valor1, valor2, ..valorN) en
seguida de las clausulas case y que determina que instrucción (
instruccion1, instruccion2, ..instruccionN) se debe ejecutar.
Cada uno de los valores debe ser un literal, es decir debe ser una constante, no
una variable, ademas que deben ser valores únicos sin repeticiones o
duplicados, entre los diferentes bloques case.
Figura 21 Resultados clase ComparaEnteros

50
La forma de la instrucción switch para el caso de bloques de instrucciones
dentro de cada una de las opciones de las sentencias case es de la siguiente
manera:
switch(expresion) {
case valor1:{
instruccion1;
....
}
break;
case valor2:{
instruccion2;
....
}
break;
.
.
.
case valorN:{
instruccionN;
....
}
break;
default:{
instruccionM;
....
}
}
La instrucción switch opera de la siguiente manera: el resultado de evaluar la
expresion, se compara con cada uno de los valores indicados en cada una de
las cláusulas case. Si coincide con alguno de los valores constantes (valor1,
valor2, ..valorN) se ejecutará la instrucción ( o instrucciones)
correspondiente a la cláusula case cuyo valor coincide y mediante la
instrucción break se interrumpe esa secuencia para darle el control ó saltar a
las instrucciones o código que siguen despues de la instrucción switch . Si
ninguno de los valores corresponde con el resultado de la expresión entonces
se ejecutará por defecto la clausula default. Esta cláusula es opcional, sin
embargo, si ningún valor coincide y no está la cláusula default , no se realiza
ninguna operación y el control se da a las instrucciones que siguen después de
la instrucción switch.
Nótese que la instrucción break se utiliza aquí para “saltar fuera” del switch,
a la primera línea de código o instrucción que sigue después de la instrucción

51
switch.
Una limitación importante de la instrucción switch en Java es que solo puede
seleccionar opciones del tipo byte, char, short, int y long. No se
puede utilizar en las opciones valores primitivos float, double, String,
ni ningún otro tipo de objeto. Tampoco se pueden utilizar relaciones diferentes
a la igualdad. Para las situaciones no contempladas en el switch, se debe
utilizar entonces la instrucción if-else.
Ejemplo 12: El siguiente ejemplo para el calculo del valor a pagar por una
camisa dependiendo de su talla, ustra la utilización de la instrucción switch :
class ValorAPagar{
int talla;
float precio=0;
String entrada;
do{
entrada=JOptionPane.showInputDialog("Digite una talla
de camisa n34 a 40:");
talla = Integer.parseInt(entrada);}
while(!(talla>= 34 && talla <=40));
switch(talla)
{
case 34:
precio=(float)30000.00;
break;
case 36:
break;
case 38:
break;
case 40:
break;
}
JOptionPane.showMessageDialog(null,"El precio de la
talla "+talla+" es $"+precio);
}
}
La ejecución de este programa da como resultado:

52
Ejemplo 13: Ahora si se quisiera asignar a las tallas 34 y 36 3l mismo valor,
asi como a las 38 y 40, el programa quedaría de la siguiente manera:
class ValorAPagar1{
int talla;
float precio=0;
String entrada;
do{
entrada=JOptionPane.showInputDialog("Digite una talla
de camisa n34 a 40:");
talla = Integer.parseInt(entrada);}
while(!(talla>= 34 && talla <=40));
switch(talla){
case 34:
case 36:
break;
case 38:
case 40:
Figura 22 Lectura datos clase ValorAPagar
Figura 23 Resultados clase ValorAPagar

53
break;
}
JOptionPane.showMessageDialog(null,"El precio de la
talla "+talla+" es $"+precio);
}
}
Como se puede observar se ha omitido la instrucción break en las opciones 34
y 38, agrupándolas con la 36 y con la 40 respectivamente. El programa continúa
su ejecución hasta que encuentre un break o hasta el final del bloque switch.
El resultado para la ejecución de este programa es el siguiente:
Ejemplo 14: En el siguiente caso se utiliza la cláusula default para indicar que
una calificación no es aprobatoria:
import javax.swing.*;
class ApruebaNoAprueba{
String entrada,resultado;
Figura 24 Entrada datos clase ValorAPagar1
Figura 25 Resultados clase ValorAPagar1

54
int nota;
do{
entrada=JOptionPane.showInputDialog("Digite una
calificacion de 1 a 10:");
nota = Integer.parseInt(entrada);}
while(!(nota>= 1 && nota <=10));
switch(nota)
{
case 10:
case 9:
case 8:
case 7:
case 6:
resultado = "Aprobado";
break;
default:
resultado = "Reprobado";
break;
}
JOptionPane.showMessageDialog(null,"Su calificación es
"+resultado);
System.exit(0);
}
}
El programa al ser ejecutado dará la siguiente salida:
Figura 26 Lectura datos clase
ApruebaNoAprueba
Figura 27 Resultados clase
ApruebaNoAprueba

55
Ejemplo 15: El siguiente ejemplo corresponde al del calculo de la estación a
que corresponde un mes determinado, solo que esta vez se utilizara la
instrucción switch, y se leerá el valor del mes por medio del componente
JoptionPane:
class CalculaEstacion2{
public static void main(String argumento[]) {
String entrada, estacion;
int mes;
entrada=JOptionPane.showInputDialog("Digite el número
de un mes:");
mes = Integer.parseInt(entrada);
switch (mes) {
case 12:
case 1:
case 2:
estacion= "invierno";
break;
case 3:
case 4:
case 5:
estacion = "primavera";
break;
case 6:
case 7:
case 8:
estacion = "verano";
break;
case 9:
case 10:
case 11:
estacion = "otoño";
break;
default:
estacion="un valor invalido";
}
JOptionPane.showMessageDialog(null, "El mes "+mes+" es
"+estacion);
System.exit(0);
}
}
Despues de compilar y ejecutar la clase anterior se obtienen los siguientes

56
resultados:
Instrucciones switch anidadas
De igual manera que las instrucciones if-else anidadas, se pueden utilizar las
instrucciones switch, como parte de un bloque de instrucciones de un switch
externo. Cada bloque switch define su propio bloque, con lo cual no se
producen conflictos entre las constantes o literales de las cláusulas case de cada
instrucción switch. Mas adelante se presentará un ejemplo de uso de la
instrucción switch anidada.
Instrucciones control de flujo: ciclos
Java, como otros lenguajes de programación, tiene tres tipos de instrucciones
para manejar ciclos, repeticiones o bucles: for, while y do-while. Tal como se
trató en el Capítulo 2, Lenguaje Algorítmico, estas instrucciones ejecutan
repetidamente el mismo conjunto de instrucciones contenidas en su bloque,
hasta que se cumpla una condición determinada, expresada por una expresión
de tipo booleano. Con frecuencia este tipo de instrucciones se utilizan
Figura 28Lectura datos clase CalculaEstacion2
Figura 29 Resultados clase
CalculaEstacion2

Programación Java básica: Instrucciones control de flujo: ciclos 7 - 57
asociadas con estructuras de datos del tipo arreglos, para realizar operaciones
sobre cada elemento de la estructura, por ejemplo en un problema de
multiplicación de matrices.
La diferencia sustantiva de cada una de las anteriores instrucciones radica en las
características de la forma de control del ciclo respectivo:
• Cuando se conoce de antemano el número de veces que se repetirá un ciclo,
se utilizará preferencialmente la instrucción for.
• Si se requiere que el ciclo se repita al menos una vez es decir, primero se
realiza la acción o instrucciones del bloque y luego se pregunta por la
condición, se puede utilizar do-while.
• Si se requiere de un ciclo el cual se ejecuta cero o mas veces, es decir,
primero se evalúa la condición y dependiendo de esta se realiza o no el
ciclo, se puede utilizar while.
La estructura lógica de los ciclos o bucles está formada de cuatro partes:
• Inicialización: hace referencia al código que establece las condiciones de
inicio del ciclo. Por ejemplo la variable que va a controlar el ciclo.
• Cuerpo: comprende el bloque de instrucciones que se desea repetir con el
ciclo y que es el propósito principal de este.
• Iteración: es el código que se ejecuta después del cuerpo pero antes de un
nuevo ciclo o repetición. En este se incrementa la variable controladora del
ciclo.
• Terminación: Corresponde a una expresión de tipo booleano que es evaluada
cada vez que se hace un ciclo, para verificar si este debe terminar o
continuar. Se evalúa respecto de la variable controladora del ciclo.
Instrucción while
Es la instrucción básica para el manejo de los ciclos o iteraciones, ya que
permite ejecutar repetidamente una o mas instrucciones, mientras una condición
o predicado lógico de terminación sea verdadera. Lo cual significa que, evalúa
la condición antes de iniciar un ciclo, el cual puede no realizarse si la condición
no es verdadera. Su forma general es la siguiente:
[inicialización;]
while (condición de terminación) {
cuerpo;

[iteración;]
}
Ejemplo 16: Desarrollar un programa que permita generar y escribir los 10
primeros números enteros
1.class CicloWhile{
2. public static void main(String args[]){
3. int entero = 1;
4. while(entero <=10){
5. System.out.println(“Numero = “+entero);
6. entero++;
7. }
8. System.out.println(“Ciclo terminado, valor de entero=
“+entero);
9. }
10.}
Linea 3: corresponde a la parte de inicialización del ciclo, se le asigna a la
variable entero el valor 1. está variable forma parte de la condición de
terminación, en la línea 4, la cual al evaluarse la primera vez, da como
resultado true, es decir la variable entero es menor o igual a 10, por tanto
realiza la primera iteración del cuerpo del ciclo, formado esta vez por la
instrucción System.out.println para generar la salida en la pantalla de
comandos.
Linea 4- 9: cuerpo del ciclo, el cual es iniciado con la instrucción while y la
primer llave. Mientras la condición sea verdadera, se realizará la generación de
una línea en la pantalla con el valor de entero.
Línea 5: escribe los valores de la variable entero.
Línea 6: Después de escribir el valor entero generado la primera vez en la Línea
3, se incrementa la variable entero mediante la expresión entero++, que es
la parte de iteración del ciclo.
Se repite el proceso de evaluar la condición de terminación; al ser
nuevamente verdadera, se realiza una vez mas el ciclo generando la salida e
iterando nuevamente. Así sucesivamente hasta que la condición de
terminación se torna falsa, lo cual se logra cuando se ha generado la salida
con System.out.println, del valor entero igual a 10, incrementando luego
en la iteración su valor a 11, el cual hace que la condición de

terminación tome el valor false, y no realizándose mas el ciclo del while.
Se continúa con la siguiente instrucción en la línea 8, la cual genera un mensaje
de terminación e indica el valor final de la variable entero.
Obsérvese que, si el valor de la variable entero es mayor que 10 antes de
iniciar el ciclo, este nunca se realiza, aunque escribirá el mensaje de
terminación, indicando el valor asignado a la variable.
Cuando se ejecuta el programa anterior da como resultado en la pantalla de
comandos:
Numero = 1
Numero = 2
Numero = 3
Numero = 4
Numero = 5
Numero = 6
Numero = 7
Numero = 8
Numero = 9
Numero = 10
Ciclo terminado, valor de entero= 11
Ejemplo 17: Desarrollar un programa en Java que permita evaluar la función
f x=x
2
2 x entre los valores a y b (a < b) y a incrementos dx. Los
valores para a, b, dx, serán leídos por el teclado. Los valores de la evaluación
de la función, así como los de la ordenada x, se escribirán en la pantalla.
1.import java.text.DecimalFormat;
2.import javax.swing.*;
3.public class EvaluaFuncion1{
4. public static void main( String args[] ){
5. double a, b, dx, fx, x;
6. String input;
7. DecimalFormat precision = new DecimalFormat
( "0.00" );
8. JTextArea outputTextArea = new JTextArea(10,20);
9. JScrollPane scroller = new JScrollPane
(outputTextArea);
10. input= JOptionPane.showInputDialog("Digite el
valor para a ");
11. a = Double.parseDouble(input);
12. input = JOptionPane.showInputDialog("Digite el
valor para b ");
13. b = Double.parseDouble(input);
14. input = JOptionPane.showInputDialog("Digite el
valor para dx ");

15. dx = Double.parseDouble(input);
16. outputTextArea.append( " valor xtvalor f(x)
n" );
17. x=a;
18. while(x<=b){
19. fx = x*x - 2*x;
20. outputTextArea.append(" "+precision.format(fx)
+ "t"+ precision.format(x)+ "n");
21. x = x+dx;
22. }
23. JOptionPane.showMessageDialog( null, scroller,
"Evalua Funcion f(x) = x*x
-2*x",JOptionPane.INFORMATION_MESSAGE );
24. System.exit( 0 );
25. }
26.}
Linea 1: se importa la clase DecimalFormat, el cual se requiere para dar
formato a la salida de resultados de las variables reales x y fx.
Linea 5:define de tipo double a las variables de entrada a, b, dx, y de
salida fx y x.
Linea 7: crea un objeto precision, del tipo DecimalFormat a partir del
constructor de esta o sea DecimalFormat(“0.00”), en el cual define que
tendrá dos cifras decimales en la salida de resultados.
Linea 8: crea un objeto areaDeSalida del tipo JTextArea, a partir del
constructor JTextArea(10,20), el cual define un área de 10 columnas por 20
filas. En esta área se guardarán los resultados.
Linea 9: crea un objeto scroller del tipo JScrollPane, a partir del
constructor JScrollPane(areaDeSalida), el cual contendrá el objeto
areaDeSalida, de tal manera que se podrá hacer desplazamiento horizontal y
vertical de la información mostrada.
Linea 10: mediante el componente JoptionPane, se introduce la informacion
para la cadena input.
Linea 11: se convierte la cadena leida input, la cual puede contener cifras
decimales en un valor real de tipo Double, elc ual se almacena en a, mediante el
método parseDouble(input), de la clase Double.
Lineas12-15: se hace la misma operación para introducir y convertir a valores
reales los valores para b y dx.

Linea 16. se agrega, mediante el método append(), la primera línea de texto al
objeto areaDeSalida. Obsérvese la utilización del comando de escape t
para hacer un tabulado, así como el del n para saltar a una nueva línea.
Linea 17. asigna a la variable x el valor del punto inicial a. La variable x es la
que controlará la ejecución del ciclo.
Linea 18: inicio del ciclo, el cual es controlado por el predicado o condición
(a<=b), es decir que, mientras esa condición sea verdadera, se ejecutarán las
instrucciones del cuerpo del ciclo while denotadas por el par de llaves {}.
Linea 19: cálculo del valor de fx mediante la evaluación de la expresión para
un valor de x.
Linea 20: agrega al objeto areaDeSalida, el texto correspondiente a los
resultados de fx y x. Obsérvese el uso del método format() del objeto
precision, para darle formato de salida con dos decimales, a las variables fx y
x.
Linea 21: se incrementa la variable x en el valor dx y se repite el ciclo si la
condición de la línea 18 sigue siendo verdadera.
Linea 23: se escriben los resultados del objeto scroller. Se coloca un título
“Evalua Funcion f(x) = x*x – 2*x” en la parte superior de la ventana del
componente JOptionPane y se utiliza la constante
INFORMATION_MESSAGE, para que aparezca un ícono alusivo a
información.
Linea 24: se invoca el método exit(0), para terminar la ejecución del
programa.
Los resultados obtenidos al ejecutar el anterior programa, para los valores de a,
b, dx dados son los siguientes:
Figura 30 Lectura valor a

Ejemplo 18 : Desarrollar un programa que permita leer 5 valores enteros y
calcular su promedio:
public class PromedioEnteros {
int total= 0, contador= 0, valorEntero,
Figura 31 Lectura valor b
Figura 32 Lectura valor dx
Figura 33 Resultados clase EvaluaFuncion

promedioEnteros;
String entrada;
while ( contador < 5 ) {
entrada = JOptionPane.showInputDialog(
"Digite un valor entero > 0: " );
valorEntero = Integer.parseInt( entrada );
total = total + valorEntero;
contador = contador + 1;
}
promedioEnteros = total / 5;
null, "El promedio de los valores leidos es: " +
promedioEnteros, "Calculo Promedios",
System.exit( 0 );
}
}
Los resultados obtenidos al digitar los valores enteros 10, 11, 12, 13, 14 enteros
son los siguientes:
Ejemplo 19: Desarrollar el problema anterior pero esta vez el ciclo se hace
con un registro centinela. Se debe escribir también el numero de valores leídos.
public class PromedioEnteros1 {
int total= 0, contador= 0, valorEntero,
promedioEnteros;
String entrada;
"Digite un valor entero.nSi digita -9
termina el programa" );
valorEntero =Integer.parseInt( entrada );
while ( valorEntero != -9 ) {
total = total + valorEntero;
Figura 34 Resultados clase PromedioValores

contador = contador + 1;
"Digite un valor entero > 0: " );
valorEntero = Integer.parseInt( entrada );
}
promedioEnteros = total / contador;
null, "El promedio de los "+contador+" valores
leidos es: " + promedioEnteros, "Calculo Promedios",
System.exit( 0 );
}
}
Los resultados obtenidos al ejecutar el programa anterior con los datos, 10, 20,
30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, -9, es el siguiente:
Ejemplo 20: Desarrollar un programa Java tipo Applet que permita dibujar 15
rectángulos.
import java.awt.Graphics;
import javax.swing.JApplet;
public class ContadorWhile1 extends JApplet {
public void paint( Graphics g ){
int contador = 1;
while ( contador <= 15 ) {
g.drawRect(contador*20, contador*5, 15, 15 );
++contador;
}
}
}
El programa HTML para ejecutar el anterior applet es el
siguiente:
Figura 35 Resultados clase PromedioEnteros1

<html>
<applet code="ContadorWhile1.class" width=350 height=105>
</applet>
</html>
Los resultados son los siguientes:
Instrucción do-while
En esta instrucción de ciclo, la evaluación de la condición de terminación se
hace al final del ciclo y no antes del ciclo como en la instrucción while vista
antes. Esto significa que, aunque la condición de terminación sea falsa, se
realiza al menos una sola vez el ciclo. La forma general de esta instrucción es:
[inicializacion;]
do {
cuerpo;
[iteración;]
}
while(condición de terminación);
inicialización, cuerpo, iteración y condición de terminación,
tienen el mismo significado dado antes en la instrucción while.
El ejemplo visto antes de la generación de los 10 primeros números enteros ,
ilustra en este caso, la utilización de la instrucción do-while .
Ejemplo 21:
1.class CicloDoWhile{
Figura 36 Resultados applet ContadorWhile1

Programacion java basica

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (6)

Similar to Programacion java basica

Similar to Programacion java basica (20)

More from Juan Antonio Ramos

More from Juan Antonio Ramos (16)

Recently uploaded

Recently uploaded (20)

Programacion java basica