Elemento 2 progra

UNIVERSIDAD TÉCNICA DE AMBATO
FACULTAD DE CIENCIAS HUMANAS Y DE LA
EDUCACIÓN
CARRERA DE DOCENCIA EN INFORMÁTICA
PROGRAMACIÓN I
ING. WILMA GAVILANES
TERCER SEMESTRE “A”
RICARDO JARA
ELEMENTO 2
APLICACIONES RESUELTAS PARA FUNDAMENTAR LA
LOGICA DE PROGRAMACION
ABRIL - SEPTIEMBRE 2014
AMBATO – ECUADOR

PROGRAMA Nº1
1.-ENUNCIADO
Utilizando el lenguaje de programación orientado a objetos JAVA realizar una suma ingresando
dos números enteros desde teclado
2.-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," " + );
3.-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
Ingresamos el 1er
numero
Ingresamos el 2do
numero
Operación para hacer la suma
Visualizamos el
resultado

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("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 : ");
do
{
}while(n>m);
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.
Case 1 en este case
resta con impresiones,
proceso y una ultima
impresión para el
resultado. Con un
control de ingreso

c=n-m;
break;
case 3:
d2=JOptionPane.showInputDialog("MULTIPLICACION
n"+"INGRESE EL PRIMER DATO : ");
c=n*m;
break;
case 4:
d2=JOptionPane.showInputDialog("DIVICIONn"+"INGRESE EL PRIMER DATO : ");
do
{
}while(n>m);
c=n/m;
break;
}
d5=JOptionPane.showInputDialog("DESEA REPETIR 1 O 0 PARA SALIR: ");
op1=Integer.parseInt(d5);
}while(op1==1);
}
}
CORRIDO:
Case 1 en este case
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
Fin del ciclo do while
Llaves de finalización del programa

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.
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
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();
break;
del programa
Inicio del programa principal
Menú de opciones
Inicio del menú de opciones
Case 1: para encontrar el perímetro y
el área de un cuadrado
el área de un rectángulo
el área de un círculo

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;
}
el área de un triángulo
el salir del menú
Clase (subprograma) para
calcular el perímetro y el
área de un cuadrado.
Inicio para crear
clases.

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.

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;
}
}
área de un triángulo.

PROGRAMA 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);
}}
DOCUMENTACIÓN
Nombre del programa o
proyecto
Librerí
a
Inicio del
programa
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

ENUNCIADO:
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.
CODIFICACION:
package prom
ediovalidacion;
public class Promediovalidacion {
{
String dato1, dato2,dato3,dato4, nom, mat;
float num, nombre, materia, nota1, nota2, nota3,pro;
int op;
do {
del programa
Ingreso de variables

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 {
} }
pro= (nota1+nota2+nota3)/3;
JOptionPane.showMessageDialog(null,"EL PROMEDIO ES:"+pro );
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
Procesos promedio de notas

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);
} while(op==1); }
Impresión de
datos de
aprobado:
Nombre
Promedio
Condición de la nota >7
Impresión de
datos de
suspenso:
Nombre
Promedio
Impresión de
datos de
reprobado:
Nombre
Promedio
Ciclo
repetitivo n
veces para el
proceso.

Programa 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.
odigo
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, "
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);
}
}
Proceso de
multiplicación e
impresión de
resultado
Declaración de variables String,
int
Ingreso de Datos
Inicio del ciclo do-while
Fin del ciclo do-while

Programa 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
(null,"ECUACION DE SEGUNDO GRADO" );
Nombre del proyecto
Librería
Inicio del
programa
Declaración
de variables
Proceso de
repetición
Impresión de un
mensaje

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);
(null, "valor de x1 y x2: " + x1 +" n"+x2 );
x1=-b/(2*a);
double resultado= Math.sqrt((-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
Visualizamos el
resultado

(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
Proceso para que el
usuario realice otro
proceso o si desea salir

ENUNCIADO
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 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.
DOCUMENTACION:
packageplanilla.de.luz;
importjava.text.DecimalFormat;
importjavax.swing.JOptionPane;
Importación de
librerías del programa

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;
Otros = (cost*2)/100;
Tot=cost+bomb+tasa+otros;
Paquetes 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

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

Programa 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
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.
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);
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;
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
Incio del Switch con
Case1
Procesos para
operaciones
Decisión if y procesos

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);
}
else
{
if(vjuan>25000 && vjuan<=45000)
{
comj=vjuan*0.06;
}
else
{
if(vjuan>45000)
{
comj=vjuan*0.85;
}
}
}
}
opj=JOptionPane.showInputDialog
("Desea realizar una nueva venta con nuestro vendedor Juan
(1 SI/0 NO)");
op=Integer.parseInt(opj);
}
while(op==1);
respectivos para
obtener sus distintos
resultados
respectivos para
resultados
respectivos para
resultados
Cierre de sentencias if
Proceso de repetición,
mensaje y cierre del do
while

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
{
if(vmarc>11000 && vmarc<=25000)
{
commarc=vmarc*0.45;
}
else
{
if(vmarc>25000 && vmarc<=45000)
{
commarc=vmarc*0.06;
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
Impresión del
nombre y datos
subtitulos
respectivos para
resultados
Impresión del
nombre y datos
subtitulos

}
else
{
if(vmarc>45000)
{
commarc=vmarc*0.85;
}
}
}
}
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");
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
respectivos para
resultados
Impresión del
nombre y datos
subtitulos
while
Case 3 y Do While
Impresión del
nombre y datos
subtitulos
Impresión del
nombre y datos
subtitulos
respectivos para
resultados
Impresión del
nombre y datos
subtitulos
respectivos para
resultados

{
if(vmar>11000 && vmar<=25000)
{
commar=vmar*0.45;
+ "n n VENDEDOR MARÍA" + "n n # VENTA: " + nummar +
}
else
{
if(vmar>25000 && vmar<=45000)
{
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)");
}
while(op==1);
+ "n n VENDEDOR MARÍA" + "n n # VENTAS: "
+ nummar + "n n Total de ventas=" + totventma
Impresión del
nombre y datos
subtitulos
Impresión del
nombre y datos
subtitulos
respectivos para
resultados
respectivos para
resultados
Impresión del
nombre y datos
subtitulos
while
Impresión del
nombre y datos
subtitulos

+ "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: "
+ 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 );
}
}
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
Cierre del programa con
sus respectivas llaves

Programa 12
Enunciado:
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;
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);
ph=he*3.50;
librerías
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
Ingreso del número de hijos

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:
do{
}while(he>8);
ph=he*3.50;
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;
GENERALn"+nom+"nEjecutivo"+"nSueldo "
+ej+"nnIngresos "+ti+"nHoras extras "
break;
case 3:
do{
Proceso
Proceso
Impresión de resultados
Cierre del case
Ingreso del nombre
extras
Proceso
Cierre del case 2
Ingreso del nombre
extras

}while(he>8);
ph=he*3.50;
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;
GENERALn"+nom+"nObrero"+"nSueldo "
+ob+"nnIngresos "+ti+"nHoras extras "
break;
case 4:
System.exit(0);
break;
}
opc1=JOptionPane.showInputDialog("Salir 1/0: ");
op1=Integer.parseInt(opc1);
}while(op1==1);
}
}
Corrido:
Proceso
Proceso
Cierre del case 3
Proceso par salir
Cierre del case 4
Cierre del while
Ingreso para la opción do-while

Enunciado:
13.-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.-SUMAn2.-RESTAn3.-MULTIPLICACIONn"+
"4.-DIVISIONn5. -POTENCIACION
n6.-RADICACIONn7.-SALIR");
op1=Integer.parseInt(op);
switch(op1)
del programa y paquete
Menú de Opciones
Transforma de String
a int para switch

{
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
{
}while(a<b);
div1=funcionesop.division(a, b);
JOptionPane.showMessageDialog(null,"La division es:"+div1);
break;
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

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;
sumar=(a1+b1);
return sumar;
}
public static int resta(int a1, int b1)
{
int restar;
restar=(a1-b1);
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
Proceso de resta

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 multiplicación
Proceso de división
Proceso de potencia
Proceso de radicación

Programa #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
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 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: ");
("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");
del programa
String, int y double
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

op=Integer.parseInt(opcion);
}while(op==1);
break;
case 2
do{
do{
}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);
(null, "La Multiplicación es: "+ multiplicacion);
("Desea realizar otra multiplicacion: 1=si / 0=no");
}while(op==1);
break;
case 4:
Case 2 y Do While
Ingreso de Datos
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
Validación de datos

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);
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 4 y Do While
Ingreso de Datos
Llamado de clase o
función
DO WHILE y break
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

(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
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;
DO WHILE y break
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

restar=(a+b);
return restar;
}
public static int multi(int a, int b)
{
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;
}
}
Proceso de
multiplicación
Proceso de división
Proceso de
potenciación
Proceso de radicación

Programa 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.
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
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;
public class edad {
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

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

PROGRAMA 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.)
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;
JOptionPane.showMessageDialog(null,"Unidad "+u+"nDecena "+d+"nCentena "+c
+"nUnidad de mil "+um+"nTotal "+a);
return 0;
}
}
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

PROGRAMA 18
ENUNCIADO:
Diseñe un menú de opciones utilizando clases que me permita diseñar un
sistema de conversiones de numeros de diferentes bases.
Se necesita convertir un numero 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:
hexa=convers.he(a);
break;
case 4:
System.exit(0);
del programa
String, int y double
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
Inicio del Switch
con Case 3
Fin del Switch con Case 4
Ingreso el número que deseo transformar a
hexadecimal y llamamos a la clase

break;
}
dato2= JOptionPane.showInputDialog("VOLVER AL MENU 1 SALIR 0: ");
op=Integer.parseInt(dato2);
}
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;
}
}
CORRIDO DEL PROGRAMA:
Fin del Programa
Nombre del Programa
principal
Transformación de un
número decimal a binario
Repetir el Programa
n veces
número decimal a octal
número decimal a
hexadecimal

Elemento 2 progra

Más contenido relacionado

La actualidad más candente (19)

Similar a Elemento 2 progra (20)

Más de Rikrdo Jara (7)

Elemento 2 progra