Manual de Java (página 3)

Descubre el Error

A continuación se muestran, algunas líeas
de código,
las cuales poseen algunos errores, los que usted tendrá
que identificar y corregir:

1. import java.swing.*

2.
JOptionPane.showMessageDialog("Bienvenido!!!!");

3. g.drawstring("Hola", 25,25);

4. g.drawOval(60,30,45,);

5. g.drawrect(60,50);

6. g.setColor(White);

7. setbackground(Green);

Capítulo IV: Cadenas de Caracteres, Métodos
Matemáticos y Excepciones

4.1 Variables

Como ya lo hemos dicho, una variable, es aquella que,
tiene la propiedad o
capacidad de cambiar de valor, durante
al ejecución del programa.
Supongamos que se necesitan dos variables de
tipo double, la declaración de ellas,
sería:

double x, y;

Cuando, realizamos ésta acción
(o la declaración de cualquier otro tipo de variables),
estamos asignando espacio en memoria (el
tamaño viene dado por el tipo de dato, del cual se
está declarando. Ver tabla 2.2). En dicho espacio, se
guardará el valor, que almacenará dicha
variable.

Por tanto, una variable tiene tres propiedades
básicas:

1. Una posición de memoria para almacenar el
   valor
2. El tipo de datos
   almacenado en la posición de memoria.
3. Y el identificar (nombre) asociado a ésa
   posición de memoria.

Ahora bien, el lector se preguntará, el por
qué, pareciera una redundancia, al hablar de las
variables, ya que, esto lo hemos tratado con
anterioridad.

Pues bien, es importante saber esto, ya que iniciaremos
hablando de lo que es la esencia de Java:

4.2 Los Objetos

Un Objeto, es una colección de datos y
operaciones,
que utilizan esos datos.

Declarar un Objeto

Al declarar un objeto, lo único que hacemos es
declarar una variable, de ése tipo, la cual hará
referencia a ése objeto. Por tanto, dicha variable
contendrá una dirección de memoria (Algo similar a lo que
eran los punteros en C).

Un objeto se crea, a partir del operador new y el
constructor correspondiente a la clase, de la
cual se está creando el objeto.

Por ejemplo, si deseamos crear, un objeto de la Clase
Datos, sería así:

Datos Jefe; //Declaración del Objeto
Jefe=new
Datos();//Creación del
Objeto

Pero También podemos hacerlo en una sola
línea:
Datos Jefe=new
Datos();//Declaración y
Creación del Objeto

Puesto que, de la misma manera que, se puede declarar e
inicializar una variable; un objeto puede ser declarado y creado
al mismo tiempo.

4.3 Uso de Las Cadenas de Caracteres

Las clases String y StringBuffer
están orientadas a manejar cadenas de caracteres. La clase
String está orientada a manejar cadenas de
caracteres constantes, es decir, que no pueden cambiar. La clase
StringBuffer permite que el programador cambie la cadena
insertando, borrando, etc. La primera es más

eficiente, mientras que la segunda permite más
posibilidades.

Ambas clases pertenecen al package java.lang, y
por lo tanto no hay que importarlas. Hay que indicar que el
operador de concatenación (+) entre objetos de tipo
String utiliza internamente objetos de la clase
StringBuffer y el método
append().

Los métodos de String se pueden utilizar
directamente sobre literales (cadenas entre comillas),
como por ejemplo: "Hola".length().

Por ejemplo, si deseamos crear una cadena de caracteres
del tipo String:

String nombre;

String Direccion= "San Salvador, El
Salvador";

A continuación, veamos algunos métodos de
la Clase String:

Tabla 4.1

Ejemplo 4.1

Diseñe un Programa que, lea una cadena de
Caracteres, y luego, muestre esa misma cadena en
minúsculas, mayúsculas y la longitud de la
misma.

1 import javax.swing.*;
2 public class
UsoCadenas {
3
public static void
main (String args []) {
4 String cadena, aux;
5
cadena=JOptionPane.showInputDialog("Ingrese la Cadena");
6 /*En la
variable aux, guardamos la nueva cadena
7 Note la forma en la
que llamamos los métodos:
8 Variable.Nombre_del_Metodo();*/
9
aux=cadena.toLowerCase();
10
JOptionPane.showMessageDialog(null, "Cadena
en Minúsculas: "+aux);
11
aux=cadena.toUpperCase();
12
JOptionPane.showMessageDialog(null, "Cadena
en Mayúsculas: "+aux);
13
JOptionPane.showMessageDialog(null, "La
longuitud de la cadena es:
"+cadena.length());
14 }
15 }

Explicación

Declaramos dos referencias a objetos de la clase String,
una de ellas es identificada por "cadena", la cual guardamos, la
cadena que, el usuario ha ingresado. La otra referencia (aux),
nos sirve para guardar, el resultado que devuelven los
métodos que hemos llamado.

En las líneas 9,10 y 11, puede observar, la forma
en la que se llaman a los métodos correspondientes, para
las operaciones que deseamos realizar. La sintaxis es la
siguiente:

Nombre_de_la_refencia_de_objeto .
Nombre_del_metodo();

Existen, algunos métodos que, reciben
parámetros, los cuales, deben especificarse, dentro de los
paréntesis del mismo. Pero, en el ejemplo anterior no es
el caso.

La clase StringBuffer se utiliza
prácticamente siempre que se desee modificar una cadena de
caracteres.

Completa los métodos de la clase
String ya que éstos realizan sólo
operaciones sobre el texto que no
conllevan un aumento o disminución del número de
letras del String.

Recuérdese que hay muchos métodos cuyos
argumentos deben ser objetos String, que antes de
pasar esos argumentos habrá que realizar la
conversión correspondiente. La Tabla 4.2 muestra los
métodos más importantes de la clase
StringBuffer.

Tabla 4.2

Ejemplo 4.2

Escriba un Applet que, lea una cadena de caracteres y
luego, la imprima tal cual fue digitada, y luego la dibuje de al
revés.

1 import javax.swing.*;
2 import java.awt.*;
3 public
class UsaBuffer
extends JApplet
4 {
5 String aux;
6 StringBuffer cadena;//Declaración del objeto
7 public
void init()
8 {
9 //Realizamos la
lectura
10
aux=JOptionPane.showInputDialog("Ingrese la
Cadena");
11
cadena=new
StringBuffer(aux);// al
constructor del objeto le enviamos el valor de
aux
12
}
13 public void
paint (Graphics
g)
14
{
15 super.paint(g);
16 g.drawString("La cadena Original es: "+cadena,
25,25);
17
cadena.reverse();
18
g.drawString("La cadena
invertida es: "+cadena,
25,50);
19
}
20
21 }

4.4 Métodos Matemáticos

La biblioteca de
clases de Java incluye una clase Math en su paquete java.lang, la
cual define un conjunto de operaciones matemáticas de uso común que pueden
ser utilizadas en cualquier programa. Veamos la siguiente
tabla:

Tabla 4.3

Ejemplo 4.3

Diseñe una aplicación en Java que dado el
valor de un ángulo, encuentre su seno, coseno, tangente.
Luego, le permita ingresar un dato al usuario, con el cual, pueda
calcular su raíz cuadrada.

1 import javax. swing.*;
2 class
UsaMetodos
3
{
4 public static
void main(String args
[])
5 {
6 String leer;
7 double angulo, valor;
8
leer=JOptionPane.showInputDialog("Ingrese el valor del ángulo:
");
9
angulo=Double.parseDouble(leer);
10
JOptionPane.showMessageDialog(null, "El
valor del seno es:
"+Math.sin(angulo)+"nEl Valor del Coseno del angulo es:
"+Math.cos(angulo)+"nY
la tangente es:
"+Math.tan(angulo));
11
leer=JOptionPane.showInputDialog("Ingrese el valor, al cual le desea calcular la
raíz cuadrada:");
12
valor=Double.parseDouble(leer);
13
JOptionPane.showMessageDialog(null, "La
raíz cuadrada de: "+valor+" es:
"+Math.sqrt(valor));
14 }
15 }

Explicación:

Recuerde que, le método showInputDialog, devuelve
un tipo de dato String, es por esa razón que, siempre
debemos realizar el cambio al tipo
de dato que deseamos usar, en nuestro caso double. Además
que, para llamar los diferentes métodos
matemáticos, lo hacemos de la siguiente forma:

Math.nombre_de_metodo(parámetro);

Además que, en vez de realizar el cálculo y
la impresión en la misma línea (en el método
showMessageDialog), podríamos haber calculado los
respectivos valores por
separado, asignarlos a tres variables auxiliares, y mandar a
impresión esas variables.

4.5 Excepciones

Una excepción es una condición anormal que
surge en una secuencia de código durante la
ejecución. La gestión
de excepciones lleva a la gestión de errores en tiempo de
ejecución. Cuando surge una condición excepcional
se crea un objeto Exception.

El trabajo con
excepciones se realiza mediante las siguientes palabras
clave:

try Tiene el código de ejecución, si se
produce un error lanza (throw) una excepción que
será capturada.

catch Captura la excepción lanzada por try que
le precede. Puede capturar más de una excepción,
es decir que se pueden añadir.

finally La excepción es tratada en un gestor
por omisión.

SINTAXIS DE EXCEPCIONES:

try{
Bloque de código;
}
catch(TipoExcepcion1 e){
gestión de la excepción;
}
catch(TipoExcepcion2 e){
gestión de la excepción;
throw(e);
}
finally{}

Ejemplo 4.4

Supongamos que, una persona, desea
realizar una división entre cero:

1 public class
EjemploExcep{
2
public static void
main (String args[]){
3 try{
4 double
resul;
5
6
resul=27/0;
7
System.out.println("Resultado
es: "+resul);
8 }//fin del
try
9 catch (ArithmeticException
e){
10
System.out.println("Java,
lanza una excepción, ya que no puede realizar una
división entre cero");
11 }
12 }
13 }

A continuación mostramos una lista de las
excepciones lanzadas por Java:

Preguntas:

1. ¿Cuáles son las diferencias entre un
   objeto y una
   variable?____________________________________________________________________________________________________________________________________
2. ¿En que se diferencian las clases String y
   StringBuffer?_____________________________________________________________________________________________________________________
3. ¿Los métodos matemáticos,
   sólo pueden utilizarse con el tipo de dato
   double?¿Por
   qué?____________________________________________________________________________________________________________________________
4. ¿Por qué Java lanza una
   Excepción?______________________________________________________________________________________________________________________
5. try y finally. ¿Tienen la misma Función?________________________________________________________________________________________________________________________

Descubre el error

1. string b;
2. StringBuffer str= StringBuffer("Hola");
3. sqrt(g);
4. try{

…

}

catch{

…

}

Ejercicios

1. Cree un Applet que indique si una frase ingresada por
   el usuario, es palíndromos. Es decir que se lee de igual
   manera al derecho que al revés.
2. Se desea una aplicación en Java, que muestre
   la posición exacta que ocupa una letra, en una cadena
   que haya ingresado anteriormente.
3. Cree un Applet, en el cual, el usuario ingrese una
   cadena, con espacios en blanco, y luego se dibuje en el Applet,
   esa misma cadena pero sin espacios en Blanco.
4. Diseñe un programa que muestre diez
   números aleatorios, que se encuentren en el rango de 1 a
   10
5. Escriba un programa en Java, que dadas 5 notas de un
   alumno, muestre en pantalla, el promedio del alumno, pero
   redondeando la nota al entero más cercano.
6. Cree un Applet, que reciba dos números (a y
   b), y que muestre, cual de ellos es mayor, cual es menor, y
   ab y ba
7. En un banco, se desea
   calcular el interés
   que, recibirá un cliente al
   final del período por sus ahorros. La fórmula
   para determinar el interés es la siguiente: I=C*i*t.
   donde C, es el monto de los ahorros, i es la tasa de
   interés y t es el período te tiempo en
   días.

Capítulo V: Sentencias de
Control

Todo lenguaje de
programación cuenta (o al menos debería
contar), con una serie de iunstrucciones que, le permitan
controlar el flujo de ejecución de las instrucciones.
Afortunadamente Java posee dos grandes rubros de dichas
sentencias:

à Estructuras
Selectivas, en las cuales encontramos el if, elseif y switch.

à Estructuras
Repetitivas o Cilclos, entre las cuales están: while,
do… while y for.

0. 5.1 Estructuras Selectivas

En la vida, muchas veces, nos toca elegir entre un
camino y otro a seguir. En muchas de las actividades que
realizamos día con día, nos enfrentamos a
decisiones que debemos tomar y que, de una u otra forma,
alteran el cause normal de nuestra vida (o de nuestro
programa).

Sentencia if

La sentencia if (o si condicional), le permite a un
programa decidir, mediante la evaluación de una condición,
ejecutar una u otra acción o acciones.

La sintaxis General es La siguiente:

if(condicion1)

Accion1;

En donde:

Condición 1: Representa una expresión
que puede ser del tipo booleana.

Acción 1: es la acción que, al evaluar
la condición como verdadera, se
ejecutará.

Si son varias acciones, van entre llaves.

Ejemplo 5.1

Diseñe un programa en Java, que calcule, los
descuentos a un trabajador, sabiendo que, son aplicables, un
6.25% del salario en
AFP, sólo si éste es superior a $300.00;
Además que, si es un trabajador hombre, se
le descuenta, aparte del AFP, el 3% sobre el sueldo en concepto de
ISSS y 10% en concepto de Renta.

1 import javax.swing.*;
2 class Descuentos{
3 public static
void main (String args [])
{
4 String
datos;
5
int sexo;
6
double sueldo,
afp=0, isss, totalre, nsueldo, renta;
7
datos=JOptionPane.showInputDialog("Ingrese el sueldo del empleado
(a)");
8
sueldo=Double.parseDouble(datos);
9 if(sueldo>300)//Preuntamos si el sueldo es mayor a
300
10
afp=sueldo*0.0625;// si es mayor,
aplicamos descuento
11
JOptionPane.showMessageDialog(null, "Este
empleado tiene un sueldo de:
"+sueldo+" y El
descuento del AFP es: "+afp);
12
datos=JOptionPane.showInputDialog("Ingrese el Sexo: nSi es Masculino (1)nSi es
Femenino (2)");
13
sexo=Integer.parseInt(datos);
14 if(sexo==1)//Si es de sexo masculino
15 {
16
isss=sueldo*0.03;//aplicamos las
otras retenciones
17
renta=sueldo*0.10;
18
totalre=afp+isss+renta;
19
nsueldo=sueldo-totalre;
20
JOptionPane.showMessageDialog(null, "A
este empleado, se le retiene:
"+isss+" En concepto
de ISSSnAdemás Se le retiene:
"+renta+" En Concepto
de RentanLo que hace un total de:
"+totalre+"nY su
nuevo sueldo es:
"+nsueldo);
21
}//del
if
22
23
}//del
main
24
}// de la clase

En las sentencias if, podemos agregar la sentencia
else, la cual indica que, si al evaluar la condición,
ésta es falsa, entonces, realizará las acciones,
que estén después del else. La sintaxis es la
siguiente:

if(condición1)

{

Acciones;

}

else

{

Condiciones;

}

Ejemplo 5.2

Al ingresar la nota de un alumno, se desea saber si
éste aprobó o no, una materia en
el colegio. Se sabe que para aprobar, se necesita una nota
mayor o igual a 7.0. Diseñe una aplicación en
Java que, al ingresar la nota, muestre con un mensaje, si el
alumno, aprobó o no. Además se sabe que si la
nota está entre 6.50 y 6.99, tiene la posibilidad de
realizar un examen de suficiencia para aprobar.

1 import javax.swing.*;
2 public class
NotaAlum{
3
public static void
main (String args []){
4 String leer;
5 double Nota;
6
leer=JOptionPane.showInputDialog("Ingrese la nota del
alumno");
7
Nota=Double.parseDouble(leer);
8 if(Nota>=7.0)
9
JOptionPane.showMessageDialog(null, "El
alumno
APROBÓ!!!!!!");
10 else
11
{
12
JOptionPane.showMessageDialog(null, "El
alumno reprobó");
13 if(Nota>=6.5 &&
Nota<=6.99)
14
JOptionPane.showMessageDialog(null, "Pero
tiene la posibilidad de realizar el examen de
suficiencia");
15 }//del else
16
}//del
main
17
}//de la clase

Explicación:

En la línea 13, colocamos una condición
compuesta, es decir que, si el alumno alcanza una nota mayor o
igual a 6.5, pero menor a 7.0 (es decir 6.99), tiene la
posibilidad de realizar el examen.

Note además que, una estructura,
puede estar dentro de otra, lo que llamamos Anidamiento,
para el caso, el if de la línea 13, está dentro
del else, que inicia en la línea 10.

Sentencia elseif

Esta estructura, es una consecuencia c�de las
estructuras if anidadas, sus formato es el
siguiente:

if(condicion1)

Sentencia 1;

elseif(condicion2)

Sentencia 2;

elseif(condicion3)

Sentencia 3;

…

else

Sentencia n;

Funciona de la siguiente manera:

Se evalúa la primera condición, si
resulta verdadera se ejecuta la sentencia 1, y se
continúa con la ejecución del programa; de lo
contrario, de evalúa la condición 2, si resulta
verdadera, se ejecuta la sentencia 2, de lo contrario se
evalúa la condición 3 y así sucesivamente.
Si al evaluar todas las condiciones, ninguna resulta verdadera,
se ejecuta el bloque del else.

Ejemplo 5.3

Cree un Applet que, reciba como ingreso la nota de un
alumno y la clasifique, según la siguiente
tabla:

9. Excelente

7. Muy Bueno

5. Bueno

3. Regular

1. Necesita Mejorar

Cabe recalcar que dicha escuela,
maneja solamente notas cerradas, es decir, sin
decimales.

1 import javax.swing.*;
2 import java.awt.*;
3 public class
NotasAlumno extends
JApplet
4
{ //declaracion de
variables
5
String leer;
6
double
nota;
7
public void init()
8 {
9
leer=JOptionPane.showInputDialog("Ingrese La
Nota:");
10

nota=Double.parseDouble(leer);
11
}
12
public void paint(Graphics
g)
13
{
14
super.paint(g);
15
16 if(nota<=10 &&
nota>=9)
17
g.drawString("Excelente!!!!",
50,50);
18
else if(nota<=8 &&
nota>=7)
19
g.drawString("Muy
Bueno!!!!", 50,50);
20 else if(nota<=6 &&
nota>=5)
21
g.drawString("Bueno",
50,50);
22
else if(nota<=4 &&
nota>=3)
23
g.drawString("Regular",
50,50);
24
else if(nota<=2 &&
nota>=1)
25
g.drawString("Necesita
Mejorar…", 50,50);
26 else
27
g.drawString("Nota
Incorrecta!!!", 50,50);
28 }//del
paint
29
}// de la clase

Sentencia switch

Esta sentencia, permite ejecutar, una u otra u otra
acción, al evaluar una condición, cuyo resultado es
el que indica que bloque (o bloques) de instrucciones se van a
ejecutar.

Su sintaxis es la siguiente:

switch(expresión)

{

case 1:

Sentecia 1;

break;

case 2:

Sentecia 2;

break;

. . .

default:

Sentencias;

break;

}

En donde, expresión es una condición que,
al evaluarla, nos indicará que camino debemos seguir.
Además ésta puede ser, una expresión entera
char, byte, int y short. Además que, la expresión
constante que acompaña a la palabra reservada case
debe ser del mismo tipo que expresión. La
cláusula default es opcional y puede omitirse en los
programas que
desarrollemos.

Ejemplo 5.4

En una tienda, se realizan diferentes descuentos, a sus
clientes al
momento de cancelar en caja. Ya que, cuando se disponen a
cancelar tienen la oportunidad de sacar una bolita, y dependiendo
del color de la
misma, se le aplica su respectivo descuento. Si la bolita es
roja, se le aplica un 10% de descuento sobre la compra; si la
bola es verde, se le aplica un 5% de descuento, y si la bolita es
blanca, no se le aplica descuento alguno. Diseñe una
aplicación que de soporte a ésta actividad en el
súper mercado.

1 import javax. swing.*;
2 public class
SuperMercado
3
{
4 public static
void main (String args
[])
5 {
6 String aux;
7 int bolita;
8 double compra, descuento=0,
monto;
9
//leemos el import de la
compra
10
aux=JOptionPane.showInputDialog("Ingrese el importe de la compra:
");
11
compra=Double.parseDouble(aux);
12 //leemos
el color de la bolita
13
aux=JOptionPane.showInputDialog("Ingrese el color de la Bolita:nSi es Roja, ingrese
1nSi fue Verde, Ingrese 2nSi fue Blanca, ingrese
3");
14
bolita=Integer.parseInt(aux);
15 switch(bolita)
16 {
17 case 1:
18 {
19
descuento=compra*.10;
20
monto=compra-descuento;
21
22 }
23 break;
24 case 2:
25 {
26
descuento=compra*.05;
27
monto=compra-descuento;
28
29 }
30 break;
31 case 3:
32
monto=compra;
33
break;
34 default:
35
monto=compra;
36
break;
37 }//del
switch
38
JOptionPane.showMessageDialog(null, "El
cliente había consumido:
"+compra+" Pero
sacó una bolita color:
"+bolita+"nPor lo que
se aplicó un descuento de:
"+descuento+"nAhora el
saldo a cancelar es:
"+monto);
39
}//del
main
40
}// de la clase

0. Estructuras Iterativas

Introducción

Es muy común encontrar en los programas
operaciones que se deben ejecutar un número repetido de
veces en períodos más o menos espaciados. Si bien
las instrucciones son las mismas, los datos sobre los que operan
varían. A nuestro alrededor, encontramos problemas que
presentan esas características, por ejemplo: el
cálculo de la nota final de los estudiantes de Programación III, se realizará
tantas veces como alumnos hayan inscritos en dicha asignatura, el
cálculo del salario de los empleados de una empresa, etc.
En estos casos la solución que se diseñe para un
solo grupo de datos
se debe repetir tantas veces como sea necesario (de acuerdo al
número de estudiantes y de empleados para los ejemplos
anteriores).

Los cálculos simples o la manipulación de
pequeños conjuntos de
datos se pueden realizar fácilmente a mano, pero las
tareas grandes o repetitivas son realizadas con mayor eficacia por una
computadora,
ya que estas están especialmente preparadas para
ello.

Para repetir varias veces un proceso
determinado haremos uso de los ciclos repetitivos, a los cuales
se les conoce con el nombre de estructura repetitiva, estructura
iterativa, lazo o bucle.

En C, al igual que en Java podemos encontrar tres tipos
de ciclos:

• Entrada Asegurada (while)
• Ciclo Controlado Por Contador (for)
• Hacer Mientras (do.. while)

Funcionamiento de Un Ciclo

Un ciclo, funciona de la siguiente manera: Evalúa
una condición de resultar cierta, realiza una
acción o bloque de acciones, luego vuelve a evaluar la
condición y si nuevamente resulta cierta, realiza la (s)
acción (es). Cuando la condición de cómo
resultado falso, se sale del ciclo y continúa con la
ejecución normal del programa.

Acumulador:

Es una variable, que , como su nombre lo indica se
encarga de acumular valores. Esto se vuelve muy
útil, por ejemplo, cuando queremos encontrar la suma de
los números del 0 al 9, en el acumulador, vamos guardando
los valores de
dichas cifras. Puede ser tanto real como entera. Su valor
inicial, en la mayoría de los casos es cero.

Contador:

Es una variable de tipo entero, que nos ayuda, en el
programa a contabilizar el número de ejecuciones de una
misma acción, de un grupo de alumnos etc. Un acumulador
tiene tres valores distintos:

• Valor Inicial: es el valor con el cual iniciamos
  nuestro contador. Generalmente es cero. Esta asignación
  puede hacerse cuando se declara la variable.
• Valor Final: después de la ejecución
  del ciclo, el valor del contador, será distinto a su
  valor inicial, este puede ser mayo o menor que el mismo, todo
  depende si fue una cuenta creciente o decreciente.
• Valor de Cambio: Es el valor Constante, en el
  cual se irá incrementando nuestro contador, este puede
  ser positivo o negativo; es decir, si la cuanta se realiza de
  manera ascendente o descendente.

Bandera:

Las variables tipo bandera son aquellas que sólo
admiten dos valores: cierto o falso, true o false, hombre o
mujer…
etc

Ciclo de Entrada Asegurada

La sintaxis es la siguiente:

while(condición)

Acción;

Funciona de la siguiente manera: primero evalúa
la condición, si da como resultado cierta realiza la
acción, luego vuelve a evaluar la condición, si su
resultado es falso, se sale del ciclo y continúa con la
ejecución del programa. Hay que tener mucho cuidado,
cuando trabajamos con ciclos, ya que podemos caer en un ciclo
infinito, es decir que nunca se sale de él. Por lo cual en
las acciones debemos siempre colocar algo que haga que se
modifique el resultado de la condición, lo cual puede ser
una bandera, un contador o un acumulador.

Ejemplo 5.5

En una empresa, se desea
se tienen datos correspondientes a los sueldos de 10 empleados,
de los cuales, se desea saber, quien goza del sueldo mayor, quien
goza del sueldo menor y cuantos poseen un sueldo mayor a
$300.00

1 import javax.swing.*;
2 class
UsaWhile{
3
public static void
main (String args []){
4 String leer;
5 double
sueldo, mayor=0, menor=10000;
6 int i=1,
contador=0;
7
while(i<=10)
8 {
9
leer=JOptionPane.showInputDialog("Ingrese el sueldo del empleado:
"+i);
10
sueldo=Double.parseDouble(leer);
11 while(sueldo<0)//si el sueldo es negativo
12 {
13
leer=JOptionPane.showInputDialog("ERROR, el sueldo no puede ser NegativonIngrese el
sueldo del empleado: "+i);
14
sueldo=Double.parseDouble(leer);
15 }
16 if(sueldo>300)
17
contador=contador+1;
18 if(sueldo>mayor)
19 mayor=sueldo;
20 if(sueldo<menor)
21 menor=sueldo;
22 i=i+1;
23 }
24
JOptionPane.showMessageDialog(null, "El
sueldo mayor es de: "+mayor+"nEl sueldo menor es:
"+menor+"n"+contador+" Empleados tienen un sueldo mayor a
$300");
25
}
26
}

Ciclo Controlado por contador.

En algunas ocasiones, sabemos a ciencia cierta
el número de veces que se tiene que repetir una misma
acción o bloque de acciones. Y para ello es que nos sirve,
esta estructura. Su sintaxis es la siguiente:

for( valor inicial; condición;
incremento)

accion;

Donde:

Valor inicial: es el valor con el cual inicializamos
nuestra variable de control.

Condición: si la cumple, ejecuta la acción
o acciones e incrementa o decrementa la variable de control, sino
la cumple la condición, se sale del ciclo.

Incremento; que puede ser positivo o negativo
(decremento).

Ejemplo 5.6

Escriba un Applet que dibuje un rectángulo, unas
líneas u óvalos en base a la entrada del usuario.
(Tomado de cómo Programar en Java)

1 import java.awt.*;
2 import
javax.swing.*;
3
public class PruebaFor extends JApplet{
4 int
opcion; //la opcion del
usuario
5 public void
init ()
6
{
7 String
entrada;
8
//obtener la opcion del usuario
9
entrada=JOptionPane.showInputDialog("Escriba 1 para dibujer LineasnEscriba 2 para dibujar
rectangulosnEscriba 3 pàra dibujar
Ovalos");
10
opcion=Integer.parseInt(entrada);
11 }//fin del
metodo init
12
//dibujer figuras en el fondo
el Applet
13 public void
paint (Graphics g)
14 {
15 super.paint(g);
16 for(int i=0; i<10;
i++)
17
{
18 switch(opcion)
19 {
20 case
1://dibujar
lineas
21
g.drawLine(10,10,250,10+i*10);
22 break;
23 case
2://dibujar
rectangulos
24
g.drawRect(10+i*10,10+i*10,50+i*10,
50+i*10);
25 break;
26 case
3: //dibujar un
Ovalo
27
g.drawOval(10+i*10, 10+i*10, 50+i*10,
50+i*10);
28 break;
29 default: //Valor Incorrecto
30 g.drawString("Se escribió un valor Incorrecto",
10,20+i*15);
31
}//fin del
switch
32
}//fin del
for
33
}//fin del
paint
34
}//fin de la clase

Ciclo Do… while

Es te ciclo funciona de la siguiente manera, realiza la
acción o conjunto de acciones, luego evalúa una
condición de resultar cierta vuelve a realizar la/s
accion/es. Cuando sea falsa, se sale del ciclo.

Formato :

do {

sentencia;

.

.

} while(<expL>);

La diferencia fundamental, entre el ciclo while y
do…while, es que en este ultimo, las sentencias se
realizarán por lo menos una vez, en cambio, con while,
solo se cumplirán mientras se cumpla la
condición, lo cual puede ser nunca.

Ejemplo 5.7

Programa que suma los valores de n1, mientras estos no
sean mayores que 100

1 class fibo{
2 public
static void main(String
args[]){
3 int n1=0;
4 do{ n1++;
5
System.out.println(n1+"
");
6
}while(n1<100);
7 }
8 }

Preguntas

1. ¿Qué es, y cuales son los tipos de
   estructuras que Java
   soporta?_________________________________________________________________________________________________________________________
2. ¿Cuál es la diferencia entre la
   estructura while y
   do..while?_______________________________________________________________________________________________________________________
3. ¿Para que nos sirven las estructuras
   repetitivas en
   Java?____________________________________________________________________________________________________________________________
4. ¿En que se diferencian las variables de tipo
   acumulador con las de tipo
   contador?________________________________________________________________________________________________________________________
5. ¿Cuándo una condición se
   convierte en
   compuesta?_____________________________________________________________________________________________________________________

Ejercicios.

1. Diseñe Un Applet que dibuje tantas veces, como
   el usuario el usuario lo desee, un
   rectángulo.
2. Se necesita crear una aplicación en Java que le
   permita al usuario ingresar tantos dígitos, como
   éste quiera, para luego, imprimir el valor mayor, el
   valor menor, y el promedio de todos los valores que se
   introdujeron.

   *

   * *

   * * *

3. Se desea crear una aplicación (ya sea Applet o
   Windows)
   que permita visualizar la construcción de un triángulo, en
   pantalla. El usuario, deberá ingresar la cantidad de
   niveles que desea y el programa, mostrará el
   resultado. Ejemplo: 3 niveles

   -Listado de Niños que están aptos para jugar
   Basketball

   -Listado de Niñas que están aptas para
   jugar Basketball

   Los requisitos para ello, son los
   siguientes:

   Los niños deben tener un estatura mayor que
   1.70mts y pesar más de 150 lbs. Y las niñas
   deben ser mayores de 1.60 mts y pesar más de
   145lbs.

4. Diseñe Un programa, que, dados el peso, edad,
   nombre y estatura de un grupo de 30 alumnos, muestre los
   siguientes datos:
5. Diseñe un Applet que, muestre si un
   número es primo o no. Si es primo, se indicará
   dibujando una leyenda en el fondo del Applet, de lo contrario,
   se dibujarán todos los divisores de ese
   número.
6. El valor del seno de un ángulo x se puede
   aproximar sumando n términos de la serie: sin(x) = x –
   x^3/3! + x^5/5! – x^7/7! + … Escribir un programa que
   solicite n y un ángulo x e informe del
   valor aproximado de su seno.
7. En una empresa de telefonía local, se tiene la siguiente
   política: si el consumo
   mensual, de una determina familia, excede
   los 300 minutos, se le cobra $0.03 por cada minuto. Si excede
   los 500 minutos, se le cobran los primeros 300 minutos a
   precio
   normal y los restantes a $0.02. Pero si el consumo mensual, es
   superior a $800 minutos, se aplica la regla de
   asignación anterior, además que se le realiza un
   descuento de 1.25% del total. Diseñe una
   Aplicación en Java que de soporte a dicha
   política de cobro.
8. Escribir un programa en Java, que le permita al
   usuario ingresar las notas de cierta cantidad de alumnos, y que
   luego muestre la cantidad de aprobados (notas mayores o iguales
   a 6.00), la cantidad de reprobados, y las notas extremas.
   Así como los nombres de los alumnos que obtuvieron
   dichas notas.
9. Abarrotes, S.A. de C.V., desea tener un mayor
   control, sobre las venta sy las
   respectivas ganancias que realizan por día. Para lo
   cual, se le soliciota que escriba un programa en Java, que le
   permita contabilizar las ventas
   diarias, los importes totales de cada venta, la ganancia neta (
   que es de 10% de cada venta).