Java Teoría-ejercicios

2014

Aplicaciones resueltas

para fundamentar la

lógica de programación

Estefanía Sánchez

UNIVERSIDAD TÉCNICA DE AMBATO

1

Contenido INTRODUCCIÓN .............................................................................................................................2

JAVA .................................................................................................................................................3

ESTRUCTURA BÁSICA DE UNA APLICACIÓN SWING. .......................................................4

En las primeras líneas se importan los paquetes necesarios. .......................................................4

Principales aspectos de una aplicación Swing ............................................................................4

LA PLATAFORMA DE JAVA .....................................................................................................5

EL PROCESO DE EDICIÓN Y COMPILACIÓN ........................................................................8

LA CODIFICACIÓN DE PROGRAMAS JAVA ..........................................................................9

EL PROCESO DE DESARROLLO DE SOFTWARE ................................................................12

ESTRUCTURA DE UN PROGRAMA JAVA ............................................................................14

ESTRUCTURAS DE CONTROL................................................................................................15

ESTRUCTURA IF .......................................................................................................................16

ESTRUCTURA IF ELSE .............................................................................................................23

ESTRUCTURA SWITCH ...........................................................................................................30

El operador condicional ............................................................................................................43

ESTRUCTURAS DE REPETICIÓN ...........................................................................................44

ESTRUCTURA WHILE ..............................................................................................................31

ESTRUCTURA DO-WHILE .......................................................................................................32

ESTRUCTURA FOR ...................................................................................................................45

OPERADORES LÓGICOS .........................................................................................................45

DECLARACIÓN DE UNA CLASE Y DEFINICIÓN DE OBJETOS. ........................................90

2

INTRODUCCIÓN

Java es un lenguaje desarrollado por Sun con la intención de competir con Microsoft en

el mercado de la red. Sin embargo, su historia se remonta a la creación de una filial de

Sun (FirstPerson) enfocada al desarrollo de aplicaciones para electrodomésticos,

microondas, lavaplatos, televisiones... Esta filial desapareció tras un par de éxitos de

laboratorio y ningún desarrollo comercial.

Sin embargo, para el desarrollo en el laboratorio, uno de los trabajadores de FirstPerson,

James Gosling, desarrolló un lenguaje derivado de C++ que intentaba eliminar las

deficiencias del mismo. Llamó a ese lenguaje Oak. Cuando Sun abandonó el proyecto

de FirstPerson, se encontró con este lenguaje y, tras varias modificaciones (entre ellas la

del nombre), decidió lanzarlo al mercado en verano de 1995.

El éxito de Java reside en varias de sus características. Java es un lenguaje sencillo, o

todo lo sencillo que puede ser un lenguaje orientado a objetos, eliminando la mayor

parte de los problemas de C++, que aportó su granito (o tonelada) de arena a los

problemas de C. Es un lenguaje independiente de plataforma, por lo que un programa

hecho en Java se ejecutará igual en un PC con Windows que en una estación de trabajo

basada en Unix. También hay que destacar su seguridad, desarrollar programas que

accedan ilegalmente a la memoria o realizar caballos de troya es una tarea propia de

titanes.

Cabe mencionar también su capacidad multihilo, su robustez o lo integrado que tiene el

protocolo TCP/IP, lo que lo hace un lenguaje ideal para Internet. Pero es su sencillez,

portabilidad y seguridad lo que le han hecho un lenguaje de tanta importancia

3

JAVA Java es un lenguaje originalmente desarrollado por un grupo de ingenieros de Sun, utilizado

por Netscape.

Este lenguaje tiene las características de ser de propósito general, está basado en clases, y

es orientado a objetos.

Una de las mayores ventajas del lenguaje Java, es que es multiplataforma, es decir, que una

vez hecho el programa, lo podremos ejecutar bajo cualquier sistema, sin necesidad de

modificar nada.

Car

acte

ríst

icas

Gestiona la memoria automáticamente

Robusto

No permite el uso de técnicas de programación inadecuadas

Multithreading

Cliente-servidor

Mecanismos de seguridad incorporados

Herramientas de documentación incorporadas

4

ESTRUCTURA BÁSICA DE UNA APLICACIÓN SWING.

Una aplicación Swing se construye mezclando componentes con las siguientes reglas.

Debe existir, al menos, un contenedor de alto nivel (Top-Level Container), que

provee el soporte que las componentes Swing necesitan para el pintado y el manejo

de eventos.

Otras componentes colgando del contenedor de alto nivel (éstas pueden ser

contenedores o componentes simples).

En las primeras líneas se importan los paquetes necesarios.

import javax.swing.*;

import java.awt.*;

import java.awt.event.*;

Principales aspectos de una aplicación Swing

Como ya se dijo antes, cada aplicación Swing debe tener al menos un top-level

container que contendrá toda la aplicación, estos pueden ser:

javax.swing.JFrame: Una ventana independiente.

javax.swing.JApplet: Un applet.

Diálogos: ventanas de interacción sencilla con el usuario como por ejemplo:

java.swing.JOptionPane: Ventana de diálogo tipo SI_NO,

SI_NO_CANCELAR, ACEPTAR, etc...

java.swing.JFileChooser: Ventana para elejir un archivo.

java.swing.JColorChooser

5

EJERCICIO N.-1

ENUNCIADO:

Utilizando el lenguaje de programación orientado a objetos JAVA realizar una suma

ingresando dos números enteros desde teclado,

ANÁLISIS:

Este programa nos permite relizar la suma ded dos números ingresados por teclado

mediante la función JOptionPane.showInputDialog y luego la convertimos en dato en tero

con la función Integer.parseInt(); y realizamos la respectiva suma e imprimimos la

respuesta con la función JOptionPane.showMessageDialog(null," " + );

CODIFICACIÓN:

package sumadenumeros1;

import javax.swing.JOptionPane;

/**

*

* @author Lab03-PC02

*/

public class Sumadenumeros1 {

/**

* @param args the command line arguments

*/

public static void main(String[] args)

{

String dato1, dato2;

int num1, num2, num3;

dato1=JOptionPane.showInputDialog("Ingrese el dato 1..: ");

num1=Integer.parseInt(dato1);

dato2=JOptionPane.showInputDialog("Ingrese el dato 2..: ");


num3=num1+num2;

JOptionPane.showMessageDialog(null,"la suma es..: " + num3);

// TODO code application logic here

}

Nombre del programa o proyecto

Librería

Inicio del programa

Declaración de variables

de tipo carácter

Ingresamos el 1er

numero Ingresamos el 2do

numero

Operación para hacer la suma

Visualizamos el

resultado

6

}

CORRIDO DEL PROGRAMA

7

LA PLATAFORMA DE JAVA

Los programas Java se compilan a un lenguaje intermedio, denominado Bytecode. Este

código es interpretado por la máquina virtual de Java del entorno de ejecución (JRE) y así

se consigue la portabilidad en distintas plataformas. El JRE es una pieza intermedia entre el

código Bytecode y los distintos sistemas operativos existentes en el mercado.

Un programa Java compilado en Bytecode se puede ejecutar en sistemas operativos como

Windows, Linux, Mac Os, Solaris, BlackBerry OS, iOs o Android utilizando el entorno de

ejecución de Java (JRE) apropiado.

El siguiente esquema muestra los elementos de la plataforma Java, desde el código fuente,

el compilador, el API de Java, los programas compilados en Bytecode y el entorno de

ejecución de Java. Este entorno de ejecución (JRE) y la máquina virtual (JVM) permiten

que un programa compilado Java se ejecute en distintos sistemas operativos.

Código Fuente Java

Compilador Java

Programa java

compilado

(Bytecode)

Java API

Aplication

Programing

Interface

Java Runtime Environment (JRE)

Sistemas operativos (Windows, Linux, Mac Os, Solaris, entre otros)

Hardware (Sparc, Pentium, Power, entre otros)

8

EL PROCESO DE EDICIÓN Y COMPILACIÓN

En Java, al igual que en otros lenguajes de programación, se sigue el siguiente proceso:

edición del código fuente, compilación y ejecución. Los programas Java se desarrollan y se

compilan para obtener un código denominado Bytecode que es interpretado por una

máquina virtual de Java.

La edición del programa fuente se realiza escribiendo el programa Java en un editor de

texto como el Bloc de notas o utilizando un entorno integrado de desarrollo. El código

fuente se almacena en un fichero de tipo .java.

La compilación se realiza con el compilador Java javac o utilizando un entorno integrado

de desarrollo. Durante el proceso de compilación se verifica que el código fuente cumple la

definición léxica, sintáctica y semántica de Java. Esto significa que el compilador

comprueba que el código fuente se compone de palabras válidas en Java y que los

comandos Java tiene la forma sintáctica correcta. Si durante el proceso de compilación el

compilador detecta los errores que ha cometido el programador y le informa de los

problemas que ha encontrado para que pueda corregirlos. Si durante la compilación no se

detectan errores, se genera un fichero de tipo class en Bytecode. Una vez finalizado el

proceso de compilación se puede ejecutar el programa. Para esto, es necesario que la

máquina virtual de Java interprete el código Bytecode y ejecute la aplicación.

Código fuente Java

Compilador Java

Programa Java Compilado

(Bytecode)

9

EJERCICIO N.-2

ENUNCIADO:

Diseñar un programa en JAVA que me permita resolver las operaciones básicas.

ANÁLISIS:

Codificaremos un programa que realice las operaciones básicas (suma, resta, multiplicación, división), para lo cual en la suma y multiplicación no tendremos problema ya no importa si el primer término o el segundo término sea mayor o menor, a diferencia de la resta y la división que el primer término deberá ser mayor que el segundo, para esto utilizaremos un controlador en estos dos casos; y un suitch para una mejor presentación.

CÓDIGO:

package operacionesbasicas;


public class Operacionesbasicas {

public static void main(String[] args) {

String d1,d2,d3,d4,d5;

int op,n,m,a,b,c,op1;

do

{

d1=JOptionPane.showInputDialog("**OPERACIONES

BASICAS**"+"\n 1.-SUMA"+"\n 2.-RESTA"

+"\n 3.-MULTIPLICACION"+"\n 4.-DIVISION"+"\n 5.-SALIR");

op=Integer.parseInt(d1);

switch(op)

{

case 1:

d2=JOptionPane.showInputDialog("SUMA\n"+"INGRESE

EL PRIMER DATO : ");

n=Integer.parseInt(d2);

d3=JOptionPane.showInputDialog("INGRESE EL

SEGUNDO DATO : ");

m=Integer.parseInt(d3);

c=n+m;

JOptionPane.showMessageDialog(null,"RESPUESTA : "+c)

break;

Importación de librerías

del programa


Inicio del ciclo do

Impresión del Menú de

Opciones

Inicio del switc

Case 1 en este case

está el proceso para la

suma con

impresiones, proceso

y una última

impresión para el

resultado.

10

case 2:

d2=JOptionPane.showInputDialog("RESTA\n"

+"INGRESE EL PRIMER DATO : ");


do

{

d3=JOptionPane.showInputDialog("INGRESE EL

SEGUNDO DATO : ");


}while(n>m);

c=n-m;

JOptionPane.showMessageDialog(null,"RESPUESTA : "+c);

break;

case 3:

d2=JOptionPane.showInputDialog("MULTIPLICACION

\n"+"INGRESE EL PRIMER DATO : ");


d3=JOptionPane.showInputDialog("INGRESE EL SEGUNDO

DATO : ");


c=n*m;


break;

case 4:

d2=JOptionPane.showInputDialog("DIVICION\n"+"INGRESE

EL PRIMER DATO : ");


do

{

d3=JOptionPane.showInputDialog("INGRESE EL SEGUNDO

DATO : ");


}while(n>m);

c=n/m;


break;

}

d5=JOptionPane.showInputDialog("DESEA REPETIR

1 O 0 PARA SALIR: ");

op1=Integer.parseInt(d5);

Case 2 en este case


resta con impresiones,

proceso y una última

impresión para el

resultado. Con un

control de ingreso

Case 3 en este case


multiplicación con

impresiones, proceso

y una última

impresión para el

resultado

Case 4 en este

case está el

proceso para la

división con

impresiones,

proceso y una

última impresión

para el resultado.

Con un control

de datos

Fin del ciclo do

while

Case 1 en este case esta el proceso para la división con impresiones, proceso y una ultima impresión para el resultado. Con un control de

11

}while(op1==1);

}

}

CORRIDO:

Case 1 en este case esta el proceso para la división con impresiones, proceso y una ultima impresión para el resultado. Con un control de

Llaves de

finalización del

programa

12

LA CODIFICACIÓN DE PROGRAMAS JAVA

El estilo de programación o codificación de los programas Java es muy importante. La

legibilidad de un programa determina en buena medida que se haya desarrollado

correctamente y que el producto final sea eficiente.

Legibilidad.- Un programa Java debe ser fácil de leer y entender, incluso para una persona

que no ha participado en el desarrollo del programa. La legibilidad es un aspecto muy

importante porque facilita el mantenimiento del software, la corrección de errores o la

modificación de la funcionalidad de la aplicación con menor coste.

Corrección.- Un programa debe hacer lo que debe hacer, ni más, ni menos.Esto es lo que

se entiende por corrección. Un programa debe cumplir rigurosamente los requisitos

funcionales y técnicos de la fase de especificación. Durante la fase de prueba se verifica

que el programa funciona correctamente y que cumple los requisitos técnicos y funcionales.

Eficiencia.- La eficiencia se refiere al tiempo que un programa tarda en ejecutarse y a los

recursos que consume. Cuanto más rápido sea un programa y utilice menos memoria o

disco duro, el diseño es mejor. La eficiencia no es un problema que deba atender cuando se

aprende a programar. Ahora lo mejor es utilizar los mecanismos de optimización propios de

los compiladores. La eficiencia se debe analizar solo cuando un programa funciona

correctamente y cumple con los requisitos técnicos definidos.

EL PROCESO DE DESARROLLO DE SOFTWARE

El proceso de desarrollo de los programas Java no difiere de la mayoría de los lenguajes de

programación. Es necesario seguir un conjunto de pasos para desarrollar correctamente un

producto software.

La Ingeniería del Software estudia los distintos procesos de desarrollo de software. El IEEE

define Ingeniería del Software como la aplicación sistemática, disciplinada y cuantificable

de un proceso de desarrollo, operación y mantenimiento de un producto software.

Legibilidad Corrección Eficiencia

13

El proceso clásico de desarrollo de software es ampliamente utilizado por su sencillez. Este

proceso se compone de las siguientes fases: especificación, diseño, codificación, prueba y

mantenimiento.

Especificación.- En esta fase se decide la funcionalidad, las características técnicas de una

aplicación y sus condiciones de uso. En esta fase es necesario responder a las siguientes

preguntas:

¿Para qué se va a utilizar la aplicación?

¿Cuáles son las necesidades funcionales de los usuarios?

¿Cuál es el perfil de los usuarios de la aplicación?

¿En qué plataforma se ejecutará la aplicación?

¿Cuáles son sus condiciones de operación?

¿Cómo se va a utilizar?

Diseño.- En esta fase se utiliza toda la información recogida en la fase de especificación y

se propone una solución que responda a las necesidades del usuario y se pueda desarrollar.

14

En esta fase se define la arquitectura de la aplicación. Es necesario detallar la estructura y la

organización del programa y cómo se relacionan las distintas partes de la aplicación.

Codificación.- Esta fase consiste en la programación en Java de las especificaciones de

diseño de la fase anterior. Durante esta fase de codificación o implementación se aplican

normas de programación para facilitar la legibilidad de los programas Java.

Prueba.- En esta fase se compila y se ejecuta la aplicación para verificar que cumple con

los requisitos funcionales y técnicos definidos en la fase de especificación. Si el programa

no cumple con todos los requisitos, se puede deber a errores de diseño o de programación.

En tal caso, es necesario corregir los errores que se hayan detectado y repetir de nuevo el

proceso de diseño y codificación. Durante la fase de prueba se verifica que la aplicación

cumple con los criterios de calidad establecidos en el proyecto: facilidad de uso, corrección,

eficiencia, integridad, fiabilidad, flexibilidad, facilidad de mantenimiento, facilidad de

prueba, portabilidad, capacidad de reutilización e interoperabilidad.

Una vez que la aplicación se ha probado y cumple con los requisitos establecidos, entonces

se pone en funcionamiento y comienza la fase de operación para que sea utilizada para el

fin con el que ha sido desarrollada.

Mantenimiento.- Una vez que la aplicación se ha puesto en operación da comienzo la fase

de mantenimiento. En esta fase se corrigen errores de funcionamiento de la aplicación, se

modifica la funcionalidad o se añaden las nuevas funcionalidades que demandan los

usuarios. La fase de mantenimiento es la de mayor duración, pues pueden pasar muchos

años desde el inicio de la operación hasta que el producto es retirado.

ESTRUCTURA DE UN PROGRAMA JAVA

Un programa describe cómo un ordenador debe interpretar las órdenes del programador

para que ejecute y realice las instrucciones dadas tal como están escritas. Un programador

utiliza los elementos que ofrece un lenguaje de programación para diseñar programas que

resuelvan problemas concretos o realicen acciones bien definidas.

El siguiente programa Java muestra un mensaje de texto“Hola Amigos”.

package mensaje;


public class mensaje {

/**

* @param args the command line arguments

15

*/


{

JOptionPane.showMessageDialog(null, "Hola Amigos");

}

}

ESTRUCTURAS DE CONTROL

El cuerpo de un programa se compone de un conjunto de sentencias que especifican las

acciones que se realizan durante su ejecución. Dentro de cualquier programa, se escriben

sentencias que definen la secuencia de acciones a ejecutar. Estas sentencias incluyen

acciones de cálculo, entrada y salida de datos, almacenamiento de datos, etc. Las sentencias

se ejecutan una a una en el orden en el que han sido escritas.

Se denomina flujo de un programa al orden de ejecución de las sentencias que forman parte

del cuerpo de un programa. Las estructuras de control son una característica básica de los

lenguajes que se utiliza para modificar el flujo de un programa.

Hay casos en los que el flujo de un programa debe ejecutar determinadas instrucciones solo

cuando se cumple una condición. En otras ocasiones, debe repetir un conjunto de sentencias

un número determinado de veces.

Las estructuras de control permiten condicionar el flujo de ejecución dependiendo del

estado de las variables de un programa.

Las estructuras de control básicas se pueden clasificar en estructuras de selección, de

repetición y de salto.

Selección. Permiten decidir si se ejecuta un bloque de sentencias o no.

Repetición. Permiten ejecutar un bloque de sentencias muchas veces.

Salto. Permiten dar un salto y continuar la ejecución de un programa en un punto distinto

de la siguiente sentencia en el orden natural de ejecución.

16

EJERCICIO N.-3

ENUNCIADO:

Diseñe un programa que me permita ingresar los datos correspondientes para

obtener el área y el perímetro de las 4 figuras básicas.

ANÁLISIS

Para calcular el área del cuadrado solo debo ingresar un lado y multiplicarlo

(área=l*l) mientras que para el perímetro lo sumo cuatro veces (perímetro=l+l+l+l).

Para el rectángulo, calcular el área es muy simple, solo debo multiplicar la base

por su altura, para el perímetro debo en cambio sumar todos sus cuatro lados.

Para calcular el área del triángulo debemos multiplicar la base por su altura

dividido para 2, para calcular el perímetro debemos sumar todos sus tres lados.

Ahora para el círculo solo hace falta ingresar el radio (el perímetro es el doble del

radio), su perímetro se calcula multiplicando el diámetro por pi (PI 3.14159265) y

el área se encuentra multiplicando pi por radio al cuadrado.

DOCUMENTACIÓN

package fig_bas;


import fig_bas.figuras;

public class Fig_bas {


{

String opc;

int menu, cua, rect, circ, trian;

opc=JOptionPane.showInputDialog("FIGURAS BÁSICAS

\n\n1.- Cuadrado \n2.- Rectángulo \n3.- Círculo

\n4.- Triángulo

\n5.- Salir \n\nQue desea realizar");

menu=Integer.parseInt(opc);

switch(menu)


del programa

Inicio del programa

principal

Declaración de

variables

Menú de opciones

Inicio del menú de

opciones

17

{

case 1:

cua=figuras.cuadrado();

break;

case 2:

rect=figuras.rectandulo();

break;

case 3:

circ=figuras.circulo();

break;

case 4:

trian=figuras.triangulo();

break;

case 5:

System.exit(0);

break;

}

}

}

package fig_bas;


public class figuras

{

public static int cuadrado()

{

String lado;

int l, per, ar;

lado=JOptionPane.showInputDialog("Ingrese el

lado del cuadrado: ");

l=Integer.parseInt(lado);

per=l*4;

ar=l*l;

JOptionPane.showMessageDialog(null, "PERIMETRO

DEL CUADRADO= " + per);

JOptionPane.showMessageDialog(null, "ÁREA DEL

CUADRADO= " + ar);

return 0;

Case 1: para encontrar el

perímetro y el área de un

cuadrado

Case 2: para encontrar el perímetro y el área de un

rectángulo


círculo


triángulo

Case 1: para encontrar el perímetro y el salir del

menú

Clase (subprograma) para

calcular el perímetro y el

área de un cuadrado.

Inicio para crear

clases.

18

}

public static int rectandulo()

{

String lado1, lado2;

int l1, l2, ar, per;

lado1=JOptionPane.showInputDialog("Ingrese la base

del rectángulo");

l1=Integer.parseInt(lado1);

lado2=JOptionPane.showInputDialog("Ingrese la altura

del rectángulo");


per=l1*2+l2*2;

ar=l1*l2;


DEL RECTÁNGULO= " + per);


RECTÁNGULO= " + ar);

return 0;

}

public static int circulo()

{

String radio;

int r;

double pi, ar, per;

radio=JOptionPane.showInputDialog("Ingrese el radio

del círculo");

r=Integer.parseInt(radio);

pi=3.1416;

ar=pi*r*r;

per=2*pi*r;

JOptionPane.showMessageDialog(null, "ÁREAL DEL

CÍRCULO= " + ar);


DEL CÍRCULO= " + per);

return 0;

}



área de un rectángulo.



área de un círculo.

19

public static int triangulo()

{

String lado1, lado2, lado3;

int l1, l2, l3, per, ar;

lado1=JOptionPane.showInputDialog("Ingrese la base

del triángulo");


lado2=JOptionPane.showInputDialog("Ingrese la altura

del triángulo");


lado3=JOptionPane.showInputDialog("Ingrese el lado

restante del triángulo");


per=l1+l2+l3;

ar=(l1*l2)/2;


DEL TRIÁNGULO= " + per);


TRIÁNGULO= " + ar);

return 0;

}

}

CORRIDO DEL PROGRAMA.



área de un triángulo.

21

EJERCICIO N.-4

ENUNCIADO

Diseñe un programa que me permita realizar la potenciación y radicación.

ANALISIS

En este programa podemos realizar la potenciación y la radicación; para la

potenciación debemos declarar los variables de tipo carácter y de tipo enteras,

luego ingresamos la base y el exponente por teclado; por ultimo realizamos el

proceso de Math.pow(base, expo); para que se pueda realizar la potenciación,

por ultimo visualizamos la respuesta.

Para la radicación primero ingresamos un numero para poder realizar la

radicación, luego ingresamos la formula Math.sqrt(radicando); para que se

pueda realizar la radicación, por ultimo visualizamos la respuesta.

CODIGO

package poteyradi;


public class PoteyRadi {


{

String dato1, dato2;

double base, expo, resp;

JOptionPane.showMessageDialog(null,"Potenciacion");

dato1=JOptionPane.showInputDialog("Ingrese una base: ");

base=Integer.parseInt(dato1);

dato2=JOptionPane.showInputDialog("Ingrese el exponente: ");

expo=Integer.parseInt(dato2);

resp=Math.pow(base, expo);

JOptionPane.showMessageDialog(null, "El resultado es: "+resp);

JOptionPane.showMessageDialog(null,"Radicación");

double radicando, raiz;

dato1=JOptionPane.showInputDialog("Ingrese un indice: ");

radicando=Integer.parseInt(dato1);

raiz=Math.sqrt(radicando);

JOptionPane.showConfirmDialog(null,"La raiz es: "+raiz);

}}

Nombre del programa o

proyecto Librerí

a

Inicio del

programa Declaración de variables

de tipo caracter Declaración de variables de tipo

doble Ingresamos la base

de la potenciación

Ingresamos el exponente

Formula o proceso para poder realizar la potenciación

Visualizamos el resultado

Ingresamos el

índice de la raíz

Formula o proceso para poder realizar la radicación

Visualizamos el resultado

22

CORRIDO

23

ESTRUCTURA IF

La estructura if se denomina estructura de selección única porque ejecuta un bloque de

sentencias solo cuando se cumple la condición del if. Si la condición es verdadera se

ejecuta el bloque de sentencias. Si la condición es falsa, el flujo del programa continúa en la

sentencia inmediatamente posterior al if .Una sentencia if tiene la siguiente sintaxis:

if (condicion) {

bloque-de-sentencias

}

La condición es una expresión que evalúa un valor lógico, por lo que el resultado solo

puede ser true o false. La condición siempre se escribe entre paréntesis. La selección se

produce sobre el bloque de sentencias delimitado por llaves. Si el bloque de sentencias solo

tiene una sentencia, entonces se puede escribir sin las llaves, como se muestra a

continuación.

if (condicion) sentencia;

Cuando el flujo de un programa llega a una estructura if, se evalúa la condición y el bloque

de instrucciones se ejecuta si el valor de la condición es true. Si la condición es false,

entonces se ejecuta la sentencia inmediatamente posterior al if.

ESTRUCTURA IF ELSE

La estructura if-else se denomina de selección doble porque selecciona entre dos bloques de

sentencias mutuamente excluyentes. Si se cumple la condición, se ejecuta el bloque de

sentencias asociado al if. Si la condición no se cumple, entonces se ejecuta el bloque de

sentencias asociado al else.

Una sentencia if-else tiene la siguiente sintaxis:

if (condicion) {

bloque-de-sentencias-if

}

else {

bloque-de-sentencias-else

}

Al igual que en el if, la condición se debe escribir entre paréntesis. La selección depende

del resultado de evaluar la condición. Si el resultado es true, se ejecuta el bloque de

sentencias del if, en cualquier otro caso se ejecuta el bloque de instrucciones del else.

Después de ejecutar el bloque de sentencias se ejecuta la sentencia inmediatamente

posterior al if-else.

24

EJERCICIO N.-5

ENUNCIADO:

Diseñe un programa que me permita ingresar un número entero desde teclado y verificar si

el número es par o impar.

ANALISIS:

Utilizamos un if para indicar la condición en donde preguntamos si el numero ingresado

nos da igual a cero entonces imprimimos que es para caso contrario se imprime que el

número es impar, también se utiliza otro if y un do while para indicar el rango en el que

queremos que se encuentren los números ingresados por el usuario, y finalmente un

sentencia do while para que el programa se repita tantas veces desee el programador.

DOCUMENTACION

package par.impar;


public class PARIMPAR {

@SuppressWarnings("empty-statement")


{

String dato1,dato2;

int num1,num2;

do

{

do

{

dato1=JOptionPane.showInputDialog("INGRESE EL NUMERO ");


if(num1<6 ||num1>65)

Declaración de las variables tanto String

como enteras.

Sentencia repetitiva que en este caso se

utiliza para repetir el programa las veces

que desee el usuario.

Este do while lo utilizamos para validar

datos.

Pedimos que ingrese el número.

Utilizamos la condición if para

validar los datos.

Importación de librerías al programa

Paquete del programa.

25

{

JOptionPane.showMessageDialog(null,"EL NUMERO "+num1+" NO ESTA DENTRO

DEL RANGO");

}

}

while(num1<6 || num1>65);

if(num1%2==0)

{

JOptionPane.showMessageDialog(null,"EL NUMERO "+num1+" ES PAR ");

}

else

{

JOptionPane.showMessageDialog(null,"EL NUMERO "+ num1+" ES IMPAR ");

}

dato2=JOptionPane.showInputDialog("PRESIONE 1 PARA SALIR 0 PARA

VOLVER");


}

while(num2==1);

}

}

Si la condición no se cumple indicamos un mensaje entonces pedimos

que ingrese otro número y cerramos la condición if.

Cerramos la sentencia do while e indicamos el rango que

queremos en el que se encuentre los números.

Utilizamos la condición if para determinar si es para o impar.

Si la condición se cumple imprimimos que es par y cerramos las llaves.

Caso contrario, abrimos llaves.

Se imprime que es impar y cierra las llaves.

Escribimos un mensaje para repetir o no el programa.

Se cierra la sentencia do while que permite repetir el proceso

varias veces.

Cierra completamente el programa.

26

CORRIDO

27

EJERCICIO N.-6

ENUNCIADO:

Diseñe un programa que me permita ingresar 3 valores flotantes desde teclado que estén

entre 1 y 10, obtenga el promedio correspondiente y determine su equivalencia: aprobado,

reprobado y suspenso

Si el promedio es > = 7 Aprobado

Si el promedio es > 5 y < 7 Suspenso

Si el promedio es < = 5 Reprobado

ANALISIS:

Debemos llamar a las librerías para que se habilite procesos propios del programa, luego

ingresaremos los datos como: nombre, materia, y las tres notas las cuales son validadas que

deben estar entre uno y diez ;para lo cual utilizaremos un do While y una condición si nos

cumple pondremos un mensaje para que ingrese nuevamente la nota.

Después haremos los cálculos y si la nota es mayor de siete aprobara e imprimirá el nombre

su promedio y la materia.

Si su nota es menor de siete y mayor que cinco se queda a suspenso e imprimirá el nombre

su promedio y la materia.

Si la nota es menor que cinco pues reprobara la materia e imprimirá el nombre su promedio

y la materia

Y por último utilizaremos otro do While para repetir el proceso las veces que el usuario

desee.

CODIFICACION:

package prom

ediovalidacion;


public class Promediovalidacion {


{


del programa

28

String dato1, dato2,dato3,dato4, nom, mat;

float num, nombre, materia, nota1, nota2, nota3,pro;

int op;

do {

nom=JOptionPane.showInputDialog("INGRESE EL NOMBRE:");

mat=JOptionPane.showInputDialog("INGRESE EL MATERIA:");

do {

dato1= JOptionPane.showInputDialog("INGRESE LA NOTA1:");

nota1= Float.parseFloat(dato1);

if(nota1<1||nota1>11) {

JOptionPane.showInputDialog("VALOR INCORRECTO:");

} }

while(nota1<1||nota1>11);

do {





} }


do {




Ingreso de variables

Ingreso de datos

nombre y materia

del estudiante

Ingreso de la

primera nota

Condición de la nota ingresada

mensaje

Ingreso de la segunda

nota

Validación de la nota entre 1 y 10

mensaje

Condición de la nota ingresada


Ingreso de la tercera

nota

mensaje

29


} }


pro= (nota1+nota2+nota3)/3;

JOptionPane.showMessageDialog(null,"EL PROMEDIO ES:"+pro );

if(pro>=7) {

JOptionPane.showMessageDialog(null, " ... APROBADO ...");

JOptionPane.showMessageDialog(null, "EL ESTUDIANTE: "+nom );

JOptionPane.showMessageDialog(null, "ESTA APROBADO CON: "+pro );

JOptionPane.showMessageDialog(null, "EN LA MATERIA DE: "+mat );

}

else { if(pro>=5&&pro<7) {

JOptionPane.showMessageDialog(null, "... SUSPENSO ...");


JOptionPane.showMessageDialog(null, "ESTA SUSPENSO CON: "+pro );


}

else {

JOptionPane.showMessageDialog(null, "... REPROBADO ...");


JOptionPane.showMessageDialog(null, "ESTA REPROBADO CON: "+pro );


} }

dato4= JOptionPane.showInputDialog("CONTINUAR1 TERMINAR 0:");

op= Integer.parseInt(dato4);


Procesos promedio de notas

Impresión de

datos de

aprobado:

Nombre

Promedio

Materia

Condición de la nota >7

Impresión de

datos de

suspenso:

Nombre

Promedio

Materia

Impresión de

datos de

reprobado:

Nombre

Promedio

Materia Ciclo

repetitivo n

veces para el

proceso.

30

} while(op==1); }

EJECUCION:

31

ESTRUCTURA WHILE

La estructura de repetición while repite el bloque de sentencias mientras la condición del

while es verdadera.

El diagrama de flujo de una estructura while muestra que la condición se verifica justo

después de inicializar la variable de control. Si el resultado de evaluar la condición por

primera es falso, entonces no se ejecuta el bloque de sentencias.

no si

Un While tiene la siguiente sintaxis: inicialización;

while (condición) {

bloque-de-sentencias;

actualizacion;

}

Esta es la sintaxis general. La condición del while se escribe obligatoriamente entre

paréntesis.

Un while no necesariamente requiere inicialización y actualización de una variable de

control. En ese caso solo es necesario incluir la condición y el bloque de sentencias:

while (condición) {


}

Inicio

Inicialización de la

variable de control

Condición Fin

Actualización de lo

variable de control

Bloque de sentencias

32

ESTRUCTURA DO-WHILE

La estructura de repetición do-while ejecuta el bloque de sentencias al menos una vez.

Después comprueba la condición y repite el bloque de sentencias mientras la condición es

verdadera.

El diagrama de flujo de una estructura do-while muestra que la condición se verifica al

final, después de ejecutar el bloque de sentencias la primera vez.

no si

Un do-whiletiene la siguiente sintaxis: inicialización;

do {


actualizacion;

} while (condición);

Inicio


variable de control

Condición Fin


variable de control


33

EJERCICIO N.-7

ENUNCIADO

Diseñe un programa que me permita ingresar desde teclado un límite y un factor

cualquiera y generar las tablas de multiplicar.

Análisis:

En este programa podemos realizar las tablas de multiplicar; debemos declarar los

variables de tipo enteras, luego ingresamos el límite y el factor, por ultimo

visualizamos la respuesta.

CÓDIGO

public class Tabla {


String dato1,dato2,dato3,dato4;

int limite,factor,i,mult,op=0,opci,a,b,c,factorial;

do

{

JOptionPane.showMessageDialog(null, "

<< SERIE DE DATOS >> \n" + "TABLA DE MULTIPLICAR");

dato1=JOptionPane.showInputDialog("INGRESE EL LIMITE:");

limite=Integer.parseInt(dato1);

dato2=JOptionPane.showInputDialog("INGRESE EL FACTOR:");

factor=Integer.parseInt(dato2);

for(i=1;i<=limite;i++)

{

mult=i*factor;

JOptionPane.showMessageDialog(null, "


Proceso de

multiplicación e

impresión de

resultado

Declaración de variables String,

int

Ingreso de Datos

Inicio del ciclo do-while

34

LA TABLA DE MULTIPLICAR ES: \n" + factor + "*" + i + " = " + mult);

}

dato3=JOptionPane.showInputDialog("

PULSE 1 PARA CONTINUAR O 0 PARA SALIR ");

op=Integer.parseInt(dato3);

}

while(op==1);

}

}

CORRIDO

Fin del ciclo do-while

35

EJERCICIO N.-8

Enunciado

Diseñe un programa que me permita resolver un sistema de Ecuación de Segundo

Grado (ax^2 + bx +c)

Análisis

En este programa podemos realizar la Ecuación de Segundo Grado donde debemos

importar la librería principal que es import javax.swing.JOptionPane; para este

programa debemos declarar los variables de tipo double, carácter y de tipo enteras,

luego ingresamos los tres valores posteriormente realizamos el proceso para poder

sacar la ecuación para esto debemos utilizar la formula Math.sqrt para poder sacar

la raíz cuadrada y por ultimo preguntamos si el usuario desea realizar nuevamente

otros procesos o si desea salir

Documentación

package ecuacion;


public class Ecuacion {


String dato2;

int op ;

do

{

JOptionPane.showMessageDialog

Nombre del proyecto

Librería

Inicio del

programa

Declaración

de variables

Proceso de

repetición

Impresión de un

mensaje

36

(null,"ECUACION DE SEGUNDO GRADO" );

double a = Double.parseDouble

(JOptionPane.showInputDialog

("Ingrese el primer valor de a: "));

double b = Double.parseDouble


("Ingrese el segundo valor de b: "));

double c = Double.parseDouble


("Ingrese el tercer valor de c: "));

double interno=b*b-(4*a*c);

if (interno==0){

double x1=-b/(2*a);


(null, "Existe un valor doble: " + x1 ) ;

}

else

if(interno>0)

{

interno = Math.sqrt(interno);

x1=(-b+interno)/(2*a);

x2=(-b-interno)/(2*a);


Ingresamos los tres

valores

Realizamos el

proceso para sacar la

ecuación

Este es el proceso para

sacar la raíz cuadrada

de la ecuación

37

(null, "valor de x1 y x2: " + x1 +" \n"+x2 );

x1=-b/(2*a);

double resultado= Math.sqrt((-interno/(2*a)));


(null, "La raiz es imaginaria y vale: " + x1 +"

+"+ resultado + "i"+x1+"-"+resultado +"i" );

dato2= JOptionPane.showInputDialog

("Ingrese 1 para continuar y 0 pasa salir");

op= Integer.parseInt(dato2);

}

while(op==1);

}

}

}

Visualizamos el

resultado

Proceso para que el

usuario realice otro

proceso o si desea salir

38

Corrido

39

EJERCICIO N.-9

Enunciado

Diseñe un programa que me permita calcular el valor total a pagar por consumo de energía

eléctrica considerando los siguientes parámetros, se leen el valor anterior y el valor actual

de consumo, en donde siempre el valor actual debe ser mayor al valor anterior.

La diferencia entre los dos valores se devuelve el consumo actual. El costo por vatio es

$0,49

Existen 3 impuestos que se deben facturar:

3% Correspondiente a Bomberos

4% Correspondiente a taza municipal

2% otros

Visualice subtotales parciales u e total a pagar en una sola ventana

ANALISIS:

1. Importación de bibliotecas principales que utilizaremos (import

javax.swing.JOptionPane; e importjava.text.DecimalFormat;).

2. Debemos declarar las variables String, double y formato para decimales.

3. Inicialización de ciclo do while para que el programa se repita n veces.

4. Ingreso del valor anterior e inicialización del ciclo do while.

5. Ingreso del valor actual, fin ciclo do while y validación del valor anterior debe ser

mayor que el valor actual.

6. Obtención de los impuestos de bomberos, taza municipal y otros los mismos que su

porcentaje será multiplicado y dividido para 100.

7. Impresión en una sola pantalla del consumo actual, anterior, real , costo, valor del

consumo e impuestos de bomberos, taza municipal, otros y finalmente el total a

pagar ,

8. Finalización del ciclo do while principal y preguntamos si el usuario desea realizar

nuevamente otros procesos o si desea salir.

40

DOCUMENTACION:

packageplanilla.de.luz;

importjava.text.DecimalFormat;

importjavax.swing.JOptionPane;

public static void main (String[] args)

{

String dato1, dato2, dato4;

double valor1, valor2, dif, cost,bomb,tasa,otros,tot,op ;

DecimalFormat f = new DecimalFormat ("00.00");

DecimalFormat g = new DecimalFormat ("0.00");

do

{

JOptionPane.showMessageDialog (null," << PLANILLA DE LUZ >> ");

dato1=JOptionPane.showInputDialog (" INGRESE EL VALOR ANTERIOR: ");

valor1=Integer.parseInt (dato1);

do

{

dato2=JOptionPane.showInputDialog ("<< INGRESE EL VALOR ACTUAL: ");

valor2=Integer.parseInt (dato2);

}

While (valor1>valor2);

Dif =valor2-valor1;

Cost=dif*0.89;

Bomb= (cost*3)/100;

Tasa= (cost*4)/100;

Paquetes del programa

Importación de

librerías del programa


String y double

Impresión de

titulo

Escaneo del

primer

valor

Escaneo del

segundo

valor

Inicio del ciclo do while

Validación del valor 1 y valor 2

Procesos para operaciones

Instrucción formato para

decimales

Inicio ciclo do while principal

41

Otros = (cost*2)/100;

Tot=cost+bomb+tasa+otros;

JOptionPane.showMessageDialog (null," CONSUMO ANTERIOR: "

+valor1+"\n CONSUMO ACTUAL: "

+valor2+ "\n CONSUMO REAL: "

+ dif + "\n COSTO: 0.89”

+ "\n << VALOR CONSUMO: "

+ f.format (cost) +"\n BOMBEROS (3%): "

+g.format (bomb) +"\n TASA MUN (4%): "

+g.format (tasa)+"\n OTROS (2%): "

+g.format (otros)+"\n << TOTAL A PAGAR: "

+f.format (tot);

dato4=JOptionPane.showInputDialog ("PULSE 1 PARA CONTINUAR O 0 PARA SALIR

");

Op=Integer.parseInt (dato4);

}

While (op==1);

}

}

Impresión de

resultados

Escaneo de

opción para

repetición del

proceso

Fin ciclo do while validado a 1

Fin del programa

42

CORRIDO DEL PROGRAMA

43

ESTRUCTURA SWITCH

La estructura switch es una estructura de selección múltiple que permite seleccionar un

bloque de sentencias entre varios casos. En cierto modo, es parecido a una estructura de if-

else anidados. La diferencia está en que la selección del bloque de sentencias depende de la

evaluación de una expresión que se compara por igualdad con cada uno de los casos. La

estructura switch consta de una expresión y una serie de etiquetas case y una opción

default. La sentencia break indica el final de la ejecución del switch.

Una sentencia switch tiene la siguiente sintaxis:

switch (expresion) {

case valor-1:

bloque-de-sentencias-1;

break;

case valor-2:


break;

case valor-3:


break;

case valor-4:


break;

case valor-5:


break;

default:

bloque-de-sentencias-default;

break;

}

El operador condicional

El operador condicional (?:) se relaciona con la estructura if-else. Es el único operador de

Java que utiliza tres operandos. El primer operando es una condición lógica, el segundo es

el valor que toma la expresión cuando la condición es true y el tercero es el valor que toma

la expresión cuando la condición es false.

El operador evalúa la condición delante del símbolo ?, que puede escribirse entre

paréntesis. Si vale true devuelve el valor que aparece a continuación del signo ?. Si es false

devuelve el valor que aparece a continuación de los dos puntos.

El operador condicional tiene la siguiente sintaxis:

44

condicion-logica ? valor-si-verdadero : valor-si-falso;

La condición lógica también se puede expresar entre paréntesis:

(condicion-logica)? valor-si-verdadero : valor-si-falso;

Después de evaluar la condición lógica, se devuelve el valor correspondiente al resultado

lógico verdadero o falso. Por ejemplo, dada la edad de una persona, se desea mostrar un

mensaje por la consola que indique si es mayor de edad o no.

int edad = 16;

String txt;

txt = (edad >= 18) ? "Mayor de edad" : "Menor de edad";

System.out.print(txt);

La condición lógica es edad mayor o igual a 18 años. Si es verdadera, el operador devuelve

el texto “Mayor de edad”, en caso contrario devuelve “Menor de edad”.

En este ejemplo la variable edad se inicializa a 16, por lo que el mensaje que se muestra por

la consola es: Menor de edad

ESTRUCTURAS DE REPETICIÓN

Las estructuras de repetición permiten repetir muchas veces un bloque de sentencias. A

estas estructuras también se les conoce como estructuras iterativas o bucles.

Como las estructuras de selección, las estructuras de repetición se pueden combinar y

anidar. Es frecuente utilizar una estructura de repetición que contenga un bloque de

sentencias que combine otras estructuras de repetición y de selección.

Las estructuras de repetición se componen de cuatro partes: la inicialización, la condición,

el bloque de sentencias y la actualización.

Inicialización. Permite inicializar la estructura iterativa, normalmente consiste en la

declaración e inicialización de la variable de control del bucle.

Condición. Define la condición que se evalúa para ejecutar el bloque de sentencias de la

estructura iterativa. Dependiendo del tipo de estructura que se utilice, la condición se

comprueba antes o después de realizar cada iteración.

Bloque de sentencias. Conjunto de sentencias que se ejecutan dentro de la estructura

iterativa.

Actualización. Actualización de la variable de control del bucle.

Normalmente se realiza al finalizar la ejecución del bloque de sentencias.

45

ESTRUCTURA FOR

La estructura de repetición for repite el bloque de sentencias mientras la condición del for

es verdadera. Un for es un caso particular de la estructura while . Solo se debe utilizar

cuando se sabe el número de veces que se debe repetir el bloque de sentencias.

El diagrama de flujo de una estructura for es igual que el de un while. Un for verifica la

condición justo después de inicializar la variable de control.

Si el resultado de evaluar la condición por primera es falso, entonces no se ejecuta el

bloque de sentencias.

Un for tiene la siguiente sintaxis:

for (inicialización; condición; actualización) {


}

OPERADORES LÓGICOS

Java utiliza tres operadores lógicos: el O lógico (disyunción), el Y lógico (conjunción) y la

negación.

Los operadores O lógico (||) y el Y lógico (&&) se utilizan para evaluar expresiones lógicas

que solo pueden tomar el valor falso o verdadero. El operador Y lógico (&&) devuelve

Inicio


variable de control

Condición Fin


variable de control


46

false si uno de los operandos es false. El O lógico (||) devuelve true si uno de los operandos

es true.

El operador de negación (¡) es unario y devuelve el valor negado de una expresión lógica.

Orden de precedencia de los operadores

La siguiente tabla muestra el orden de prioridad de los operadores. Indica qué operador se

aplica primero en una expresión.

EJERCICIO N.-10

Enunciado

Diseñe una aplicación que me permita calcular el valor de las comisiones ganadas de los

vendedores de una empresa, según lo siguientes parámetros: la empresa dispone de 3

vendedores que realizan las ventas de sus vehículos.

Las comisiones se las concede en función de los valores facturados:

Si el valor >= 8000 <=11000 Recibe una comisión de 3% de la venta

47

Si el valor >11000 <=25000 Recibe una comisión de 4,5% de la venta

Si el valor >25000 <=45000 Recibe una comisión de 6 % de la venta

Si el valor >40000 Recibe una comisión de 8,5% de la venta

Se necesita conocer el valor acumulado por cada vendedor y el valor total generado por

comisión

Análisis:

1. Debemos importar las bibliotecas que vayamos a utilizar en el programa, en este

caso deberemos importar la librería principal (import javax.swing.JOptionPane ;).

2. Debemos declarar las variables string y las variables enteras que necesitemos.

3. En la variable de escoger una opción imprimimos el menú que vamos a presentar

para realizar los diferentes procesos.

4. Convertimos la variable escoger (de string) a entero y asignamos el valor de

correspondiente.

5. Utilizamos un swtich para realizar cada proceso del menú.

6. En cada case debemos ingresar los dos valores que usaremos para las operaciones y

convertirlos a datos de tipo entero.

7. Llamamos a la variable en que almacenaremos el resultado que será igual al nombre

de la clase que usaremos y del bloque al que pertenece, ubicando entre paréntesis

las variables de los datos ingresados.

8. Imprimimos la variable resultante del proceso

9. Utilizamos un do while para preguntar al usuario si desea volver a realizar el

proceso con diferentes valores

10. Repetimos el proceso en cada case con la variación de realizar las posteriores

operaciones a la suma.

11. En el último case utilizamos una instrucción que nos permitirá salir del programa

mientras este corriendo, esto es: System.exit(0);

12. Preguntamos si el usuario desea realizar nuevamente otros procesos o si desea salir.

48

Análisis Flujográmico:

package comision;


public class Comision {


{

String ventj, ventmarc, ventmar, rept, opcion, opj;

int vjuan, vmarc, vmar, op, menu, numj=0, nummarc=0, nummar=0;

double comj=0, commarc=0, commar=0, comjuan=0, commarcelo=0,

commaria=0, totventj=0, totventm=0, totventma=0, total=0;

do

{

opcion=JOptionPane.showInputDialog("EMPRESA DON LUCHO" +

"\n \n VENDEDORES" + "\n \n 1.- JUAN" + "\n 2.- MARCELO" + "\n

3.- MARÍA" + "\n 4.- Salir" +

"\n \n Con quien desea realizar su venta");

menu=Integer.parseInt(opcion);

Importación de

librerías del programa

Paquetes del

programa

Declaración

de variables

String, int y

double

Impresión del

Menú de

Opciones

Transformación de

variables String a

int

49

switch(menu)

{

case 1:

do

{

ventj=JOptionPane.showInputDialog("EMPRESA DON LUCHO" + "\n \n VENDEDOR

JUAN" + "\n \n Valor de la venta");

vjuan=Integer.parseInt(ventj);

numj=numj+1;

totventj=totventj+vjuan;

if(vjuan>=8000 && vjuan<=11000)

{

comj=vjuan*0.03;

comjuan=comjuan+comj;

c JOptionPane.showMessageDialog(null, "EMPRESA DON LUCHO" + "\n \n

VENDEDOR JUAN" + "\n \n # VENTA: " + numj +

"\n \n Venta=" + vjuan + "\n Comisión= " + comj);

}

else

{

if(vjuan>11000 && vjuan<=25000)

{

comj=vjuan*0.45;


JOptionPane.showMessageDialog(null, "EMPRESA DON LUCHO" + "\n

\n VENDEDOR JUAN" + "\n \n # VENTA: " + numj + "\n \n Venta=" + vjuan + "\n

Comisión= " + comj);

Incio del Switch con

Case1

Procesos para

operaciones

Decisión if y procesos


respectivos para

obtener sus distintos

resultados

50

}

else

{

if(vjuan>25000 && vjuan<=45000)

{

comj=vjuan*0.06;


JOptionPane.showMessageDialog(null, "EMPRESA DON LUCHO" +

"\n \n VENDEDOR JUAN" + "\n \n # VENTA: " + numj + "\n \n Venta=" + vjuan + "\n


}

else

{

if(vjuan>45000)

{

comj=vjuan*0.85;


JOptionPane.showMessageDialog(null, "EMPRESA DON LUCHO" +

"\n \n VENDEDOR JUAN" + "\n \n # VENTA: " + numj + "\n \n Venta=" + vjuan + "\n


}

}

}

}

opj=JOptionPane.showInputDialog

("Desea realizar una nueva venta con nuestro vendedor Juan

(1 SI/0 NO)");


respectivos para


resultados


respectivos para


resultados

Cierre de sentencias if

Proceso de repetición,

mensaje y cierre del

do while

51

op=Integer.parseInt(opj);

}

while(op==1);

JOptionPane.showMessageDialog(null,"EMPRESA DON LUCHO" + "\n \n VENDEDOR

JUAN" + "\n \n # VENTAS: " + numj + "\n \n Total de ventas=" + totventj + "\n

Comisiones ganadas= " + comjuan );

break;

case 2:

do

{

ventmarc=JOptionPane.showInputDialog("EMPRESA DON LUCHO"

+ "\n \n VENDEDOR MARCELO" + "\n \n Valor de la venta");

vmarc=Integer.parseInt(ventmarc);

nummarc=nummarc+1;

totventm=totventm+vmarc;

if(vmarc>=8000 && vmarc<=11000)

{

commarc=vmarc*0.03;

commarcelo=commarcelo+commarc;

JOptionPane.showMessageDialog(null, "EMPRESA DON LUCHO"

+ "\n \n VENDEDOR MARCELO" + "\n \n # VENTA: " + nummarc +

"\n \n Venta=" + vmarc + "\n Comisión= " + commarc);

}

else

{

Case 2 y Do While

Impresión del

nombre y datos

subtitulos


respectivos para


resultados

Impresión del

nombre y datos

subtitulos


respectivos para


resultados

52

if(vmarc>11000 && vmarc<=25000)

{

commarc=vmarc*0.45;





}

else

{

if(vmarc>25000 && vmarc<=45000)

{

commarc=vmarc*0.06;





}

else

{

if(vmarc>45000)

{

commarc=vmarc*0.85;


Impresión del

nombre y datos

subtitulos


respectivos para


resultados

Impresión del

nombre y datos

subtitulos


respectivos para


resultados

53




}

}

}

}

opj=JOptionPane.showInputDialog("Desea realizar una

nueva venta con nuestro vendedor Marcelo (1 SI/0 NO)");


}

while(op==1);

JOptionPane.showMessageDialog(null,"EMPRESA DON LUCHO"

+ "\n \n VENDEDOR MARCELO" + "\n \n # VENTAS: "

+ nummarc + "\n \n Total de ventas=" + totventm +

"\n Comisiones ganadas= " + commarcelo);

break;

case 3:

do

{

ventmar=JOptionPane.showInputDialog("EMPRESA DON LUCHO"

+ "\n \n VENDEDORA MARÍA" + "\n \n Valor de la venta");

Impresión del

nombre y datos

subtitulos




do while

Case 3 y Do While

Impresión del

nombre y datos

subtitulos

Impresión del

nombre y datos

subtitulos

54

vmar=Integer.parseInt(ventmar);

nummar=nummar+1;

totventma=totventma+vmar;

if(vmar>=8000 && vmar<=11000)

{

commar=vmar*0.03;

commaria=commaria+commar;


+ "\n \n VENDEDORA MARÍA" + "\n \n # VENTA: " + nummar +

"\n \n Venta=" + vmar + "\n Comisión= " + commar);

}

else

{

if(vmar>11000 && vmar<=25000)

{

commar=vmar*0.45;



+ "\n \n VENDEDOR MARÍA" + "\n \n # VENTA: " + nummar +


}

else

{

if(vmar>25000 && vmar<=45000)


respectivos para


resultados

Impresión del

nombre y datos

subtitulos


respectivos para


resultados

Impresión del

nombre y datos

subtitulos


respectivos para


resultados

55

{

commar=vmar*0.06;



+ "\n \n VENDEDOR MARÍA" + "\n \n # VENTA: " + nummar

+ "\n \n Venta=" + vmar + "\n Comisión= " + commar);

}

else

{

if(vmar>45000)

{

commar=vmar*0.85;


CJOptionPane.showMessageDialog(null, "EMPRESA DON LUCHO"

+ "\n \n VENDEDOR MARÍA" + "\n \n # VENTA: " + nummar +


}

}

}

}

opj=JOptionPane.showInputDialog("Desea realizar una

nueva venta con nuestro vendedor María (1 SI/0 NO)");

Impresión del

nombre y datos

subtitulos


respectivos para


resultados

Impresión del

nombre y datos

subtitulos




do while

56


}

while(op==1);


+ "\n \n VENDEDOR MARÍA" + "\n \n # VENTAS: "

+ nummar + "\n \n Total de ventas=" + totventma

+ "\n Comisiones ganadas= " + commaria);

break;

case 4:

System.exit(0);

break;

}

rept=JOptionPane.showInputDialog("Desea realizar una

nueva compra (1 SI/0 NO)");

op=Integer.parseInt(rept);

}

while(op==1);

total=totventj+totventm+totventma;


+ "\n \n VENDEDOR JUAN" + "\n \n # VENTAS: "

+ numj + "\n \n Total de ventas=" + totventj +

"\n Comisiones ganadas= " + comjuan +

"\n \n VENDEDOR MARCELO" + "\n \n # VENTAS: "

Impresión del

nombre y datos

subtitulos

Case 4 Opción Salir

Repetir el Programa

n veces

Suma total de las

comisiones de vendedores

Impresión de

subtítulos, para

cada vendedor y en

forma general, total,

comisiones

ganadas y

respuestas finales

57

+ nummarc + "\n \n Total de ventas=" + totventm +

"\n Comisiones ganadas= " + commarcelo + "\n \n

VENDEDOR MARÍA"

+ "\n \n # VENTAS: " + nummar + "\n \n Total de ventas="

+ totventma + "\n Comisiones ganadas= " + commaria+

"\n \n TODAL DE LAS VENTAS= " + total );

}}

Corrido

Cierre del programa con

sus respectivas llaves

ves

61

EJERCICIO N.-11

Enunciado

Diseñe un programa que me permita calcular el valor por concepto de matrículas de una

institución educativa bajo los siguientes parámetros

Las matriculas se cobran de forma diferenciada de acuerdo al tipo de institución que puede

ser:

Publica costo de la matricula: $120,00

Particular costo de la matricula: $190,00

Fisco misional costo de la matricula: $140,00

Todos los estudiantes independientemente del tipo de institución cancelan los siguientes

aranceles por beneficios extras que le concede la institución, estos son:

3% de la Matricula corresponde al Servicio Medico

8% de la Matricula corresponde al Servicio de Internet

6% de la Matricula corresponde al Servicio de Deportes

El sistema debe visualizar y reflejar el # de estudiantes matriculados por día, el valor total

acumulado por tipo de institución y por tipo de arancel, además que debe visualizar el

Boucher individual de cada estudiante.

Analisis

Iniciamos el programa para ello debemos importar las bibliotecas que vayamos a utilizar en

el programa, en este caso deberemos importar la librería principal (import

javax.swing.JOptionPane; ) y la librería de la clase que usaremos (import

pkg13.operacionesmenu.operaciones;).

Debemos declarar las variables string y las variables enteras que necesitemos.

En la variable de escoger una opción imprimimos el menú que vamos a presentar para

realizar los diferentes procesos.

Covertimos la variable escoger (de string) a entero y asignamos el valor de correspondiente.

Utilizamos un swtich para realizar cada proceso del menú.

62

En cada case debemos realizamos los procesos e imprimimos resultados.

Cerramos el programa con un while para que se repite las veces que desee el usuario

Documentación

package matriculas;


import java.text.DecimalFormat;

public class Matriculas {


{

String nombre,tipo,ret,repet;

int t,op1, op;

double p=120,pr=190,f1=140,con1=0,con2=0,con3=0,

sm1,sd1,si1,t1,sm2,sd2,si2,t2,sm3,sd3,si3,t3,sm11=0,

sd11=0,si11=0,sm22=0,sd22=0,si22=0,sm33=0,sd33=0,

si33=0,pt=0,prt=0, ft=0,cont, mt, smt, sit,sdt,st,tt;

DecimalFormat f=new DecimalFormat(".00");

do

{

JOptionPane.showMessageDialog(null," SISTEMA DE MATRICULAS" );

tipo=JOptionPane.showInputDialog("Escoja el tipo de Institucion"


del programa


Inicio del programa

Declaración de

variables String, int y

double


Opciones

Do-while proceso de

repetición

63

+"\n 1.- Publica"+"\n 2.- Pribada"+"\n 3.- Fiscomisinal"+"\n 4.-Salir");

t=Integer.parseInt(tipo);

switch(t)

{

case 1:

pt=pt+p;

con1=con1+1;

nombre=JOptionPane.showInputDialog("Ingrese el nombre

del estudiante:");

sm1=(p*3)/100;

sm11=sm11+sm1;

sd1=(p*8)/100;

sd11=sd11+sd1;

si1=(p*6)/100;

si11=si11+si1;

t1=sm1+sd1+si1+p;

JOptionPane.showMessageDialog(null," Nombre: "

+ nombre + "\n Institucion: Publica"+ "\n Costo de matricula: $ "

+ p +"\n Servicio Médico: $ "+f.format(sm1)+"\n Servicio Internt: $ "

+f.format(si1)+"\n Servicio Deportes"+f.format(si1)+"\n Total: $"

+f.format(t1) );

Transformación de

variables String a int


Case1 (primera opción)

Ingreso de Datos

Procesos

Impresión de resultados

64

break;

case 2:

prt=prt+pr;

con2=con2+1;

nombre=JOptionPane.showInputDialog("Ingrese el nobre

del estudiante:");

sm2=(pr*3)/100;

sm22=sm22+sm2;

sd2=(pr*8)/100;

sd22=sd22+sd2;

si2=(pr*6)/100;

si22=si22+si2;

t2=sm2+sd2+si2+pr;

JOptionPane.showMessageDialog(null," Nombre: "+ nombre

+ "\n Institucion: Pribada"+ "\n Costo de matricula: $ " + pr

+"\n Servicio Médico: $ "+f.format(sm2)+"\n Servicio Internt: $ "

Break cierre de la

primera opción (case 1)

Inicio Case2 (segunda

opción)

Contadores

Ingreso de Datos

Procesos


65

+f.format(si2)+"\n Servicio Deportes"+f.format(si2)+"\n Total: $"

+f.format(t2 ));

break;

case 3:

ft=ft+f1;

con3=con3+1;

nombre=JOptionPane.showInputDialog("Ingrese el

nombre del estudiante:");

sm3=(f1*3)/100;

sm33=sm33+sm3;

sd3=(f1*8)/100;

sd33=sd33+sd3;

si3=(f1*6)/100;

si33=si33+si3;

t3=sm3+sd3+si3+f1;

JOptionPane.showMessageDialog(null," Nombre: "+ nombre

+ "\n Institucion: Pribada"+ "\n Costo de matricula: $ " + f1

+"\n Servicio Médico: $ "+f.format(sm3)+"Servicio Internt: $ "+f.format(si3)+"Servicio

Deportes"+f.format(si3)+"Total: $"

+f.format(t3 ));

Break cierre de la


Inicio Case3 (tercera

opción)

Contadores

Ingreso de Datos

Procesos


66

break

case 4:

System.exit(0);

break;

}

repet=JOptionPane.showInputDialog("Desea ingresar otra

matricula 1 / 0");

op1=Integer.parseInt(repet);

}while(op1==1);

cont=con1+con2+con3;

mt=pt+prt+ft;

smt=sm11+sm22+sm33;

sdt=sd11+sd22+sd33;

sit=si11+si22+si33;

st=smt+sdt+sit;

tt=mt+st;

JOptionPane.showMessageDialog(null,"REPORTE GENERAL"

+ "\n Publica Pribada Fiscomisional Total"

+ " /n N° de matriculados "+ con1 + " " + con2 +" "

+ con3 + " " + cont+ "\n Valor de matriculas $ "+ pt+ " $ "

+prt+" $ "+ft +" $"+mt+"\nServicios Medicos $ "

Break cierre de la


Case4 (Opción Salir) Cierre del switch

Fin del proceso de repeticion

Procesos Finales

Impresión final

67

+f.format(sm11) + " $"+f.format(sm22)+" $"+f.format(sm33)+" $"+f.format(smt)+"\n

Servicios Internet $"+f.format(si11) + " $"

+f.format(si22)+" $"+f.format(si33)+" $"+f.format(sit)+"\n

Servicios Internet $"+f.format(sd11) + " $"+f.format(sd22)

+" $"+f.format(sd33)+" $"+f.format(sdt)+"\n

TOTOL: $ " +f.format(tt));

}

}

Corrido del programa

Fin del Programa

69

EJERCICIO N.-12

Enunciado

12. Diseñe un programa que me permita simular el funcionamiento de un sistema de rol de

pagos bajo los siguientes parámetros:

el nominal se ingresa conforme a la categoría si es administrativo gana Usd. 540, si

es ejecutivo gana Usd 1’200,00 si es obrero gana Usd 340,00

Obtenga el valor ingresado Horas Extras tomando en puede tener un máximo de

número de horas extras 8 y cada hora cuesta Usd 3,50

Obtenga el valor de cargas familiares la misma que esta condicionada. Si el

empleado tiene más de dos hijos se le paga Usd. 4,5 por cada hijo caso contrario se

le reconoce Usd 6,2 por cada hijo

Obtenga el valor del IESS que es el 11,5 % del nominal

Se le descuenta a todos los empleados por concepto de comisariato el 2,5% del

nominal

Obtenga el total de ingreso, egresos y líquido a recibir

Análisis:

En este programa hemos utilizado Do-While ya la estructura Switch para realizar un menú

de opciones en cada case va el miso proceso, en la declaración de variables utilizamos un

doublé para cantidades con decimales, para la impresión hemos utilizando la

JOptionPane.showMessageDialog y al final cada case un break.

Código:

package prueba;

import java.text.DecimalFormat;


public class Prueba {


String opc1,opc,nom,ce;

double ad=540,ej=1200,ob=340,he,ph,h,pi,ie,co,te,ti,st,sp,op1;


librerías


Inicio del programa

70

int a,op;

do{

DecimalFormat df=new DecimalFormat(".00");

opc=JOptionPane.showInputDialog(" LIQUIDO TOTAL DE EMPLEADOS\n"+"1.-

Administrativo\n"

+"2.-Ejeutivo\n"+"3.-Obrero\n"+"5.-Salir");

op=Integer.parseInt(opc);

switch(op)

{

case 1:

nom=JOptionPane.showInputDialog("Nombre: ");

do{

he=Double.parseDouble(JOptionPane.showInputDialog("Horas extras: "));

}while(he>8);

ph=he*3.50;

h=Double.parseDouble(JOptionPane.showInputDialog("Hijos: "));

if(h>2)

{

pi=h*4.50;

}

else

{

pi=h*6.20;

}

ti=ph+pi;

Inicio del do-while

Diseño del menú

Ingreso de la opción

Inicio del switch

Ingreso del nombre

Ingreso de las horas

extras

Ingreso del número de hijos

Proceso

71

ie=ad*0.115;

co=ad*0.025;

te=ie+co;

sp=ad+ph+pi;

st=sp-ie-co;

JOptionPane.showMessageDialog(null," REPORTE

GENERAL\n"+nom+"\nAdministrativo"+"\nSueldo "

+ad+"\n\nIngresos "+ti+"\nHoras extras "

+ph+"\nCargas familiares "+pi+"\n\nEgresos "+te+"\nIESS "+ie+

"\nComisiariato "+co+"\nSueldo a recibir "+st);

break;

case 2:


do{


}while(he>8);

ph=he*3.50;


if(h>2)

{

pi=h*4.50;

}

else

{

pi=h*6.20;

Proceso


Cierre del case

Ingreso del nombre


extras Ingreso del número de hijos

Proceso

72

}

ti=ph+pi;

ie=ej*0.115;

co=ej*0.025;

te=ie+co;

sp=ej+ph+pi;

st=sp-ie-co;


GENERAL\n"+nom+"\nEjecutivo"+"\nSueldo "

+ej+"\n\nIngresos "+ti+"\nHoras extras "



break;

case 3:


do{


}while(he>8);

ph=he*3.50;


if(h>2)

{

pi=h*4.50;

}

Else


Cierre del case 2

Ingreso del nombre


extras

Ingreso del número de hijos

Proceso

73

{

pi=h*6.20;

}

ti=ph+pi;

ie=ob*0.115;

co=ob*0.025;

te=ie+co;

sp=ob+ph+pi;

st=sp-ie-co;


GENERAL\n"+nom+"\nObrero"+"\nSueldo "

+ob+"\n\nIngresos "+ti+"\nHoras extras "



break;

case 4:

System.exit(0);

break;

}

opc1=JOptionPane.showInputDialog("Salir 1/0: ");

op1=Integer.parseInt(opc1);

}while(op1==1);

}

}


Proceso

Cierre del case 3

Proceso par salir

Cierre del case 4

Cierre del while

Ingreso para la opción do-while

74

Corrido:

75

EJERCICIO N.-13

Enunciado

Diseñe un programa que me permita realizar las operaciones básicas a través de un menú

de opciones.

Análisis:

En este programa utilizamos un switch para realizar un menú de opciones y en cada case

hacemos procesos diferentes que nos permiten hacer el cálculo de las seis operaciones

básicas en el programa principal solo ingresamos los datos e imprimimos y llamamos al

proceso que está en las funciones y lo llamamos desde el programa principal.

Debemos importar las bibliotecas q vayamos a utilizar en nuestro programa en este caso

(import javax.swing.JOptionPane;)

Código:

Programa principal.

package seisop;


import seisop.funcionesop;

public class Seisop {


String dato1,dato2,op,opa;

int a,b,op1,sum1,res1,mult1,opb;

double div1,pot1,rad1;

do{

op=JOptionPane.showInputDialog("ESCOJA UNA OPCION

\n1.-SUMA\n2.-RESTA\n3.-MULTIPLICACION\n"+

"4.-DIVISION\n5. -POTENCIACION

\n6.-RADICACION\n7.-SALIR");

op1=Integer.parseInt(op);


del programa y paquete


Declaración de

variables

Menú de Opciones

Transforma de String

a int para switch

76

switch(op1)

{

case 1:

dato1=JOptionPane.showInputDialog("Dato 1 :");

a=Integer.parseInt(dato1);


b=Integer.parseInt(dato2);

sum1=funcionesop.suma1(a, b);

JOptionPane.showMessageDialog(null,"La suma es: "+sum1);

break;

case 2:

do

{





}while(a<b);

res1=funcionesop.resta(a, b);

JOptionPane.showMessageDialog(null,"La resta es:"+res1);

break;

case 3:





mult1=funcionesop.multiplicacion(a, b);

JOptionPane.showMessageDialog(null,"La multiplicacion es:"+mult1);

break;

case 4:

do

{


Ingreso de datos

Llamamos a la clase

Impresión del mensaje

Do-while para el control

en la resta

Ingreso de datos

Llamamos a la clase


Ingreso de datos

Llamamos a la clase


Control para el proceso de la división

Ingreso de datos

77




}while(a<b);

div1=funcionesop.division(a, b);

JOptionPane.showMessageDialog(null,"La division es:"+div1);

break;

case 5:

dato1=JOptionPane.showInputDialog("Base :");


dato2=JOptionPane.showInputDialog("Exponente :");


pot1=funcionesop.potencia(a, b);

JOptionPane.showMessageDialog(null,"La potencia es:"+pot1);

break;

case 6:

dato1=JOptionPane.showInputDialog("Numero :");


rad1=funcionesop.radicacion(a);

JOptionPane.showMessageDialog(null,"La raiz es:"+rad1);

break;

}

opa=JOptionPane.showInputDialog("INGRESE 1 CONTINUAR

Y 0 PARA SALIR:");

opb=Integer.parseInt(opa);

}while(opb==1);

}

}

Clase del programa:

package seisop;

public class funcionesop {

public static int suma1(int a1, int b1)

{

int sumar;

Llamamos a la clase


Ingreso de datos

Llamamos a la clase


Ingreso de datos

Llamamos a la clase


Mensaje de do-while para

enviar un mensaje si desea

repetir

Nombre del programa principal

Proceso de suma

78

sumar=(a1+b1);

return sumar;

}

public static int resta(int a1, int b1)

{

int restar;

restar=(a1-b1);

return restar;

}

public static int multiplicacion(int a1, int b1)

{

int multiplicar;

multiplicar=(a1*b1);

return multiplicar;

}

public static double division(double a1, double b1)

{

double dividir;

dividir=(a1/b1);

return dividir;

}

public static double potencia(double a1, double b1)

{

double poten;

poten=Math.pow(a1,b1);

return poten;

}

public static double radicacion(double a1)

{

double radical;

radical=Math.sqrt(a1);

return radical;

}

}

Proceso de resta

Proceso de multiplicación

Proceso de división

Proceso de potencia

Proceso de radicación

79

Corrido:

80

EJERCICIO N.-14

Enunciado

Diseñe un menú de opciones que me permita realzar las 6 operaciones básicas con datos

enteros ingresados desde teclado, utilizando clases.

Analisis

1. Debemos importar las bibliotecas que vayamos a utilizar en el programa, en este

caso deberemos importar la librería principal (import javax.swing.JOptionPane; ) y

la librería de la clase que usaremos (import pkg13.operacionesmenu.operaciones;).

2. Debemos declarar las variables string y las variables enteras que necesitemos.

3. En la variable de escoger una opción imprimimos el menú que vamos a presentar

para realizar los diferentes procesos.

4. Covertimos la variable escoger (de string) a entero y asignamos el valor de

correspondiente.

5. Utilizamos un swtich para realizar cada proceso del menú.

6. En cada case debemos ingresar los dos valores que usaremos para las operaciones (a

excepción de la radicación) y convertirlos a datos de tipo entero.

7. Llamamos a la variable en que almacenaremos el resultado que será igual al nombre

de la clase que usaremos y del bloque al que pertenece, ubicando entre parentesis

las variables de los datos ingresados.

8. Imprimimos la variable resultante del proceso

9. Utilizamos un do while para preguntar al usuario si desea volver a realizar el

proceso con diferentes valores

10. Repetimos el proceso en cada case con la variación de realizar las posteriores

operaciones a la suma.

11. En el ultimo case utilzamos una instrucción que nos permitirá salir del programa

miestras este corriendo, esto es: System.exit(0);

12. Preguntamos si el usuario desea realizar nuevamente otros procesos o si desea salir

81

Documentación

//PROGRAMA PRINCIPAL

package pkg13.operacionesmenu;


import pkg13.operacionesmenu.operaciones;

public class Operacionesmenu {


{

String dato1,dato2,escoger,opcion;

int num1,num2,suma,resta,multiplicacion,es,op;

double division, potenciacion, radicacion;

{

escoger=JOptionPane.showInputDialog(null, "

OPERACIONES BASICAS \n\n 1. Suma \n 2. Resta \n

3. Multiplicación \n 4. División \n 5. Potenciación \n

6. Radicación \n 7. Salir \n\n Escoja una opcion:");


del programa


Declaración de


double


Opciones

82

es=Integer.parseInt(escoger);

switch(es)

{

case 1:

do{

dato1=JOptionPane.showInputDialog

("Ingrese el primer valor: ");



("Ingrese el segundo valor: ");


suma=operaciones.sumar(num1, num2);


(null, "La Suma es: "+ suma);

opcion=JOptionPane.showInputDialog

("Desea realizar otra suma: 1=si / 0=no");

op=Integer.parseInt(opcion);

}while(op==1);

break;

case 2

do{

do{

Transformación de

variables String a int


Case1

Ingreso de Datos

Llamado de clase o

función

DO WHILE y break

Case 2 y Do While

Ingreso de Datos

83







}while(num1<num2);

resta=operaciones.restar(num1, num2);


(null, "La Resta es: "+ resta);


("Desea realizar otra resta: 1=si / 0=no");


}while(op==1);

break;

case 3:

do{







multiplicacion=operaciones.multi(num1, num2);

Llamado de clase o

función

DO WHILE y break

Case 3 y Do While

Ingreso de Datos

Llamado de clase o

función

Validación de datos

84


(null, "La Multiplicación es: "+ multiplicacion);


("Desea realizar otra multiplicacion: 1=si / 0=no");


}while(op==1);

break;

case 4:

do{

do{







}while(num1<num2);

division=operaciones.dividir(num1, num2);


(null, "La División es: "+ division);


("Desea realizar otra division 1=si / 0=no");


}while(op==1);

DO WHILE y break

Case 4 y Do While

Ingreso de Datos

Llamado de clase o

función

DO WHILE y break

Validación de datos

85

break;

case 5:

do{


("Ingrese la base: ");



("Ingrese el exponente: ");


potenciacion=operaciones.potencia(num1, num2);


(null, "La Potenciación es: "+ potenciacion);


("Desea realizar otra potenciacion 1=si / 0=no");


}while(op==1);

break;

case 6:

do{

dato1=JOptionPane.showInputDialog("Ingrese el valor: ");


radicacion=operaciones.raiz(num1);


Case 5 y Do While

Ingreso de Datos

Llamado de clase o

función

DO WHILE y break

Case 6 y Do While

Ingreso de Datos

Llamado de clase o

función

86

(null, "La Radicacion es: "+ radicacion);


("Desea realizar otra radicación 1=si / 0=no");


}while(op==1);

break;

case 7:

System.exit(0);

break;

}// fin del switch


("Desea volver al menu: 1=si / 0=no");


}while(op==1);

}// fin del paquete

}// fin de la aplicación

//CLASE DEL PROGRAMA

DO WHILE y break

Case 7 Opción Salir

Fin del Switch

Repetir el Programa n

veces

Fin del Programa

87

package pkg13.operacionesmenu;

public class operaciones

{

public static int sumar(int a, int b)

{

int sumar;

sumar=(a+b);

return sumar;

}

public static int restar(int a, int b)

{

int restar;

restar=(a+b);

return restar;

}

public static int multi(int a, int b)

{

int multi;

multi=(a+b);

return multi;

Nombre del Programa

principal

Inicio de Clase o

Función

Proceso de suma

Proceso de resta

Proceso de

multiplicación

88

}

public static double dividir(double a, double b)

{

double dividir;

dividir=(a/b);

return dividir;

}

public static double potencia(double a, double b)

{

double potencia;

potencia=Math.pow(a, b);

return potencia;

}

public static double raiz(double a)

{

double raiz;

raiz=Math.sqrt(a);

return raiz;

}

}

Proceso de división

Proceso de

potenciación

Proceso de radicación

89

CORRIDO

91

DECLARACIÓN DE UNA CLASE Y DEFINICIÓN DE OBJETOS.

La programación orientada a objetos se basa en la programación de clases; a diferencia de

la programación estructurada, que está centrada en las funciones.

Una clase es un molde del que luego se pueden crear múltiples objetos, con similares

características.

Una clase es una plantilla (molde), que define atributos (variables) y métodos (funciones)

La clase define los atributos y métodos comunes a los objetos de ese tipo, pero luego, cada

objeto tendrá sus propios valores y compartirán las mismas funciones.

Debemos crear una clase antes de poder crear objetos (instancias) de esa clase. Al crear un

objeto de una clase, se dice que se crea una instancia de la clase o un objeto propiamente

dicho.

La estructura de una clase es:

package operaciones6;

public class funcion {

public static int suma(int a, int b)

{

int sumar;

sumar=(a+b);

return sumar;

}

public static int resta(int a, int b)

{

int restar;

restar=(a-b);

return restar;

}

Para poder utilizar las funciones tenemos q activar en el programa principal de la siguiente

manera:

package operaciones6;

import static java.lang.System.exit;


import operaciones6.funcion;

92

EJERCICIO N.-15

ENUNCIADO:

Diseñe un programa utilizando clases que me permita verificar si un numero entero

ingresado desde teclado le corresponde a la siguiente categoría:

1 – 3 Bebé

3 – 11 Niño

12 – 17 Adolescente

18 – 45 Adulto

46 en adelante – Adulto Mayor

ANALISIS: Este programa permite verificar la edad a que categoría corresponde. 1.

Importación de bibliotecas principales que utilizaremos (import javax.swing.JOptionPane; e

importjava.text.DecimalFormat;). Debemos declarar las variables String, double y formato

para decimales. Inicialización de ciclo do while para que el programa se repita n veces,

llamamos a las clases.En las clases hacemos el proceso correspondiente mediante un if, else

e impresiones de pantalla.

PROGRAMA

package edades;


public class Edades {


String opcion,dato;

int edad1,op,edades;

do

{

opcion=JOptionPane.showInputDialog(null,"***VERIFICACION DE EDAD***\n1 a 3

años BEBE\n3 a 11 años NIÑO\n12 a 17 años ADOLESCENTE\n18 a 45 años

ADULTO\n45 en adelante ADULTO MAYOR\n**INGRESE UNA EDAD** ");

edad1=Integer.parseInt(opcion);

edades=edad.edades(edad1);

dato=JOptionPane.showInputDialog(null,"DESEA REPETIR 1 O 0 PARA SALIR: ");

op=Integer.parseInt(dato);

}while(op==1);

}

}

CLASES

package edades;


Importación de librerías del

programa


Declaración de variables String y double

Inicio ciclo do while principal

LLAMA A LAS FUNCIONES

SE CIERRA EL LAZO REPETITIVO

Importación de librerías del

programa

93

public class edad {

public static int edades(int edad1)

{

if(edad1>=1 && edad1<=3)

{

JOptionPane.showMessageDialog(null, "BEBE: "+edad1);

}

else

{

if(edad1>=4 && edad1<=11)

{

JOptionPane.showMessageDialog(null, "NIÑO: "+edad1);

}

else

{

if(edad1>=12 && edad1<=17)

{

JOptionPane.showMessageDialog(null, "ADOLESCENTE: "+edad1);

}

else

{

if(edad1>=18 && edad1<=45)

{

JOptionPane.showMessageDialog(null, "ADULTO: "+edad1);

}

else

{

if(edad1>45)

{

JOptionPane.showMessageDialog(null, "ADULTO MAYOR: "+edad1);

}

}

}

}

}

return 0;

}

}

PROCESO

SE CIERRA LA CLASE

94

EJERCICIO N.-16

ENUNCIADO:

Diseñe un menú de opciones utilizando clases de un conjunto de series de datos: primos,

factorial, Fibonacci, pares, y la opción salir.

ANALISIS:

Para realizar este proyecto primero debemos importar las bibliotecas que vayamos a

utilizar, Declarar datos del tipo que necesitemos y empezar el programa con títulos y un

menú de opciones que nos permita escoger la serie que deseemos realizar, seguido de una

clase para realizar cada serie, también con la opción de repetir el proceso las veces que

desee el usuario presentando al fin los resultados respectivos que queremos.

DOCUMENTACIÓN:

package menuseries;


import menuseries.series;

public class Menuseries {


{

String dato1, dato2,dato3;

int op,limite,pares,num,i,p,primos,factor,fibo,opc;

JOptionPane.showMessageDialog(null, "MENU DE SERIES ");

do

{dato1=JOptionPane.showInputDialog("1. PRIMOS \n 2. FACTORIAL

\n 3. FIBONACCI \n 4. PARES \n 5. SALIR \n Ingrese una opcion: ");


switch(op)

{

case 1:

dato2=JOptionPane.showInputDialog("Ingrese un limite");


primos=series.primos(limite);

break;

case 2:



factor=series.facto(limite);

break;

case 3:



fibo=series.fibo(limite);

break;


del programa

Declaración de


double


Opciones

Inicio del Switch con

Case1

Ingreso del límite y

Llamado de clase o

función Inicio del Switch con

Case 2 Ingreso del límite y

Llamado de clase o

función Inicio del Switch con

Case 3 Ingreso del límite y

Llamado de clase o

función

95

case 4:



pares=series.par(limite);

break;

case 5:

System.exit(0);

break;

}

dato3=JOptionPane.showInputDialog("Volver al menu 1 Salir 0: ");

opc=Integer.parseInt(dato3);

}

while(opc==1);

}

}

CLASE DEL PROGRAMA

package menuseries;


public class series

{

public static int par (int limite)

{

int p;

int i;

p=0;


{

p=p+2;

JOptionPane.showMessageDialog(null, +p);

}

return 0;

}

public static int primos (int limite)

{

int conta,residuo,i,j;


{

conta=0;

for(j=1;j<=i;j++)

{

residuo=i%j;

Inicio del Switch con Case 4

Ingreso del límite y

Llamado de clase o

función

Fin del Switch con Case 5


veces

Fin del Programa

Nombre del Programa

principal

Serie de numeros pares

Serie de numeros primos

96

if(residuo==0)

{

conta=conta+1;

}

}

if(conta==2)

{

JOptionPane.showMessageDialog(null, +i);

}

}

return 0;

}

public static int facto(int limite)

{

int f,i;

f=1;

i=1;

i=i+1;


{

f=f*i;

JOptionPane.showMessageDialog(null, +i+f);

}

return 0;

}

public static int fibo(int limite)

{

int m,i,j,c,a = 0,b=1;

m=1;

for(j=1;j<=limite-1;j++)

{

m=m+3;

}

for(i=0;i<=limite-2;i++)

{

c=a+b;

a=b;

b=c;

JOptionPane.showMessageDialog(null, +a);

}

return 0;

}

}

Serie de numeros primos

Serie de la factorial

Serie del Fibonacci

97

CORRIDO DEL PROGRAMA:

98

EJERCICIO N.-17

ENUNCIADO:

Diseñe un programa utilizando clases que me permita ingresar un número entero desde

teclado y me permita descomponerlo en todos sus elementos posibles. (Unidad, decena,

centena, unidad de mil, etc.)

ANÁLISIS

Necesitaremos una variable tipo int para generar la descomposición en sus unidades

DOCUMENTACIÓN

package decompocicion;


import decompocicion.descomponer;

public class Decompocicion {


String num;

int a,res;

do{

num=JOptionPane.showInputDialog("NUMERO");

a=Integer.parseInt(num);

}while(a<1 || a>9999);

res=descomponer.descomponer(a);

}

}

Clase

package decompocicion;


public class descomponer {

public static int descomponer(int a)

{

int um,c,d,u;

um=a;

um=(um/1000)*1000;

c=a;

c=c-um;

c=(c/100)*100;

d=a;

d=d-um-c;

d= (d/10)*10;

u=(a-um)-c-d;


del programa


Declaración de variables tipo int y string

Fin del programa principal

Programa principal importación de librerías e inicio de clases

Clase descomposición

con su respectivo

proceso para realizar

una descomposición en

sus unidades

99

JOptionPane.showMessageDialog(null,"Unidad "+u+"\nDecena "+d+"\nCentena "+c

+"\nUnidad de mil "+um+"\nTotal "+a);

return 0;

}

}

CORRIDO

100

EJERCICIO N.-18

ENUNCIADO:

Diseñe un menú de opciones utilizando clases que me permita diseñar un sistema de

conversiones de números de diferentes bases.

Se necesita convertir un número entero a su binario correspondiente, un entero a octal y un

entero a hexadecimal.

ANALISIS:

Para realizar este proyecto primero debemos importar las bibliotecas que vayamos a

utilizar, Declarar datos del tipo que necesitemos y empezar el programa con títulos y un

menú de opciones que nos permita escoger la conversión que deseemos realizar, seguido de

una clase para realizar cada conversion, también con la opción de repetir el proceso las

veces que desee el usuario presentando al fin los resultados respectivos que queremos.

DOCUMENTACIÓN:

package conversiones;


public class Conversiones {


{

String dato1, dato2, dato;

int a,bi,oc,hexa,op,opc;

JOptionPane.showMessageDialog(null, "CONVERSIONES ");

do

{

dato=JOptionPane.showInputDialog("1. BINARIO \n 2. OCTAL

\n 3. HEXADECIMAL \n 4. SALIR \n Ingrese una Opcion: ");

opc=Integer.parseInt(dato);

switch(opc)

{

case 1:

dato1=JOptionPane.showInputDialog("Ingrese un numero: ");


bi=convers.bi(a);

break;

case 2:



oc=convers.oct(a);

break;

case 3:




del programa

Declaración de


double


Opciones


Case1

Ingreso el número que

deseo transformar a

binario y llamamos a la

clase


Case 2 Ingreso el número que

deseo transformar a

octal y llamamos a la

clase


Case 3

101

hexa=convers.he(a);

break;

case 4:

System.exit(0);

break;

}

dato2= JOptionPane.showInputDialog("VOLVER AL

MENU 1 SALIR 0: ");


}

while(op==1);

}

}

CLASE DEL PROGRAMA

package conversiones;


public class convers

{

public static int bi (int a)

{

JOptionPane.showMessageDialog(null, "Numero Binario:

"+Integer.toBinaryString(a));

return 0;

}

public static int oct (int a)

{

JOptionPane.showMessageDialog(null, "Numero Octal: "+Integer.toOctalString(a));

return 0;

}

public static int he(int a)

{

JOptionPane.showMessageDialog(null, "Numero

Hexadecimal: "+Integer.toHexString(a));

return 0;

}

}

Fin del Programa

Nombre del Programa

principal

Transformación de un número decimal a binario

Fin del Switch con

Case 4


veces

Ingreso el número que

deseo transformar a

hexadecimal y llamamos a

la clase

Transformación de un

número decimal a octal

Transformación de un

número decimal a

hexadecimal

102

CORRIDO DEL PROGRAMA:

103

BIBLIOGRAFIA:

http://pendientedemigracion.ucm.es/info/tecnomovil/documentos/fjava.pdf

http://www.java.com/es/about/

http://www.slideshare.net/pbcanessa/introduccin-a-la-programacin-en-java

http://www.edukanda.es/mediatecaweb/data/zip/1305/page_08.htm

http://users.dcc.uchile.cl/~lmateu/CC60H/Trabajos/edavis/swing.html

Java Teoría-ejercicios

Education

Transcript of Java Teoría-ejercicios