1
2
INDICE
INTRODUCCION ................................................................................................................. 3
LENGUAJE DE PROGRAMACION JAVA ....................................................................... 4
CONCEPTUALIZACIONES ............................................................................................... 5
PRINCIPALES CARACTERISTICAS DE JAVA ............................................................. 7
RECOMENDACIONES ....................................................................................................... 8
CONJUNTO DE PALABRAS RESERVADAS DE JAVA ............................................... 8
SEPARADORES ................................................................................................................11
OPERADORES ..................................................................................................................12
OPERADORES UNARIOS. ..........................................................................................12
OPERADORES BINARIOS. .........................................................................................12
TIPOS DE DATOS PRIMITIVOS: ...................................................................................13
DECLARACIÓN DE VARIABLES. ..................................................................................14
ESTRUCTURAS DE CONTROL EN JAVA ...................................................................14
ESTRUCTURAS CONDICIONALES ..........................................................................15
ESTRUCTURAS DE REPETICIÓN ............................................................................17
CLASES EN JAVA .............................................................................................................19
DEFINICIÓN DE UNA CLASE EN JAVA .......................................................................19
COMO CREAR UNA CLASE EN JAVA .........................................................................20
APLICACIONES SENCILLAS UTILIZANDO SENTENCIAS DE CONTROL PARA
DESARROLLAR LA LOGICA DE LA PROGRAMACION EN JAVA ........................21
BIBLIOGRAFIA...................................................................................................................72
3
INTRODUCCION
Los lenguajes de programación son idiomas artificiales diseñados para expresar
cálculos y procesos que serán llevados a cabo por ordenadores. Un lenguaje de
programación está formado por un conjunto de palabras reservadas, símbolos y
reglas sintácticas y semánticas que definen su estructura y el significado de sus
elementos y expresiones. Se llama Programación a la implementación de un
algoritmo en un determinado lenguaje de programación, para realizar un
programa, es el idioma utilizado para controlar el comportamiento de una máquina,
particularmente una computadora. Hay muchos lenguajes de programación, pero
para programar no es necesario conocer todos los lenguajes, es igual que cuando
hablamos, podemos comunicarnos en español aunque no sepamos alemán.
Aunque la palabra debería ser idioma ya que lenguaje realmente abarca todos los
idiomas pero en computación equivocadamente se usa el término lenguaje cuando
el término correcto es idiomas de programación. En la actualidad los lenguajes de
programación están escritos para ser comprensibles por el ser humano, a este
código se le llama código fuente, pero no es comprendido por la máquina ya que
esta solo maneja el lenguaje binario. El estudio de los lenguajes de programación
requiere a su vez comprender perfectamente los tipos de lenguajes de
programación que existen y la clasificación comúnmente aceptada que a éstos se
les da. Existen diversos lenguajes y paradigmas de programación para facilitar la
tarea de programación en diferentes ámbitos. Por ejemplo, la programación
orientada a objetos es un paradigma dirigido al mejoramiento en la calidad del
software por medio de la observación de aspectos tales como la corrección,
robustez, extensibilidad, compatibilidad y sobre todo la reusabilidad del software.
La programación lógica, por su parte, es un paradigma orientado a la expresión de
los problemas en términos lógicos para su posterior solución por métodos de
inferencia y técnicas lógicas. En la práctica, cada paradigma de programación es
implementado a través de diversos lenguajes. Solo como un ejemplo, la
programación orientada a objetos encuentra recipientes en lenguajes JAVA, C++,
Eiffel, Objetive c, etc.
4
LENGUAJE DE PROGRAMACION JAVA
Es un lenguaje de programación de propósito general,
concurrente, orientado a objetos y basado en clases que fue
diseñado específicamente para tener tan pocas dependencias
de implementación como fuera posible. Su intención es
permitir que los desarrolladores de aplicaciones escriban el
programa una vez y lo ejecuten en cualquier dispositivo, lo que
quiere decir que el código que es ejecutado en una plataforma
no tiene que ser recompilado para correr en otra.
El término Java fue acuñado en una cafetería frecuentada por
algunos de los miembros del equipo: JAVA = James Gosling,
Arthur Van Hoff, y Andy Bechtolsheim. JAVA = Just Another
Vague
5
CONCEPTUALIZACIONES
“Java" tiene como objetivo
conseguir que los
desarrolladores de
software que sean nuevos
en la tecnología Java estén
listos y en movimiento con
la programación orientada
a objetos (OOP). También no es solo un
lenguaje de programación,
sino toda una plataforma;
sin embargo en este
material, salvo indicación
expresa, se estará
haciendo referencia al
lenguaje de programación
como tal
Desarrollado por Sun
Microsystems (actualmente
propiedad de Oracle), Java
es un lenguaje de
programación orientado a
objetos (P.O.O) y es
considerado de propósito
general. Como lenguaje de
programación.
6
7
PRINCIPALES CARACTERISTICAS DE JAVA
No permite la sobrecarga
de operadores.
Java tienen una clase String, que permite
un mejor manejo que los arrays de
terminación nula del C y C++.
Interpretado Dinámico
Alto Rendimiento: sobre todo con la
aparición de hardware
especializado y mejor software
No ofrece herencia múltiple.
Maneja los comandos en línea
de diferente manera que C++
Portable
Seguro
8
RECOMENDACIONES
Conviene conocer y seguir estas reglas:
• Los nombres de las clases deben empezar por mayúscula.
• Los atributos y métodos de las clases deben empezar por minúsculas y si
están formadas por varias
Palabras, se escriben sin espacios y la primera letra de cada palabra en
mayúscula.
• Las instancias de las clases siguen la misma recomendación que los
métodos y atributos.
• Las constantes se escriben en mayúsculas.
CONJUNTO DE PALABRAS RESERVADAS DE JAVA
• abstract
• continue
• for
• new
• switch
• boolean
• default
• goto
• null
• synchronized
• break
• do
• if
• package
• this
• byte
• double
• implements
• private
• threadsafe
• byvalue
• else
• import
• protected
• throw
• case
• extends
• instance
• of
• public
• transient
• catch
• false
• int
• return
• true
En Java existen ciertas reglas de codificación que
son comúnmente utilizadas por los programadores.
9
ENTORNO DE DESARROLLO
PARA JAVA
BlueJ: desarrollado
como un proyecto de investigación universitaria,
es libre. Eclipse:
desarrollado por la
Fundación Eclipse, es libre y de código abierto,
IntelliJ IDEA: desarrollado por JetBrains,
es comercial.
NetBeans – gratuito y de
código abierto.
JCreator: desarrollado
por Xinox, , es comercial
pero también existe la versión gratuita.
Sun Java Studio
Enterprise: desarrollado por Sun, es comercial.
10
11
SEPARADORES
En Java existen seis separadores distintos. A continuación se muestra el
uso de cada uno de ellos.
Los paréntesis ():
*Delimitan listas de parámetros.
*Modifican la precedencia de una expresión.
*Delimitan condiciones.
*Indican el tipo en las coerciones.
La coma «,»:
Separan identificadores en declaraciones.
Encadenan expresiones.
El punto y coma «;»:
Terminan instrucciones.
El punto «.»:
Acceden a los atributos y métodos de una clase.
Los corchetes []:
Declaran vectores y permiten acceder a sus elementos.
Las llaves {}:
Definen bloques de código.
Delimitan las listas de valores iniciales de los arrays.
12
OPERADORES
Los operadores son aquellos que tras realizar una operación devuelven un
resultado, estos se puede caracterizar por el número de operadores, el tipo de
operando, y el resultado que generan.
Número de operando. Pueden ser de dos tipos unarios, y binarios. Los unarios son
aquellos que solo necesitan de un operando para devolver un valor, mientras que
los binarios necesitan de dos o más operados.
OPERADORES UNARIOS.
OPERADORES BINARIOS.
Operador Descripción
- Cambio de signo
! Operador NOT
~ Complemento a 1
Operadores Descripción
+ - * / % Operadores aritméticos
== != < > <= >= Operadores relacionales
&& || ^ Operadores booleanos
^ << >> >>> Operadores a nivel de bit
+ Concatenación de cadenas
13
TIPOS DE DATOS PRIMITIVOS:
Es posible recubrir los tipos primitivos para tratarlos como cualquier otro objeto en
Java. Así por ejemplo: existe una clase envoltura del tipo primitivo int llamado
Integer. La utilidad de estas clases envoltura quedará clara cuando veamos las
clases contenedoras de datos.
En Java existen además de objetos tipos de datos
primitivos (int, float, etcétera). Al contrario que en C o C++
en Java el tamaño de los tipos primitivos no depende del
sistema operativo o de la arquitectura, en todas las
arquitecturas y bajo todos los sistemas operativos el
tamaño en memoria es el:
14
DECLARACIÓN DE VARIABLES.
ESTRUCTURAS DE CONTROL EN JAVA.
Las estructuras de control en Java presentan escasas diferencias con respecto a
C/C++, no obstante existen diferencias. Recordemos que se llama programación
estructurada al uso correcto de las estructuras de control, que se resume en que
toda estructura de control debe tener un único punto de entrada y un único punto
de salida.
Siempre es aconsejable asignar un valor por defecto en el momento
de declaración de una variable. En algunos casos, incluso, se
producirá un error durante la compilación si hemos olvidado iniciar
alguna variable.
Int a, b;
15
ESTRUCTURAS CONDICIONALES
Dos son las estructuras de control condicionales en Java: bifurcación y selección
múltiple.
Bifurcación: if-else, if-else-if
Es necesario que la condición sea una variable o expresión booleana. Si sólo
existe una instrucción en el bloque, las llaves no son necesarias. No es necesario
que existe un bloque else.
SINTAXIS
if(condición) {
instruccion1 ();
instruccion2 ();
// Etc.
} Else {
instruccion1 ();
instruccion2 ();
// etc.
}
16
Selección múltiple: switch.
La expresión ha de ser una variable de tipo entero o una expresión de tipo entero.
Cuando se encuentra coincidencia con un case se ejecutan las instrucciones a él
asociadas hasta encontrar el primer break. Si no se encuentra ninguna
coincidencia se ejecutan las instrucciones en default. La sección default es
prescindible.
SINTAXIS
Switch (expresión) {
Case valor1:
Instrucciones ();
Break;
Case valor2:
Instrucciones ();
Break;
Default:
Instrucciones ();
}
17
ESTRUCTURAS DE REPETICIÓN
En Java las estructuras de repetición son las mismas que en C/C++. A
continuación se detallan y se indican las pequeñas diferencias con respecto a
C/C++.
Repetición sobre un rango determinado. For
Bucles for, su sintaxis es la siguiente:
No es necesario que la condición se base exclusivamente en la variable de control
del bucle. En la parte de iniciación se puede declarar una variable de control del
bucle cuyo ámbito será el bucle.
Tanto en la parte de iniciación como de incremento se puede incluir varias
expresiones separadas por comas, pero nunca en la parte de condición. La
condición ha de ser una variable booleana o una expresión que se evalué a un
valor booleano.
SINTAXIS
For (iniciación; condición;
incremento)
{
// Bloque de instrucciones
}
18
Repeticiones condicionales: while, do while.
Su sintaxis y funcionamiento son iguales que en C/C++, en la estructura de control
while evalúa la condición antes de ejecutar el bloque de la estructura; en la
do...while se evalúa la condición después de la ejecución del bloque.
Igual que en el caso del for la condición ha de ser una variable booleana o una
expresión que se evalúe a un valor booleano.
SINTAXIS
While (condición) {
// Bloque de instrucciones
}
Do {
// Bloque de instrucciones
}
While (condición);
19
CLASES EN JAVA
.
DEFINICIÓN DE UNA CLASE EN JAVA
La programación orientada a objetos (POO) abstrae las entidades del
mundo real como objetos y las relaciones entre ellos como paso de
mensajes. Los objetos son instancias o ejemplares de una clase o plantilla
y poseen como características atributos (valores) y métodos (acciones).
Java es un lenguaje de programación orientado a objetos. Todo en Java,
con la excepción de los tipos primitivos, es un objeto
Una clase en Java agrupa un conjunto de atributos y un conjunto de métodos bajo un nombre común.
Cuando creamos una nueva clase que no extiende a ninguna otra, implícitamente se están heredando las propiedades (atributos) y el comportamiento (métodos) de la clase raíz Object
En el momento de la declaración se debe especificar desde donde se puede acceder a la nueva clase.
20
COMO CREAR UNA CLASE EN JAVA
Dar clic en
la opcion
ARCHIVO
Escoger la
opcion
JAVA
CLASS
Asignarle
un nombre
a tu clase
21
APLICACIONES SENCILLAS UTILIZANDO SENTENCIAS DE
CONTROL PARA DESARROLLAR LA LOGICA DE LA
PROGRAMACION EN JAVA
EJERCICIO 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 realizar la suma de 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.
3.-DOCUMENTACION
package sumadenumeros1;
import javax.swing.JOptionPane;
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..: ");
num2=Integer.parseInt(dato2);
num3=num1+num2;
JOptionPane.showMessageDialog(null,"la suma es..: " + num3);
}
}
4.-CORRIDO DEL PROGRAMA
Nombre del programa o proyecto
Librería
Inicio del programa
Declaración de variables de tipo
caracter
Ingresamos el 1er
numero
Ingresamos el 2do
numero
Operación para hacer la suma
Visualizamos el
resultado
22
EJERCICIO N.-2
1. ENUNCIADO:
Diseñar un programa en JAVA que me permita resolver las operaciones
básicas.
2. 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 switch para una mejor presentación.
3. DOCUMENTACION:
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("SUMA\n"+"INGRESE EL PRIMER DATO : ");
n=Integer.parseInt(d2);
d3=JOptionPane.showInputDialog("INGRESE EL SEGUNDO DATO : ");
m=Integer.parseInt(d3);
c=n+m;
JOptionPane.showMessageDialog(null,"RESPUESTA : "+c);
break;
case 2:
d2=JOptionPane.showInputDialog("RESTA\n"+"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);
Importación de librerías
del programa
Declaración de variables
Inicio del ciclo do
Impresión del Menú de
Opciones
Inicio del switc
Proceso para la suma
con impresiones Y EL
resultado.
Proceso para la resta
con impresiones,
resultado y Con un
control de ingreso
23
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("DIVICION\n"+"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);
}
}
4. CORRIDO DEL PROGRAMA:
Proceso para la
multiplicación
impresiones,
resultado
Proceso para la
división con
impresión para
el resultado.
Con un control
de ingreso
Fin del ciclo do while
Finalización del programa
24
EJERCICIO N.-3
1. ENUNCIADO:
Diseñe un programa que me permita ingresar los datos correspondientes para
obtener el área y el perímetro de las 4 figuras básicas.
2. 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.
3. DOCUMENTACIÓN:
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
\n\n1.- Cuadrado \n2.- Rectángulo \n3.- Círculo \n4.- Triángulo
\n5.- Salir \n\nQue 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
Encontrar el perímetro y el área de
un cuadrado
Encontrar el perímetro y el área de
un rectángulo
25
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;
}
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);
Encontrar el perímetro y el área de
un triángulo
Salir del menú
Clase (subprograma) para
calcular el perímetro y el
área de un cuadrado.
Clase (subprograma) para
calcular el perímetro y el
área de un rectángulo.
CLASE
26
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;
}
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;
}
}
Clase (subprograma) para
calcular el perímetro y el
área de un círculo.
Clase (subprograma) para
calcular el perímetro y el
área de un triángulo.
27
4. CORRIDO DEL PROGRAMA.
EJERCICIO Nª 4
1. ENUNCIADO
Diseñe un programa que me permita realizar la potenciación y radicación.
2. 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.
3. DOCUMENTACION:
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);
Nombre del programa o proyecto
Librería
Inicio del programa
Declaración de variables de tipo caracter
Ingresamos la
base de la
potenciación
28
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);
}}
4. CORRIDO DEL PROGRAMA:
Ingresamos el exponente
Visualizamos el resultado
Ingresamos el índice de la raíz
Formula o proceso para poder realizar la
radicación
Visualizamos el resultado
29
EJERCICIO Nª 5
1. ENUNCIADO: Diseñe un programa que me permita ingresar un número entero
desde teclado y verificar si el número es par o impar.
2. 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.
3. DOCUMENTACION:
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");
}
}
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.
Cerramos la sentencia do while e indicamos el rango que
queremos en el que se encuentre los números.
Importación de librerías al programa
Paquete del programa.
30
while(num1<6 || num1>65);
if(num1%2==0)
{
JOptionPane.showMessageDialog(null,"EL NUMERO "+num1+" ES PAR ");
}
else
{
JOptionPane.showMessageDialog(null,"EL NUMERO "+ num1+" ES IMPAR ");
}
dato2=JOptionPane.showInputDialog("PRESIONE 1 PARA SALIR 0 PARA VOLVER");
num2=Integer.parseInt(dato2);
}
while(num2==1);
}
}
4. CORRIDO DEL PROGRAMA:
Utilizamos la condición if para determinar si es para o impar.
Si la condición se cumple imprimimos que es par y cerramos las
llaves.
Caso contrario, abrimos
llaves.
Se imprime que es impar y cierra las llaves.
Escribimos un mensaje para repetir o no el
programa. Se cierra la sentencia do while que permite repetir el proceso
varias veces.
FIN del programa.
31
EJERCICIO Nª 6
1. ENUNCIADO: Diseñe un programa que me permita ingresar 3 valores flotantes
desde teclado que estén entre 1 y 10, obtenga el promedio correspondiente y
determine su equivalencia: aprobado, reprobado y suspenso
Si el promedio es > = 7 Aprobado
Si el promedio es > 5 y < 7 Suspenso
Si el promedio es < = 5 Reprobado
2. 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. Y por último utilizaremos otro do While para
repetir el proceso las veces que el usuario desee.
3. DOCUMENTACION:
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) {
Importación de
librerías del programa
Ingreso de variables
Ingreso de datos
nombre y materia
del estudiante
Ingreso de la
primera nota
32
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) {
JOptionPane.showInputDial og("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) {
mensaje
Ingreso de la segunda
nota
Validación de la nota entre 1 y 10
mensaje
Condición de la nota ingresada
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:
Condición de la nota >7
33
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 {
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); }
4. CORRIDO DEL PROGRAMA:
Impresión de
datos de
suspenso:
Impresión de
datos de
reprobado:
34
EJERCICIO Nª 7
1. ENUNCIADO: Diseñe un programa que me permita ingresar desde teclado
un límite y un factor cualquiera y generar las tablas de multiplicar.
2. 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.
3. DOCUMENTACION:
public class Tabla { public static void main(String[] args) { String dato1,dato2,dato3,dato4; int l imite,factor,i,mult,op=0,opci,a,b,c,factorial;
do { JOptionPane.showMessageDialog(null, "
<< SERIE DE DATOS >> \n" + "TABLA DE MULTIPLICAR"); dato1=JOptionPane.showInputDial og("INGRESE EL LIMITE:"); l imite=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); } }
4. CORRIDO DEL PROGRAMA:
Nombre del programa o proyecto
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
35
EJERCICIO Nª 8
1. ENUNCIADO: Diseñe un programa que me permita resolver un sistema de
Ecuación de Segundo Grado (ax^2 + bx +c).
2. 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 .
3. DOCUMENTACIÓN:
package ecuacion;
import javax.swing.JOptionPane;
public class Ecuacion {
public static void main(String[] args) {
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
Nombre del proyecto
Librería
Inicio del
programa Declaración
de variables
Proceso de
repetición
Impresión de un
mensaje
Ingresamos los tres
valores
36
("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)
{
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);
}
}
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
Proceso para que el
usuario realice otro
proceso o si desea salir
37
4. CORRIDO DEL PROGRAMA:
EJERCICIO Nª 9
1. 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
2. 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.
3. DOCUMENTACION:
packageplanilla.de.luz;
importjava.text.DecimalFormat;
importjavax.swing.JOptionPane;
Importación de librerías
del programa
38
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;
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%): "
Declaración de variables 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
Impresión de
resultados
Inicio ciclo do while principal
39
+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);
}
}
4. CORRIDO DEL PROGRAMA:
EJERCICIO Nª 10
1. 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
Escaneo de
opción para
repetición del
proceso
Fin ciclo do while validado a 1
Fin del programa
40
Se necesita conocer el valor acumulado por cada vendedor y el valor total
generado por comisión
2. ANÁLISIS:
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. Preguntamos si el usuario desea realizar
nuevamente otros procesos o si desea salir.
3. DOCUMENTACION:
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" +
"\n \n Con quien desea realizar su venta");
menu=Integer.parseInt(opcion);
switch(menu)
{
Importación de librerías
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
41
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;
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
42
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>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);
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
{
+ "\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)
{
Decisión if y procesos
respectivos para obtener
sus distintos resultados
Proceso de repetición,
mensaje y cierre del do
while
Case 2 y Do While
Decisión if y procesos
respectivos para obtener
sus distintos resultados
43
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;
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;
Impresión del nombre y
datos subtítulos
Decisión if y procesos
respectivos para obtener
sus distintos resultados
Impresión del nombre y
datos subtítulos
Decisión if y procesos
respectivos para obtener
sus distintos resultados
Impresión del nombre y
datos subtítulos
Decisión if y procesos
respectivos para obtener
sus distintos resultados
44
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);
}
}
}
}
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
{
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 +
Impresión del nombre y
datos subtítulos
Cierre de sentencias if
Proceso de repetición,
mensaje y cierre del do
while
Case 3 y Do While
Impresión del nombre y
datos subtítulos
Impresión del nombre y
datos subtítulos
45
"\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
{
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;
Decisión if y procesos
respectivos para obtener
sus distintos resultados
Impresión del nombre y
datos subtítulos
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 subtítulos
46
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);
}
while(op==1);
total=totventj+totventm+totventma;
JOptionPane.showMessageDialog(null,"EMPRESA DON LUCHO"
+ "\n \n VENDEDOR JUAN" + "\n \n # VENTAS: "
Cierre de sentencias if
Proceso de repetición,
mensaje y cierre del do
while
Impresión del nombre y
datos subtítulos
Case 4 Opción Salir
Suma total de las comisiones
de vendedores
47
+ 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 );
}
4. CORRIDO DEL PROGRAMA:
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
48
EJERCICIO N.-11
1. ENUNCIADO: Diseñe un programa que me permita calcular el valor por concepto
de matrículas de una institución educativa bajo los siguientes parámetros:
Las matriculas se cobran de forma diferenciada de acuerdo al tipo de institución
que puede ser:
Publica costo de la matricula: $120,00
Particular costo de la matricula: $190,00
Fisco misional costo de la matricula: $140,00
Todos los estudiantes independientemente del tipo de institución cancelan los
siguientes aranceles por beneficios extras que le concede la institución, estos son:
3% de la Matricula corresponde al Servicio Medico
8% de la Matricula corresponde al Servicio de Internet
6% de la Matricula corresponde al Servicio de Deportes
El sistema debe visualizar y reflejar el # de estudiantes matriculados por día, el
valor total acumulado por tipo de institución y por tipo de arancel, además que
debe visualizar el Boucher individual de cada estudiante.
2. ANÁLISIS: 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
3. DOCUMENTACIÓN:
package matriculas;
import javax.swing.JOptionPane;
import java.text.DecimalFormat;
public class Matriculas {
public static void main(String[] args)
{
String nombre,tipo,ret,repet;
Importación de
librerías del programa
Declaración de
variables String, int y
double
49
int t,op1, op;
double p=120,pr=190,f1=140,con1=0,con2=0,con3=0,
sm1,sd1,si1,t1,sm2,sd2,si2,t2,sm3,sd3,si3,t3,sm11=0,
sd11=0,si11=0,sm22=0,sd22=0,si22=0,sm33=0,sd33=0,
si33=0,pt=0,prt=0, ft=0,cont, mt, smt, sit,sdt,st,tt;
DecimalFormat f=new DecimalFormat(".00");
do
{
JOptionPane.showMessageDialog(null," SISTEMA DE MATRICULAS" );
tipo=JOptionPane.showInputDialog("Escoja el tipo de Institucion"
+"\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:");
sm2=(pr*3)/100;
sm22=sm22+sm2;
sd2=(pr*8)/100;
Impresión del Menú de
Opciones
Transformación de
variables String a int
Incio del Switch con
Case1 (primera opción)
Do-while proceso de
repetición
Ingreso de Datos
Procesos
Impresión de resultados
Ingreso de Datos
Procesos
50
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;
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;
Impresión de resultados
Ingreso de Datos
Procesos
Impresión de resultados
Procesos Finales
51
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));
}
}
4. CORRIDO DEL PROGRAMA:
Impresión
final
Fin del Programa
52
EJERCICIO N.-12
1. 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 está 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
2. 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. 3. DOCUMENTACION:
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 EMPLEADOS\n"+"1.-Administrativo\n" +"2.-Ejeutivo\n"+"3.-Obrero\n"+"5.-Salir");
op=Integer.parseInt(opc); switch(op) { case 1:
nom=JOptionPane.showInputDialog("Nombre: "); do{ he=Double.parseDouble(JOptionPane.showInputDialog("Horas extras: "));
}while(he>8); ph=he*3.50; h=Double.parseDouble(JOptionPane.showInputDialog("Hijos: ")); if(h>2)
{
Nombre del programa o proyecto
Librerías
Declaración de variables
Inicio del do-while
Diseño del menú
Inicio del
switch
Ingreso del nombre
Ingreso de las horas
extras
Ingreso del número de hijos
53
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 GENERAL\n"+nom+"\nAdministrativo"+"\nSueldo " +ad+"\n\nIngresos "+ti+"\nHoras extras "
+ph+"\nCargas familiares "+pi+"\n\nEgresos "+te+"\nIESS "+ie+ "\nComisiariato "+co+"\nSueldo a recibir "+st); break; case 2:
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 GENERAL\n"+nom+"\nEjecutivo"+"\nSueldo "
+ej+"\n\nIngresos "+ti+"\nHoras extras " +ph+"\nCargas familiares "+pi+"\n\nEgresos "+te+"\nIESS "+ie+ "\nComisiariato "+co+"\nSueldo a recibir "+st); 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) {
Procesos
Impresión de resultados
Ingreso de las horas
extras
Ingreso del número de hijos
Procesos
Ingreso del nombre
Ingreso de las horas
extras
Ingreso del número de hijos
54
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 GENERAL\n"+nom+"\nObrero"+"\nSueldo " +ob+"\n\nIngresos "+ti+"\nHoras extras " +ph+"\nCargas familiares "+pi+"\n\nEgresos "+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); } }
4. CORRIDO DEL PROGRAMA:
Procesos
Impresión de resultados
Proceso para salir
DO while
55
EJERCICIO N.-13
1. ENUNCIADO: Diseñe un programa que me permita realizar las operaciones
básicas a través de un menú de opciones.
2. 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;).
3. DOCUMENTACION:
package seisop;
import javax.swing.JOptionPane;
import seisop.funcionesop;
public class Seisop {
public static void main(String[] args) {
String dato1,dato2,op,opa;
int a,b,op1,sum1,res1,mult1,opb;
double div1,pot1,rad1;
do{
op=JOptionPane.showInputDialog("ESCOJA UNA OPCION
\n1.-SUMA\n2.-RESTA\n3.-MULTIPLICACION\n"+
"4.-DIVISION\n5. -POTENCIACION
\n6.-RADICACION\n7.-SALIR");
op1=Integer.parseInt(op);
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;
Importación de librerías del
programa y paquete
Paquetes del programa
Declaración de variables
Menú de Opciones
Transforma de String
a int para switch
Ingreso de datos
Llamamos a la clase
56
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;
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(nul l,"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);
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
Llamamos a la clase
Ingreso de datos
Llamamos a la clase
Ingreso de datos
57
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);
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);
Mensaje de do-while para
repetir
Nombre del programa principal
Proceso de suma
Proceso de resta
Proceso de multiplicación
Proceso de división
Proceso de potencia
58
return poten;
}
public static double radicacion(double a1)
{
double radical;
radical=Math.sqrt(a1);
return radical;
}
}
4. CORRIDO DEL PROGRAMA:
EJERCICIO N.-14
1. ENUNCIADO: Diseñe un menú de opciones que me permita realzar las 6
operaciones básicas con datos enteros ingresados desde teclado, utilizando
clases.
2. 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;). Preguntamos si el usuario desea
realizar nuevamente otros procesos o si desea salir.
Proceso de
radicación
59
3. DOCUMENTACIÓN:
package pkg13.operacionesmenu;
import javax.swing.JOptionPane;
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 \n\n 1. Suma \n 2. Resta \n
3. Multiplicación \n 4. División \n 5. Potenciación \n
6. Radicación \n 7. Salir \n\n Escoja una opcion:");
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;
case 2
do{
do{
dato1=JOptionPane.showInputDialog
("Ingrese el primer valor: ");
Importación de librerías del
programa
Declaración de
variables String, int y
double
Impresión del Menú de
Opciones
Transformación de
variables String a int
Ingreso de Datos
Llamado de clase o
función
DO WHILE y break
Ingreso de Datos
60
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: ");
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");
Llamado de clase o
función
DO WHILE y break
Ingreso de Datos
Llamado de clase o
función
DO WHILE y break
Ingreso de Datos
Validación de datos
Validación de datos
61
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);
}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);
Ingreso de Datos
Llamado de clase o
función
DO WHILE y break
Ingreso de Datos
Llamado de clase o
función
Fin del Switch
Repetir el Programa n
veces
Fin del Programa
62
//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)
{
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;
Inicio de Clase o
Función
Proceso de suma
Proceso de resta
Proceso de
multiplicación
Proceso de división
Proceso de
potenciación
Proceso de radicación
63
4. CORRIDO DEL PROGRAMA:
EJERCICIO N.-15
1. ENUNCIADO: Diseñe un menú de opciones utilizando clases de un
conjunto de series de datos: primos, factorial, Fibonacci, pares, y la opción
salir.
2. 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.
3. DOCUMENTACIÓN:
package menuseries;
import javax.swing.JOptionPane; import menuseries.series; public class Menuseries {
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"); l imite=Integer.parseInt(dato2);
primos=series.primos(limite);
Importación de
librerías del programa
Declaración de
variables String, int y
double
Impresión del Menú de
Opciones
Ingreso del límite y
Llamado de clase o
función
64
break;
case 2: dato2=JOptionPane.showInputDialog("Ingrese un limite"); l imite=Integer.parseInt(dato2);
factor=series.facto(limite); break; case 3: dato2=JOptionPane.showInputDialog("Ingrese un limite");
l imite=Integer.parseInt(dato2); fibo=series.fibo(limite); break;
case 4:
dato2=JOptionPane.showInputDialog("Ingrese un limite"); l imite=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; import javax.swing.JOptionPane; public class series {
public static int par (int l imite) { 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 l imite) {
int conta,residuo,i,j;
Ingreso del límite y
Llamado de clase o
función
Ingreso del límite y
Llamado de clase o
función
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
Serie de numeros pares
65
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 l imite)
{ int f,i; f=1;
i=1; i=i+1; for(i=1;i<=limite;i++) {
f=f*i; JOptionPane.showMessageDialog(null, +i+f); } return 0;
} public static int fibo(int l imite) {
int m,i,j,c,a = 0,b=1; m=1; for(j=1;j<=limite-1;j++) {
m=m+3; } for(i=0;i<=limite-2;i++)
{ c=a+b; a=b; b=c;
JOptionPane.showMessageDialog(null, +a); } return 0; }
}
Serie de numeros primos
Serie de numeros primos
Serie de la factorial
Serie del Fibonacci
66
4. CORRIDO DEL PROGRAMA:
EJERCICIO N.-16
1. ENUNCIADO: Diseñe un programa utilizando clases que me permita
verificar si un numero entero ingresado desde teclado le corresponde a la
siguiente categoría:
1 – 3 Bebé
3 – 11 Niño
12 – 17 Adolescente
18 – 45 Adulto
46 en adelante – Adulto Mayor
1. 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.
2. DOCUMENTACION:
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 BEBE\n3
a 11 años NIÑO\n12 a 17 años ADOLESCENTE\n18 a 45 años ADULTO\n45 en adelante ADULTO
MAYOR\n**INGRESE UNA EDAD** ");
edad1=Integer.parseInt(opcion);
edades=edad.edades(edad1);
dato=JOptionPane.showInputDialog(null,"DESEA REPETIR 1 O 0 PARA SALIR: ");
op=Integer.parseInt(dato);
}while(op==1);
Importación de librerías del programa
Declaración de variables String y double
Inicio ciclo do while principal
SE CIERRA EL LAZO REPETITIVO
Menu
del
progra
ma
67
}
}
CLASE
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);
}
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;
Importación de librerías del programa
PROCESO
SE CIERRA LA CLASE
68
3. CORRIDO DEL PROGRAMA:
EJERCICIO N.-17
1. ENUNCIADO: Diseñe un programa utilizando clases que me permita ingresar
un número entero desde teclado y me permita descomponerlo en todos sus
elementos posibles. (Unidad, decena, centena, unidad de mil, etc.).
2. ANÁLISIS: Necesitaremos una variable tipo int para generar la
descomposición en sus unidades. 3. DOCUMENTACIÓN:
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)
{
int um,c,d,u;
um=a;
um=(um/1000)*1000;
c=a;
c=c-um;
c=(c/100)*100;
d=a;
Importación de
librerías 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
69
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;
}
}
4. CORRIDO DEL PROGRAMA:
EJERCICIO N.-18
PROGRAMA # 18
1. 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 número entero a su binario
correspondiente, un entero a octal y un entero a hexadecimal.
2. 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.
3. DOCUMENTACIÓN:
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
Importación de librerías
del programa
Declaración de variables
String, int y double
Impresión del Menú de
Opciones
70
\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
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; }
}
Ingreso el número
Ingreso el número
Fin del Programa
Nombre del Programa
principal
Decimal a binario
Fin del Switch
Repetir el Programa
n veces
Ingreso el número
Decimal a octal
Decimal a hexadecimal
71
4. CORRIDO DEL PROGRAMA:
72
BIBLIOGRAFIA
http://www3.uji.es/~belfern/pdidoc/IX26/Documentos/introJava.pdf
http://puntocomnoesunlenguaje.blogspot.com/2012/04/identificadores-
y-palabras-reservadas.html
http://edcruz.50megs.com/javareservadas.html
Top Related