Este documento presenta un programa en Java que permite calcular el área y perímetro de cuatro figuras básicas (cuadrado, rectángulo, círculo y triángulo). El programa contiene clases para cada figura que solicitan los datos de entrada necesarios, realizan los cálculos correspondientes y muestran los resultados. También incluye un menú principal que guía al usuario en la selección de la figura a analizar.

1. U N I V E R S I D A D T E C N I C A D E A M B A T O
2014
PROGRAMACION EN
JAVA
EJERCICIOS DE APLICACION
JAVA

2. 1
UNIVERSIDAD TECNICA DE AMBATO
FACULTAD DE CIENCIAS HUMANAS Y DE LA EDUCACIÓN
DOCENCIA EN INFORMATICA
MODULO
PROGRAMACIÓN I
CURSO: TERCER SEMESTRE
PARALELO: UNICO
PERIODO: ABRIL - SEPTIEMBRE 2014
ESTUDIANTE: VINICIO VERDEZOTO
DOCENTE: ING. MG.WILMA GAVILANES
FECHA: LUNES, 12 DE MAYO DEL 2014
AMBATO-ECUADOR

3. 2
INDICE
pág.
1. CARATULA………………………………………………………………………………………………………………….1
2. INDICE…………………………………………………………………………………………………………………….....2
3. INTRODUCCIÓN………………………………………………………………………………………………………….3
4. OBJETIVOS………………………………………………………………………………………………………………….4
5. CONCLUSIONES………………………………………………………………………………………………………….5
6. SUMA DE DOS NUMEROS……………………….………………………………………………………6
7. OPERACIONES BASICAS………..……………………………………………………………………………………7
8. AREA Y PERIMETRO…………..……………………………………………………………………………………….10
9. POTENCIACION Y RADICACION………………………………………………………………………………….14
10. VERIFICAR PAR O IMPAR………………………………………..…………………………………………………16
11. PROMEDIO DE UNA CALIFICACION…………….…………………………………………………………….19
12. TABLA DE MULTIPLICAR…………………………………………………………………………………………….23
13. ECUACION DE SEGUNDO GRADO………………………………………………………………………………25
14. CONSUMO DE ENERGIA ELECTRICA…………………………………………………………………………..28
15. COMISIONES………………………………………………………………………………………………………………32
16. MATRICULAS DE UNA INSTITUCION EDUCATIVA………………………………………………………41
17. ROL DE PAGOS……………………………………………………………………………………………………………47
18. MENU DE OPERACIONES BASICAS…………………………………………………………………………….50
19. SEIS OPERACIONES BASICAS……………………………………………………………………………………..55
20. PRIMO, FACTORIAL, FIBONACII Y PARES……………………………………………………………………61
21. VERIFICAR LA EDAD MEDIANTE CLASES…………………………………………………………………….65
22. DESCOMPONER EN UNIDAD, DECENA, CENTENA MEDIANTE CLASES………………………68
23. CONVERSION DE NUMEROS MEDIANTE CLASES……………………………………………………….69

4. 3
INTRODUCCIÓN
El presente trabajo se refiere a programación, que se puede definir como un lenguaje
formal diseñado para expresar procesos que pueden ser llevados a cabo por máquinas
como las computadoras.
Java es un lenguaje de programación es una fase de la metodología orientada a
objetos para el desarrollo de Software. Su uso induce a los programadores a pensar en
términos de objetos, en vez de procedimientos, cuando planifican su código. Un objeto
agrupa datos encapsulados y procedimientos para representar una entidad. La 'interfaz
del objeto', esto es, las formas de interactuar con el objeto, también se definen en esta
etapa. Un programa orientado a objetos se caracteriza por la interacción de esos objetos.
El diseño orientado a objetos es la disciplina que define los objetos y sus interacciones
para resolver un problema de negocio que fue identificado y documentado durante el
análisis orientado a objetos

5. 4
Objetivo general:
 Conocer el funcionamiento del programa y sus clases.
Objetivo específico:
 Identificar la utilidad del programa.
 Identificar qué tipo de lazo se debe poner en el proceso para su correcto
funcionamiento.

6. 5
Conclusiones:
 Como resultado del trabajo conocimos los diferentes tipos de procesos de acuerdo
al ejercicio que se lo desea realiza.
 Por medio de este trabajo nos ayudó a conocer la utilidad de la programación para
resolver ejercicios en java.

7. 6
1. Utilizando el lenguaje de programación orientado a objetos JAVA realizar una suma
ingresando dos números enteros desde teclado
ANALISIS:
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," " + );
PROGRAMA:
package suma;
import javax.swing.JOptionPane;
public class Suma {
public static void main(String[] args) {
String dato1, dato2;
int n1, n2, suma;
dato1=JOptionPane.showInputDialog("1° numero");
n1=Integer.parseInt(dato1);
dato2=JOptionPane.showInputDialog("2° nemero");
n2=Integer.parseInt(dato2);
suma=n1+n2;
JOptionPane.showMessageDialog(null,"La Suma es= "+suma);
}
}
Inicio del programa
Declaración de variables
Ingreso de datos
Proceso
Impresión del resultado
Cierre del programa

8. 7
2. Diseñar un programa en JAVA que me permita resolver las operaciones básicas.
ANALISIS:
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.
PROGRAMA:
package operacionesbasicas;
import javax.swing.JOptionPane;
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("SUMAn"+"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;
case 2:
d2=JOptionPane.showInputDialog("RESTAn"+"INGRESE EL PRIMER DATO : ");
n=Integer.parseInt(d2);
Importación de librerías
del programa
Declaración de variables
Inicio del ciclo do
Impresión del Menú de
Opciones
Inicio del switc
Case 1 en este case
esta el proceso para la
suma con
impresiones, proceso
y una ultima
impresión para el
resultado.

9. 8
do
{
d3=JOptionPane.showInputDialog("INGRESE EL SEGUNDO DATO : ");
m=Integer.parseInt(d3);
}while(n>m);
c=n-m;
JOptionPane.showMessageDialog(null,"RESPUESTA : "+c);
break;
case 3:
d2=JOptionPane.showInputDialog("MULTIPLICACION
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;
case 4:
d2=JOptionPane.showInputDialog("DIVICIONn"+"INGRESE EL PRIMER DATO : ");
n=Integer.parseInt(d2);
do
{
d3=JOptionPane.showInputDialog("INGRESE EL SEGUNDO DATO : ");
m=Integer.parseInt(d3);
}while(n>m);
c=n/m;
JOptionPane.showMessageDialog(null,"RESPUESTA : "+c);
break;
}
d5=JOptionPane.showInputDialog("DESEA REPETIR 1 O 0 PARA SALIR: ");
op1=Integer.parseInt(d5);
}while(op1==1);
}
}
CORRIDO:
Case 1 en este case
esta el proceso para la
resta con impresiones,
proceso y una ultima
impresión para el
resultado. Con un
control de ingreso
Case 1 en este case
esta el proceso para la
multiplicación con
impresiones, proceso
y una ultima
impresión para el
resultado
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
datos
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
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
Llaves de finalización del programa

10. 9

11. 10
3. 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.
ANALISIS:
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.
PROGRAMA:
package fig_bas;
import javax.swing.JOptionPane;
import fig_bas.figuras;
public class Fig_bas {
public static void main(String[] args)
{
String opc;
int menu, cua, rect, circ, trian;
opc=JOptionPane.showInputDialog("FIGURAS BÁSICAS
nn1.- Cuadrado n2.- Rectángulo n3.- Círculo n4.- Triángulo
n5.- Salir nnQue desea realizar");
menu=Integer.parseInt(opc);
switch(menu)
{
case 1:
cua=figuras.cuadrado();
break;
case 2:
rect=figuras.rectandulo();
break;
case 3:
circ=figuras.circulo();
Importación de librerías
del programa
Inicio del programa principal
Declaración de variables
Menú de opciones
Inicio del menú de opciones
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
Case 3: para encontrar el perímetro y
el área de un círculo

12. 11
break;
case 4:
trian=figuras.triangulo();
break;
case 5:
System.exit(0);
break;
}
}
}
package fig_bas;
import javax.swing.JOptionPane;
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 4: para encontrar el perímetro y
el área de un 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.

13. 12
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");
l2=Integer.parseInt(lado2);
per=l1*2+l2*2;
ar=l1*l2;
JOptionPane.showMessageDialog(null, "PERIMETRO
DEL RECTÁNGULO= " + per);
JOptionPane.showMessageDialog(null, "ÁREA DEL
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);
JOptionPane.showMessageDialog(null, "PERIMETRO
DEL CÍRCULO= " + per);
return 0;
}
Clase (subprograma) para
calcular el perímetro y el
área de un rectángulo.
Clase (subprograma)
para calcular el
perímetro y el área de un
círculo.

14. 13
public static int triangulo()
{
String lado1, lado2, lado3;
int l1, l2, l3, per, ar;
lado1=JOptionPane.showInputDialog("Ingrese la base
del triángulo");
l1=Integer.parseInt(lado1);
lado2=JOptionPane.showInputDialog("Ingrese la altura
del triángulo");
l2=Integer.parseInt(lado2);
lado3=JOptionPane.showInputDialog("Ingrese el lado
restante del triángulo");
l3=Integer.parseInt(lado3);
per=l1+l2+l3;
ar=(l1*l2)/2;
JOptionPane.showMessageDialog(null, "PERIMETRO
DEL TRIÁNGULO= " + per);
JOptionPane.showMessageDialog(null, "ÁREA DEL
TRIÁNGULO= " + ar);
return 0;
}
}
CORRIDO:
Clase (subprograma)
para calcular el
perímetro y el área de
un triángulo.

15. 14
4. 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.
PROGRAMA:

16. 15
package poteyradi;
import javax.swing.JOptionPane;
public class PoteyRadi {
public static void main(String[] args)
{
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);
}}
CORRIDO:
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

17. 16
5. 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.
PROGRAMA:

18. 17
package par.impar;
import javax.swing.JOptionPane;
public class PARIMPAR {
@SuppressWarnings("empty-statement")
public static void main(String[] args)
{
String dato1,dato2;
int num1,num2;
do
{
do
{
dato1=JOptionPane.showInputDialog("INGRESE EL NUMERO ");
num1=Integer.parseInt(dato1);
if(num1<6 ||num1>65)
{
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 ");
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.
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.
Importación de librerías al programa
Paquete del programa.

19. 18
}
dato2=JOptionPane.showInputDialog("PRESIONE 1 PARA SALIR 0 PARA VOLVER");
num2=Integer.parseInt(dato2);
}
while(num2==1);
}
}
CORRIDO:
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.

20. 19
6. 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.

21. 20
PROGRAMA:
package prom
ediovalidacion;
import javax.swing.JOptionPane;
public class Promediovalidacion {
public static void main(String[] args)
{
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 {
dato2= JOptionPane.showInputDialog("INGRESE LA NOTA2:");
nota2= Float.parseFloat(dato2);
if(nota2<1||nota2>11) {
Importación de librerías
del programa
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
Condición de la nota ingresada

22. 21
JOptionPane.showInputDialog("VALOR INCORRECTO:");
} }
while(nota2<1||nota2>11);
do {
dato3= JOptionPane.showInputDialog("INGRESE LA NOTA3:");
nota3= Float.parseFloat(dato3);
if(nota3<1||nota3>11) {
JOptionPane.showInputDialog("VALOR INCORRECTO:");
} }
while(nota3<1||nota3>11);
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, "EL ESTUDIANTE: "+nom );
JOptionPane.showMessageDialog(null, "ESTA SUSPENSO CON: "+pro );
JOptionPane.showMessageDialog(null, "EN LA MATERIA DE: "+mat );
}
else {
mensaje
Validación de la nota entre 1 y 10
Ingreso de la tercera
nota
mensaje
Validación de la nota entre 1 y 10
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

23. 22
JOptionPane.showMessageDialog(null, "... REPROBADO ...");
JOptionPane.showMessageDialog(null, "EL ESTUDIANTE: "+nom );
JOptionPane.showMessageDialog(null, "ESTA REPROBADO CON: "+pro );
JOptionPane.showMessageDialog(null, "EN LA MATERIA DE: "+mat );
} }
dato4= JOptionPane.showInputDialog("CONTINUAR1 TERMINAR 0:");
op= Integer.parseInt(dato4);
} while(op==1); }
CORRIDO:
Impresión de
datos de
reprobado:
Nombre
Promedio
Materia
Ciclo
repetitivo n
veces para el
proceso.

24. 23
7. Diseñe un programa que me permita ingresar desde teclado un límite y un factor
cualquiera y generar las tablas de multiplicar.
ANALISIS:
En este programa podemos realizar las tablas de multiplicar; debemos declarar las
variables de tipo enteras, luego ingresamos el límite y el factor, por último visualizamos la
respuesta.
PROGRAMA
public class Tabla {
public static void main(String[] args) {
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:");
Nombre del programa o proyecto
Declaración de variables String,
int
Ingreso de Datos
Inicio del ciclo do-while

25. 24
factor=Integer.parseInt(dato2);
for(i=1;i<=limite;i++)
{
mult=i*factor;
JOptionPane.showMessageDialog(null, "
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:
Proceso de
multiplicación e
impresión de
resultado
Fin del ciclo do-while

26. 25
8. Diseñe un programa que me permita resolver un sistema de ecuaciones de 2°
grado (ax^2 + bx +c).
ANALISIS:
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.
PROGRAMA:
Documentación
package ecuacion;
import javax.swing.JOptionPane;
public class Ecuacion {
public static void main(String[] args) {
Nombre del proyecto
Librería
Inicio del
programa

27. 26
String dato2;
int op ;
do
{
JOptionPane.showMessageDialog
(null,"ECUACION DE SEGUNDO GRADO" );
double a = Double.parseDouble
(JOptionPane.showInputDialog
("Ingrese el primer valor de a: "));
double b = Double.parseDouble
(JOptionPane.showInputDialog
("Ingrese el segundo valor de b: "));
double c = Double.parseDouble
(JOptionPane.showInputDialog
("Ingrese el tercer valor de c: "));
double interno=b*b-(4*a*c);
if (interno==0){
double x1=-b/(2*a);
JOptionPane.showMessageDialog
(null, "Existe un valor doble: " + x1 ) ;
}
else
if(interno>0)
Declaración
de variables
Proceso de
repetición
Impresión de un
mensaje
Ingresamos los tres
valores
Realizamos el
proceso para sacar la
ecuación

28. 27
{
interno = Math.sqrt(interno);
x1=(-b+interno)/(2*a);
x2=(-b-interno)/(2*a);
JOptionPane.showMessageDialog
(null, "valor de x1 y x2: " + x1 +" n"+x2 );
x1=-b/(2*a);
double resultado= Math.sqrt((-interno/(2*a)));
JOptionPane.showMessageDialog
(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);
}
}
}
CORRIDO:
Este es el proceso para
sacar la raíz cuadrada
de la ecuación
Visualizamos el
resultado
Proceso para que el
usuario realice otro
proceso o si desea salir

29. 28
9. 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

30. 29
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
kwattio 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:
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. Ingreso del valor anterior e inicialización del ciclo do while. Ingreso del valor actual,
fin ciclo do while y validación del valor anterior debe ser mayor que el valor actual.
Obtención de los impuestos de bomberos, taza municipal y otros los mismos que su
porcentaje será multiplicado y dividido para 100. 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 , Finalización del ciclo do while principal y
preguntamos si el usuario desea realizar nuevamente otros procesos o si desea salir.
PROGRAMA:
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");
Paquetes del programa
Importación de
librerías del programa
Declaración de variables
String y double
Instrucción formato para
decimales
Inicio ciclo do while principal

31. 30
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;
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%): "
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
Impresión de
resultados

32. 31
+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);
}
}
CORRIDO:
Escaneo de
opción para
repetición del
proceso
Fin ciclo do while validado a 1
Fin del programa

33. 32
10. 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
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
ANALISIS:

34. 33
Debemos importar las bibliotecas que vayamos a utilizar en el programa, en este caso
deberemos importar la librería principal (import javax.swing.JOptionPane ;).
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. Convertimos la variable escoger (de string) a entero y
asignamos el valor de correspondiente. Utilizamos un swtich para realizar cada proceso
del menú. En cada case debemos ingresar los dos valores que usaremos para las
operaciones y convertirlos a datos de tipo entero. 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.
Imprimimos la variable resultante del proceso. Utilizamos un do while para preguntar al
usuario si desea volver a realizar el proceso con diferentes valores. Repetimos el proceso
en cada case con la variación de realizar las posteriores operaciones a la suma. En el
último case utilizamos una instrucción que nos permitirá salir del programa mientras este
corriendo, esto es: System.exit(0);. Preguntamos si el usuario desea realizar nuevamente
otros procesos o si desea salir.
PROGRAMA:
Análisis Flujográmico:
package comision;
import javax.swing.JOptionPane;
public class Comision {
public static void main(String[] args)
{
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" +
Importación de
librerías del programa
Paquetes del
programa
Declaración
de variables
String, int y
double
Impresión del
Menú de
Opciones

35. 34
"n n Con quien desea realizar su venta");
menu=Integer.parseInt(opcion);
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;
comjuan=comjuan+comj;
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>25000 && vjuan<=45000)
{
comj=vjuan*0.06;
comjuan=comjuan+comj;
Transformación de
variables String a int
Incio del Switch con
Case1
Procesos para
operaciones
Decisión if y procesos
Decisión if y procesos
respectivos para
obtener sus distintos
resultados
Decisión if y procesos
respectivos para
obtener sus distintos
resultados

36. 35
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>45000)
{
comj=vjuan*0.85;
comjuan=comjuan+comj;
JOptionPane.showMessageDialog(null, "EMPRESA DON
LUCHO" + "n n VENDEDOR JUAN" + "n n # VENTA: " + numj + "n n Venta=" +
vjuan + "n Comisión= " + comj);
}
}
}
}
opj=JOptionPane.showInputDialog
("Desea realizar una nueva venta con nuestro vendedor Juan
(1 SI/0 NO)");
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"
Decisión if y procesos
respectivos para
obtener sus distintos
resultados
Cierre de sentencias if
Proceso de repetición,
mensaje y cierre del do
while
Case 2 y Do While
Impresión del
nombre y datos
subtitulos
Decisión if y procesos
respectivos para
obtener sus distintos
resultados
Impresión del
nombre y datos
subtitulos

37. 36
+ "n n VENDEDOR MARCELO" + "n n # VENTA: " + nummarc +
"n n Venta=" + vmarc + "n Comisión= " + commarc);
}
else
{
if(vmarc>11000 && vmarc<=25000)
{
commarc=vmarc*0.45;
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
{
if(vmarc>25000 && vmarc<=45000)
{
commarc=vmarc*0.06;
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
{
if(vmarc>45000)
{
commarc=vmarc*0.85;
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);
}
}
}
Decisión if y procesos
respectivos para
obtener sus distintos
resultados
Impresión del
nombre y datos
subtitulos
Decisión if y procesos
respectivos para
obtener sus distintos
resultados
Impresión del
nombre y datos
subtitulos
Decisión if y procesos
respectivos para
obtener sus distintos
resultados
Impresión del
nombre y datos
subtitulos
Cierre de sentencias if

38. 37
}
opj=JOptionPane.showInputDialog("Desea realizar una
nueva venta con nuestro vendedor Marcelo (1 SI/0 NO)");
op=Integer.parseInt(opj);
}
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");
vmar=Integer.parseInt(ventmar);
nummar=nummar+1;
totventma=totventma+vmar;
if(vmar>=8000 && vmar<=11000)
{
commar=vmar*0.03;
commaria=commaria+commar;
JOptionPane.showMessageDialog(null, "EMPRESA DON LUCHO"
+ "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;
commaria=commaria+commar;
JOptionPane.showMessageDialog(null, "EMPRESA DON LUCHO"
+ "n n VENDEDOR MARÍA" + "n n # VENTA: " + nummar +
"n n Venta=" + vmar + "n Comisión= " + commar);
}
else
{
Proceso de repetición,
mensaje y cierre del do
while
Case 3 y Do While
Impresión del
nombre y datos
subtitulos
Impresión del
nombre y datos
subtitulos
Decisión if y procesos
respectivos para
obtener sus distintos
resultados
Impresión del
nombre y datos
subtitulos
Decisión if y procesos
respectivos para
obtener sus distintos
resultados
Impresión del
nombre y datos
subtitulos

39. 38
if(vmar>25000 && vmar<=45000)
{
commar=vmar*0.06;
commaria=commaria+commar;
JOptionPane.showMessageDialog(null, "EMPRESA DON LUCHO"
+ "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;
commaria=commaria+commar;
CJOptionPane.showMessageDialog(null, "EMPRESA DON LUCHO"
+ "n n VENDEDOR MARÍA" + "n n # VENTA: " + nummar +
"n n Venta=" + vmar + "n Comisión= " + commar);
}
}
}
}
opj=JOptionPane.showInputDialog("Desea realizar una
nueva venta con nuestro vendedor María (1 SI/0 NO)");
op=Integer.parseInt(opj);
}
while(op==1);
JOptionPane.showMessageDialog(null,"EMPRESA DON LUCHO"
+ "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);
Impresión del
nombre y datos
subtitulos
Decisión if y procesos
respectivos para
obtener sus distintos
resultados
Decisión if y procesos
respectivos para
obtener sus distintos
resultados
Impresión del
nombre y datos
subtitulos
Cierre de sentencias if
Proceso de repetición,
mensaje y cierre del do
while
Impresión del
nombre y datos
subtitulos
Case 4
Opción Salir
Repetir el Programa
n veces

40. 39
}
while(op==1);
total=totventj+totventm+totventma;
JOptionPane.showMessageDialog(null,"EMPRESA DON LUCHO"
+ "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: "
+ 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:
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
Cierre del programa con
sus respectivas llaves
ves

41. 40

42. 41
11. 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

43. 42
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ú.
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
PROGRAMA:
package matriculas;
import javax.swing.JOptionPane;
import java.text.DecimalFormat;
public class Matriculas {
public static void main(String[] args)
{
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
{
Importación de
librerías del
programa
Paquetes del
programa
Inicio del programa
Declaración de
variables String, int y
double
Do-while proceso de
repetición

44. 43
JOptionPane.showMessageDialog(null," SISTEMA DE MATRICULAS" );
tipo=JOptionPane.showInputDialog("Escoja el tipo de Institucion"
+"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) );
break;
case 2:
prt=prt+pr;
con2=con2+1;
nombre=JOptionPane.showInputDialog("Ingrese el nobre
del estudiante:");
Impresión del Menú
de Opciones
Transformación de
variables String a int
Incio del Switch con
Case1 (primera
opción)
Ingreso de Datos
Procesos
Impresión de
resultados
Break cierre de la
primera opción (case
1)
Inicio Case2
(segunda opción)
Contadores
Ingreso de Datos

45. 44
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: $ "
+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;
Procesos
Impresión de resultados
Break cierre de la
primera opción (case 2)
Inicio Case3 (tercera
opción)
Contadores
Ingreso de Datos
Procesos
Impresión de resultados
Break cierre de la
primera opción (case 2)

46. 45
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 $ "
+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:
Case4 (Opción Salir)
Cierre del switch
Fin del proceso de
repeticion
Procesos Finales
Impresión final
Fin del Programa

47. 46

48. 47
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
ANALISIS:
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.
PROGRAMA:
package prueba;
import java.text.DecimalFormat;
import javax.swing.JOptionPane;
public class Prueba {
public static void main(String[] args) {
String opc1,opc,nom,ce;
double ad=540,ej=1200,ob=340,he,ph,h,pi,ie,co,te,ti,st,sp,op1;
int a,op;
do{
DecimalFormat df=new DecimalFormat(".00");
opc=JOptionPane.showInputDialog(" LIQUIDO TOTAL DE EMPLEADOSn"+"1.-Administrativon"
+"2.-Ejeutivon"+"3.-Obreron"+"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);
Nombre del programa o proyecto
librerías
Declaración de variables
Inicio del programa
Inicio del do-while
Diseño del menú
Ingreso de la opción
Inicio del switch
Ingreso del nombre
Ingreso de las horas
extras

49. 48
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;
ie=ad*0.115;
co=ad*0.025;
te=ie+co;
sp=ad+ph+pi;
st=sp-ie-co;
JOptionPane.showMessageDialog(null," REPORTE
GENERALn"+nom+"nAdministrativo"+"nSueldo "
+ad+"nnIngresos "+ti+"nHoras extras "
+ph+"nCargas familiares "+pi+"nnEgresos "+te+"nIESS "+ie+
"nComisiariato "+co+"nSueldo a recibir "+st);
break;
case 2:
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;
ie=ej*0.115;
co=ej*0.025;
te=ie+co;
sp=ej+ph+pi;
st=sp-ie-co;
JOptionPane.showMessageDialog(null," REPORTE
GENERALn"+nom+"nEjecutivo"+"nSueldo "
+ej+"nnIngresos "+ti+"nHoras extras "
+ph+"nCargas familiares "+pi+"nnEgresos "+te+"nIESS "+ie+
"nComisiariato "+co+"nSueldo a recibir "+st);
Ingreso del número de hijos
Proceso
Proceso
Impresión de resultados
Cierre del case
Ingreso del nombre
Ingreso de las horas
extras
Ingreso del número de hijos
Proceso
Impresión de resultados

50. 49
break;
case 3:
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;
ie=ob*0.115;
co=ob*0.025;
te=ie+co;
sp=ob+ph+pi;
st=sp-ie-co;
JOptionPane.showMessageDialog(null," REPORTE
GENERALn"+nom+"nObrero"+"nSueldo "
+ob+"nnIngresos "+ti+"nHoras extras "
+ph+"nCargas familiares "+pi+"nnEgresos "+te+"nIESS "+ie+
"nComisiariato "+co+"nSueldo a recibir "+st);
break;
case 4:
System.exit(0);
break;
}
opc1=JOptionPane.showInputDialog("Salir 1/0: ");
op1=Integer.parseInt(opc1);
}while(op1==1);
}
}
CORRIDO:
Cierre del case 2
Ingreso del nombre
Ingreso de las horas
extras
Ingreso del número de hijos
Proceso
Impresión de resultados
Cierre del case 2
Impresión de resultados
Proceso
Cierre del case 3
Proceso par salir
Cierre del case 4
Cierre del while
Ingreso para la opción do-while

51. 50
13. Diseñe un programa que me permita realizar las operaciones básicas a través de
un menú de opciones
ANALISIS:
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;)
PROGRAMA:
Programa principal.
package seisop;
import javax.swing.JOptionPane;
import seisop.funcionesop;
public class Seisop {
public static void main(String[] args) {
Importación de librerías
del programa y paquete
Paquetes del programa

52. 51
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.-SUMAn2.-RESTAn3.-MULTIPLICACIONn"+
"4.-DIVISIONn5. -POTENCIACION
n6.-RADICACIONn7.-SALIR");
op1=Integer.parseInt(op);
switch(op1)
{
case 1:
dato1=JOptionPane.showInputDialog("Dato 1 :");
a=Integer.parseInt(dato1);
dato2=JOptionPane.showInputDialog("Dato 2 :");
b=Integer.parseInt(dato2);
sum1=funcionesop.suma1(a, b);
JOptionPane.showMessageDialog(null,"La suma es: "+sum1);
break;
case 2:
do
{
dato1=JOptionPane.showInputDialog("Dato 1 :");
a=Integer.parseInt(dato1);
dato2=JOptionPane.showInputDialog("Dato 2 :");
b=Integer.parseInt(dato2);
}while(a<b);
res1=funcionesop.resta(a, b);
JOptionPane.showMessageDialog(null,"La resta es:"+res1);
break;
Declaración de variables
Menú de Opciones
Transforma de String
a int para switch
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
Impresión del mensaje

53. 52
case 3:
dato1=JOptionPane.showInputDialog("Dato 1 :");
a=Integer.parseInt(dato1);
dato2=JOptionPane.showInputDialog("Dato 2 :");
b=Integer.parseInt(dato2);
mult1=funcionesop.multiplicacion(a, b);
JOptionPane.showMessageDialog(null,"La multiplicacion es:"+mult1);
break;
case 4:
do
{
dato1=JOptionPane.showInputDialog("Dato 1 :");
a=Integer.parseInt(dato1);
dato2=JOptionPane.showInputDialog("Dato 2 :");
b=Integer.parseInt(dato2);
}while(a<b);
div1=funcionesop.division(a, b);
JOptionPane.showMessageDialog(null,"La division es:"+div1);
break;
case 5:
dato1=JOptionPane.showInputDialog("Base :");
a=Integer.parseInt(dato1);
dato2=JOptionPane.showInputDialog("Exponente :");
b=Integer.parseInt(dato2);
pot1=funcionesop.potencia(a, b);
JOptionPane.showMessageDialog(null,"La potencia es:"+pot1);
break;
case 6:
dato1=JOptionPane.showInputDialog("Numero :");
a=Integer.parseInt(dato1);
rad1=funcionesop.radicacion(a);
JOptionPane.showMessageDialog(null,"La raiz es:"+rad1);
break;
}
opa=JOptionPane.showInputDialog("INGRESE 1 CONTINUAR
Y 0 PARA SALIR:");
Ingreso de datos
Llamamos a la clase
Impresión del mensaje
Control para el proceso de la división
Ingreso de datos
Llamamos a la clase
Impresión del mensaje
Ingreso de datos
Llamamos a la clase
Impresión del mensaje
Ingreso de datos
Llamamos a la clase
Impresión del mensaje
Mensaje de do-while para
enviar un mensaje si desea
repetir

54. 53
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;
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);
Nombre del programa principal
Proceso de suma
Proceso de resta
Proceso de multiplicación
Proceso de división
Proceso de potencia

55. 54
return poten;
}
public static double radicacion(double a1)
{
double radical;
radical=Math.sqrt(a1);
return radical;
}
}
CORRIDO:
Proceso de radicación

56. 55
14. Diseñe un menú de opciones que me permita realzar las 6 operaciones básicas con
datos enteros ingresados desde teclado, utilizando clases.
ANALISIS:
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.
Convertimos la variable escoger (de string) a entero y asignamos el valor de
correspondiente. Utilizamos un swtich para realizar cada proceso del menú. 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.
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. Imprimimos la variable resultante del proceso. Utilizamos un do
while para preguntar al usuario si desea volver a realizar el proceso con diferentes valores.
Repetimos el proceso en cada case con la variación de realizar las posteriores operaciones
a la suma.
En el último case utilizamos una instrucción que nos permitirá salir del programa muestras
este corriendo, esto es: System.exit(0);. Preguntamos si el usuario desea realizar
nuevamente otros procesos o si desea salir
PROGRAMA:
package pkg13.operacionesmenu;
import javax.swing.JOptionPane;
Importación de librerías
del programa

57. 56
import pkg13.operacionesmenu.operaciones;
public class Operacionesmenu {
public static void main(String[] args)
{
String dato1,dato2,escoger,opcion;
int num1,num2,suma,resta,multiplicacion,es,op;
double division, potenciacion, radicacion;
{
escoger=JOptionPane.showInputDialog(null, "
OPERACIONES BASICAS nn 1. Suma n 2. Resta n
3. Multiplicación n 4. División n 5. Potenciación n
6. Radicación n 7. Salir nn Escoja una opcion:");
es=Integer.parseInt(escoger);
switch(es)
{
case 1:
do{
dato1=JOptionPane.showInputDialog
("Ingrese el primer valor: ");
num1=Integer.parseInt(dato1);
dato2=JOptionPane.showInputDialog
("Ingrese el segundo valor: ");
num2=Integer.parseInt(dato2);
suma=operaciones.sumar(num1, num2);
JOptionPane.showMessageDialog
(null, "La Suma es: "+ suma);
opcion=JOptionPane.showInputDialog
("Desea realizar otra suma: 1=si / 0=no");
op=Integer.parseInt(opcion);
}while(op==1);
break;
Paquetes del programa
Declaración de variables
String, int y double
Impresión del Menú de
Opciones
Transformación de
variables String a int
Incio del Switch con
Case1
Ingreso de Datos
Llamado de clase o
función
DO WHILE y break

58. 57
case 2
do{
do{
dato1=JOptionPane.showInputDialog
("Ingrese el primer valor: ");
num1=Integer.parseInt(dato1);
dato2=JOptionPane.showInputDialog
("Ingrese el segundo valor: ");
num2=Integer.parseInt(dato2);
}while(num1<num2);
resta=operaciones.restar(num1, num2);
JOptionPane.showMessageDialog
(null, "La Resta es: "+ resta);
opcion=JOptionPane.showInputDialog
("Desea realizar otra resta: 1=si / 0=no");
op=Integer.parseInt(opcion);
}while(op==1);
break;
case 3:
do{
dato1=JOptionPane.showInputDialog
("Ingrese el primer valor: ");
num1=Integer.parseInt(dato1);
dato2=JOptionPane.showInputDialog
("Ingrese el segundo valor: ");
num2=Integer.parseInt(dato2);
multiplicacion=operaciones.multi(num1, num2);
JOptionPane.showMessageDialog
(null, "La Multiplicación es: "+ multiplicacion);
opcion=JOptionPane.showInputDialog
("Desea realizar otra multiplicacion: 1=si / 0=no");
op=Integer.parseInt(opcion);
}while(op==1);
break;
case 4:
do{
do{
dato1=JOptionPane.showInputDialog
("Ingrese el primer valor: ");
Case 2 y Do While
Llamado de clase o
función
DO WHILE y break
Case 3 y Do While
Ingreso de Datos
Llamado de clase o
función
DO WHILE y break
Case 4 y Do While
Validación de datos

59. 58
num1=Integer.parseInt(dato1);
dato2=JOptionPane.showInputDialog
("Ingrese el segundo valor: ");
num2=Integer.parseInt(dato2);
}while(num1<num2);
division=operaciones.dividir(num1, num2);
JOptionPane.showMessageDialog
(null, "La División es: "+ division);
opcion=JOptionPane.showInputDialog
("Desea realizar otra division 1=si / 0=no");
op=Integer.parseInt(opcion);
}while(op==1);
break;
case 5:
do{
dato1=JOptionPane.showInputDialog
("Ingrese la base: ");
num1=Integer.parseInt(dato1);
dato2=JOptionPane.showInputDialog
("Ingrese el exponente: ");
num2=Integer.parseInt(dato2);
potenciacion=operaciones.potencia(num1, num2);
JOptionPane.showMessageDialog
(null, "La Potenciación es: "+ potenciacion);
opcion=JOptionPane.showInputDialog
("Desea realizar otra potenciacion 1=si / 0=no");
op=Integer.parseInt(opcion);
}while(op==1);
break;
case 6:
do{
dato1=JOptionPane.showInputDialog("Ingrese el valor: ");
num1=Integer.parseInt(dato1);
radicacion=operaciones.raiz(num1);
JOptionPane.showMessageDialog
(null, "La Radicacion es: "+ radicacion);
opcion=JOptionPane.showInputDialog
("Desea realizar otra radicación 1=si / 0=no");
op=Integer.parseInt(opcion);
Ingreso de Datos
Validación de datos
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
DO WHILE y break

60. 59
}while(op==1);
break;
case 7:
System.exit(0);
break;
}// fin del switch
opcion=JOptionPane.showInputDialog
("Desea volver al menu: 1=si / 0=no");
op=Integer.parseInt(opcion);
}while(op==1);
}
}
CLASE DEL PROGRAMA
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)
{
Case 7
Opción Salir
Fin del Switch
Repetir el Programa n
veces
Fin del Programa
Nombre del Programa
principal
Inicio de Clase o
Función
Proceso de suma
Proceso de resta
Proceso de
multiplicación

61. 60
int multi;
multi=(a+b);
return multi;
}
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;
}
}
CORRIDO:
Proceso de división
Proceso de
potenciación
Proceso de radicación

62. 61
15. Diseñe un menú de opciones utilizando clases de un conjunto de series de datos:
1. Primo
2. Factorial
3. Fibonacci
4. Pares
5. 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.
PROGRAMA:
package menuseries;
import javax.swing.JOptionPane;
import menuseries.series;
public class Menuseries {
Importación de librerías
del programa

63. 62
public static void main(String[] args)
{
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: ");
op=Integer.parseInt(dato1);
switch(op)
{
case 1:
dato2=JOptionPane.showInputDialog("Ingrese un limite");
limite=Integer.parseInt(dato2);
primos=series.primos(limite);
break;
case 2:
dato2=JOptionPane.showInputDialog("Ingrese un limite");
limite=Integer.parseInt(dato2);
factor=series.facto(limite);
break;
case 3:
dato2=JOptionPane.showInputDialog("Ingrese un limite");
limite=Integer.parseInt(dato2);
fibo=series.fibo(limite);
break;
case 4:
dato2=JOptionPane.showInputDialog("Ingrese un limite");
limite=Integer.parseInt(dato2);
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;
Declaración De
variables String, int y
double
Impresión del
Menú de Opciones
Inicio del Switch con
Case1
Ingreso del límite y
Llamado de clase o
funciónInicio del Switch con
Case 2
Ingreso del límite y
Llamado de clase o
funciónInicio del Switch con
Case 3
Ingreso del límite y
Llamado de clase o
función
Inicio del Switch con Case 4
Ingreso del límite y
Llamado de clase o
función
Fin del Switch con Case 5
Repetir el Programa
n veces
Fin del Programa
Nombre del Programa
principal

64. 63
import javax.swing.JOptionPane;
public class series
{
public static int par (int limite)
{
int p;
int i;
p=0;
for(i=1;i<=limite;i++)
{
p=p+2;
JOptionPane.showMessageDialog(null, +p);
}
return 0;
}
public static int primos (int limite)
{
int conta,residuo,i,j;
for(i=1;i<=limite;i++)
{
conta=0;
for(j=1;j<=i;j++)
{
residuo=i%j;
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;
for(i=1;i<=limite;i++)
{
f=f*i;
JOptionPane.showMessageDialog(null, +i+f);
}
Serie de números pares
Serie de números primos
Serie de números primos
Serie de la factorial

65. 64
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;
}
}
CORRIDO:
Serie del Fibonacci
Fin del programa

66. 65
16. 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.

67. 66
En las clases hacemos el proceso correspondiente mediante un if, else e impresiones de
pantalla.
PROGRAMA:
PROGRAMA
package edades;
import javax.swing.JOptionPane;
public class Edades {
public static void main(String[] args) {
String opcion,dato;
int edad1,op,edades;
do
{
opcion=JOptionPane.showInputDialog(null,"***VERIFICACION DE EDAD***n1 a 3 años BEBEn3
a 11 años NIÑOn12 a 17 años ADOLESCENTEn18 a 45 años ADULTOn45 en adelante ADULTO
MAYORn**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;
import javax.swing.JOptionPane;
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);
Importación de librerías del
programa
Paquetes 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
Proceso

68. 67
}
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;
}
}
CORRIDO:
PROCESO
SE CIERRA LA CLASE

69. 68
17. 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.)
ANALISIS:
Necesitaremos una variable tipo int para generar la descomposición en sus unidades.
PROGRAMA:
package decompocicion;
import javax.swing.JOptionPane;
import decompocicion.descomponer;
public class Decompocicion {
public static void main(String[] args) {
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;
import javax.swing.JOptionPane;
public class descomponer {
public static int descomponer(int a)
{
Importación de librerías
del programa
Paquetes 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

70. 69
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;
JOptionPane.showMessageDialog(null,"Unidad "+u+"nDecena "+d+"nCentena "+c
+"nUnidad de mil "+um+"nTotal "+a);
return 0;
}
}
CORRIDO:
18. Diseñe un programa en java 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
Se necesita convertir un número entero a octal
Se necesita convertir un número 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
Clase descomposición
con su respectivo
proceso para realizar
una descomposición en
sus unidades

71. 70
de una clase para realizar cada conversión, también con la opción de repetir el proceso las
veces que desee el usuario presentando al fin los resultados respectivos que queremos.
PROGRAMA:
package conversiones;
import javax.swing.JOptionPane;
public class Conversiones {
public static void main(String[] args)
{
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: ");
a=Integer.parseInt(dato1);
bi=convers.bi(a);
break;
case 2:
dato1=JOptionPane.showInputDialog("Ingrese un numero: ");
a=Integer.parseInt(dato1);
oc=convers.oct(a);
break;
case 3:
dato1=JOptionPane.showInputDialog("Ingrese un numero: ");
a=Integer.parseInt(dato1);
hexa=convers.he(a);
break;
case 4:
System.exit(0);
break;
}
dato2= JOptionPane.showInputDialog("VOLVER AL MENU 1 SALIR 0: ");
op=Integer.parseInt(dato2);
}
while(op==1);
}
}
CLASE DEL PROGRAMA
Importación de librerías
del programa
Declaración de variables
String, int y double
Impresión del Menú de
Opciones
Inicio del Switch con
Case1 Ingreso el número que
deseo transformar a
binario y llamamos a la
clase
Inicio del Switch con
Case 2 Ingreso el número que
deseo transformar a
octal y llamamos a la
clase
Fin del Programa
Inicio del Switch
con Case 3
Fin del Switch con Case 4
Repetir el
Programa n veces
Ingreso el número que deseo transformar a
hexadecimal y llamamos a la clase

72. 71
package conversiones;
import javax.swing.JOptionPane;
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;
}
}
CORRIDO:
Nombre del Programa
principal
Transformación de un
número decimal a binario
Transformación de un
número decimal a octal
Transformación de
un número decimal a
hexadecimal