Introducción a JAVA

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ñadoespecíficamente para tener tan pocas dependencias
de implementación como fuera posible. Su intención es
permitir que los desarrolladores de aplicaciones escriban el
programauna 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.

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 codiﬁcació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.

11
SEPARADORES
En Java existen seis separadores distintos. A continuaciónse muestra el
uso de cada uno de ellos.
Los paréntesis ():
*Delimitan listas de parámetros.
*Modiﬁcan la precedenciade una
expresión.
*Delimitan condiciones.
*Indican el tipo en las coerciones.
La coma «,»:
Separan identificadoresen
declaraciones.
Encadenan expresiones.
El punto y coma «;»:
Terminan instrucciones.
El punto «.»:
Accedena los atributos y
métodos de una clase.
Los corchetes []:
Declaran vectores y permiten
accedera sus elementos.
Las llaves {}:
Deﬁnen 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) {
}
Do {
}
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 conjuntode
atributosy un conjuntode 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
especiﬁcar 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
packagesumadenumeros1;
import javax.swing.JOptionPane;
public static void main(String[] args)
{
String dato1, dato2;
int num1, num2, num3;
dato1=JOptionPane.showInputDialog("Ingreseel dato 1..: ");
num1=Integer.parseInt(dato1);
dato2=JOptionPane.showInputDialog("Ingreseel dato 2..: ");
num3=num1+num2;
JOptionPane.showMessageDialog(null,"la suma es..: " + num3);
}
}
4.-CORRIDO DEL PROGRAMA
Nombre del programa o proyecto
Librería
Iniciodel programa
Declaración de variables de tipo
caracter
Ingresamosel 1er
numero
Ingresamosel 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:
packageoperacionesbasicas;
public classOperacionesbasicas{
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)
{
case1:
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;
case2:
d2=JOptionPane.showInputDialog("RESTAn"+"INGRESE EL PRIMER DATO : ");
do
{
}while(n>m);
c=n-m;
Importación de librerías
del programa
Declaración de variables
Inicio del ciclodo
Impresión del Menú de
Opciones
Inicio del switc
Proceso para la suma
con impresionesYEL
resultado.
Proceso para la resta
con impresiones,
resultadoy Con un
control de ingreso

23
break;
case3:
d2=JOptionPane.showInputDialog("MULTIPLICACION
n"+"INGRESE EL PRIMER DATO : ");
c=n*m;
break;
case4:
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);
}
}
4. CORRIDO DEL PROGRAMA:
Proceso para la
multiplicación
impresiones,
resultado
Proceso para la
división con
impresiónpara
el resultado.
Con un control
de ingreso
Fin del ciclodo while
Finalizacióndel 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 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();
Importación de
librerías del programa
Inicio del programa principal
Menú de opciones
Inicio del menú de opciones
Encontrar el perímetro y el área de
un cuadrado
un rectángulo

25
break;
case 4:
trian=figuras.triangulo();
break;
case 5:
System.exit(0);
break;
}
}
}
package fig_bas;
public class figuras
{
public static int cuadrado()
{
String lado;
int l, per, ar;
lado=JOptionPane.showInputDialog("Ingrese el
lado del cuadrado: ");
l=Integer.parseInt(lado);
per=l*4;
ar=l*l;
JOptionPane.showMessageDialog(null, "PERIMETRO
DEL CUADRADO= " + per);
JOptionPane.showMessageDialog(null, "ÁREA DEL
CUADRADO= " + ar);
return 0;
}
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);
un triángulo
Salir del menú
Clase (subprograma) para
calcular el perímetro y el
área de un cuadrado.
área de un rectángulo.
CLASE

26
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;
}
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 círculo.
á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;
importjavax.swing.JOptionPane;
publicclassPoteyRadi {
publicstaticvoidmain(String[] args)
{
Stringdato1, dato2;
double base,expo,resp;
JOptionPane.showMessageDialog(null,"Potenciacion");
dato1=JOptionPane.showInputDialog("Ingrese unabase:");
base=Integer.parseInt(dato1);
Librería
Iniciodel programa
Declaración de variables de tipo caracter
Ingresamosla
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 resultadoes:"+resp)
JOptionPane.showMessageDialog(null,"Radicación");
double radicando,raiz;
dato1=JOptionPane.showInputDialog("Ingrese unindice:");
radicando=Integer.parseInt(dato1);
raiz=Math.sqrt(radicando);
JOptionPane.showConfirmDialog(null,"Laraizes:"+raiz);
}}
Ingresamosel exponente
Visualizamosel resultado
Ingresamosel índice de la raíz
Formula o proceso para poder realizar la
radicación
Visualizamosel 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:
packagepar.impar;
public classPARIMPAR {
@SuppressWarnings("empty-statement")
{
String dato1,dato2;
int num1,num2;
do
{
do
{
dato1=JOptionPane.showInputDialog("INGRESE EL NUMERO ");
if(num1<6 ||num1>65)
{
JOptionPane.showMessageDialog(null,"ELNUMERO "+num1+" NO ESTA DENTRO DEL RANGO");
}
}
Declaración de las variablestanto 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 sentenciado 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,"ELNUMERO "+num1+" ES PAR ");
}
else
{
JOptionPane.showMessageDialog(null,"ELNUMERO "+ num1+" ES IMPAR ");
}
dato2=JOptionPane.showInputDialog("PRESIONE 1 PARA SALIR 0 PARA VOLVER");
}
while(num2==1);
}
}
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 sentenciado 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:
packageprom
ediovalidacion;
public classPromediovalidacion {
{
String dato1, dato2,dato3,dato4, nom, mat;
floatnum, 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
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 {
} }
do {
} }
pro= (nota1+nota2+nota3)/3;
JOptionPane.showMessageDialog(null,"ELPROMEDIO 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
Ingreso de la tercera
nota
mensaje
Procesos promedio de notas
Impresión de
datos de
aprobado:
Condición de la nota >7

33
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
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 classTabla {
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
Iniciodel ciclodo-while
Fin del ciclodo-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;
publicclassEcuacion{
publicstaticvoidmain(String[] args) {
Stringdato2;
intop ;
do
{
JOptionPane.showMessageDialog
(null,"ECUACION DESEGUNDO GRADO");
double a= Double.parseDouble
(JOptionPane.showInputDialog
("Ingrese el primervalorde a:"));
double b= Double.parseDouble
("Ingrese el segundovalorde b:"));
double c= Double.parseDouble
Nombre del proyecto
Librería
Iniciodel
programa
Declaración
de variables
Proceso de
repetición
Impresiónde un
mensaje
Ingresamoslos tres
valores

36
("Ingrese el tercervalorde c: "));
double interno=b*b-(4*a*c);
if (interno==0){
double x1=-b/(2*a);
(null,"Existe unvalordoble:"+ x1 ) ;
}
else
if(interno>0)
{
interno= Math.sqrt(interno);
x1=(-b+interno)/(2*a);
x2=(-b-interno)/(2*a);
(null,"valorde x1y x2: " + x1 +" n"+x2);
x1=-b/(2*a);
double resultado=Math.sqrt((-interno/(2*a)));
(null,"Laraiz esimaginariayvale:" + x1 +"
+"+ resultado+"i"+x1+"-"+resultado+"i");
dato2= JOptionPane.showInputDialog
("Ingrese 1para continuary 0 pasa salir");
op= Integer.parseInt(dato2);
}
while(op==1);
}
}
Realizamosel proceso
para sacar la ecuación
Este esel procesopara
sacar la raíz cuadrada de la
ecuación
Visualizamosel
resultado
Proceso para que el
usuario realice otro
proceso o si deseasalir

37
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;
del programa

38
public static void main (String[] args)
{
String dato1, dato2, dato4;
double valor1,valor2,dif,cost,bomb,tasa,otros,tot,op ;
DecimalFormatf = new DecimalFormat("00.00");
DecimalFormatg = 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ónde titulo
Escaneo del
primer
valor
Escaneo del
segundo
valor
Iniciodel ciclodo while
Validacióndel valor 1 y valor
2
Procesospara operaciones
Impresión de
resultados
Iniciociclo 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);
}
}
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;
publicclassComision{
publicstaticvoidmain(String[] args)
{
Stringventj,ventmarc,ventmar,rept,opcion,opj;
intvjuan,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 nVENDEDORES"+ "n n1.- JUAN" + "n 2.- MARCELO" + "n
3.- MARÍA"+ "n 4.- Salir"+
"n nCon quiendesearealizarsuventa");
menu=Integer.parseInt(opcion);
switch(menu)
{
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 VENDEDORJUAN"+ "nn
Valorde 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 nVENDEDOR JUAN"+
"n n# VENTA:" + numj +
"n n Venta="+ vjuan+ "nComisión="+ comj);
}
else
{
if(vjuan>11000 && vjuan<=25000)
{
comj=vjuan*0.45;
JOptionPane.showMessageDialog(null,"EMPRESA DON LUCHO" + "nn VENDEDOR
JUAN"+ "nn # VENTA:" + numj + "n nVenta="+ vjuan+ "n Comisión="+ comj);
}
else
if(vjuan>25000 && vjuan<=45000)
{
comj=vjuan*0.06;
Procesos para operaciones
Decisión if y procesos
respectivos para obtener
sus distintos resultados

42
JOptionPane.showMessageDialog(null,"EMPRESA DON LUCHO" + "n nVENDEDOR JUAN"+ "n
n # VENTA:" + numj + "nn Venta="+ vjuan+ "nComisión="+ comj);
}
else
{
if(vjuan>45000)
{
comj=vjuan*0.85;
opj=JOptionPane.showInputDialog
("DesearealizarunanuevaventaconnuestrovendedorJuan
(1 SI/0NO)");
op=Integer.parseInt(opj);
}
while(op==1);
JOptionPane.showMessageDialog(null,"EMPRESA DON LUCHO"+ "nn VENDEDORJUAN"+ "n
n # VENTAS:" + numj + "n n Total de ventas="+ totventj +"n Comisionesganadas="+
comjuan);
break;
case 2:
do
{
+ "nn VENDEDORMARCELO" + "nn Valorde la venta");
vmarc=Integer.parseInt(ventmarc);
nummarc=nummarc+1;
totventm=totventm+vmarc;
if(vmarc>=8000 && vmarc<=11000)
{
Proceso de repetición,
mensaje y cierre del do
while
Case 2 y Do While

43
commarc=vmarc*0.03;
commarcelo=commarcelo+commarc;
JOptionPane.showMessageDialog(null,"EMPRESA DON LUCHO"
+ "nn VENDEDORMARCELO" + "nn # VENTA:" + nummarc +
"n nVenta="+ 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;
"n n Venta="+ vmarc + "nComisión="+ commarc);
}else
{
if(vmarc>45000)
{
commarc=vmarc*0.85;
Impresióndel nombre y
datos subtítulos
datos subtítulos
datos subtítulos

44
}
}
}
}
opj=JOptionPane.showInputDialog("Desearealizaruna
nuevaventacon nuestro vendedorMarcelo(1SI/0 NO)");
}
while(op==1);
+ "n nVENDEDORMARCELO" + "n n# VENTAS:"
+ nummarc+ "n nTotal de ventas="+ totventm+
"n Comisionesganadas="+ commarcelo);
break;
case 3:
do
{
if(vmar>=8000 && vmar<=11000)
{
commar=vmar*0.03;
commaria=commaria+commar;
+ "nn VENDEDORA MARÍA"+ "nn # VENTA:" + nummar+
datos subtítulos
Cierre de sentencias if
while
Case 3 y Do While
datos subtítulos
datos subtítulos

45
"n n Venta="+ vmar + "n Comisión="+ commar);
}
else
{
if(vmar>11000 && vmar<=25000)
{
commar=vmar*0.45;
+ "nn VENDEDORMARÍA"+ "n n# VENTA:" + nummar+
"n nVenta="+ vmar+ "n Comisión="+ commar);
}
else
{
if(vmar>25000 && vmar<=45000)
{
commar=vmar*0.06;
+ "nn VENDEDORMARÍA"+ "n n# VENTA:" + nummar
+ "nn Venta="+ vmar + "nComisión="+ commar);
}
else
{
if(vmar>45000)
{
commar=vmar*0.85;
datos subtítulos
datos subtítulos

46
CJOptionPane.showMessageDialog(null,"EMPRESA DON LUCHO"
+ "nn VENDEDORMARÍA"+ "n n# VENTA:" + nummar+
"n n Venta="+ vmar + "n Comisión="+ commar);
}
}
}
}
opj=JOptionPane.showInputDialog("Desearealizaruna
nuevaventacon nuestrovendedorMaría (1 SI/0 NO)");
}
while(op==1);
+ "nn VENDEDORMARÍA"+ "n n# VENTAS:"
+ nummar+ "nn Total de ventas="+ totventma
+ "nComisionesganadas="+ commaria);
break;
case 4:
System.exit(0);
break;
}
rept=JOptionPane.showInputDialog("Desearealizaruna nuevacompra(1 SI/0 NO)");
op=Integer.parseInt(rept);
}
while(op==1);
total=totventj+totventm+totventma;
+ "n nVENDEDORJUAN" + "n n # VENTAS:"
Cierre de sentencias if
while
datos subtítulos
Case 4
Opción Salir
Suma total de las comisiones
de vendedores

47
+ numj + "nn Total de ventas="+ totventj +
"n Comisionesganadas="+ comjuan+
"n n VENDEDORMARCELO" + "n n # VENTAS:"
+ nummarc+ "nn Total de ventas="+ totventm+
"n Comisionesganadas="+ commarcelo+ "nn
VENDEDORMARÍA"
+ "n n# VENTAS:" + nummar + "n nTotal de ventas="
+ totventma+ "nComisionesganadas="+ commaria+
"n n TODALDE LAS VENTAS=" + total );
}
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:
packagematriculas;
import java.text.DecimalFormat;
public classMatriculas {
{
String nombre,tipo,ret,repet;
Importación de
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;
DecimalFormatf=new DecimalFormat(".00");
do
{
JOptionPane.showMessageDialog(null,"SISTEMA DE MATRICULAS" );
tipo=JOptionPane.showInputDialog("Escojael tipo de Institucion"
+"n 1.- Publica"+"n 2.- Pribada"+"n 3.- Fiscomisinal"+"n 4.-Salir");
t=Integer.parseInt(tipo);
switch(t)
{
case1:
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;
case2:
prt=prt+pr;
con2=con2+1;
nombre=JOptionPane.showInputDialog("Ingreseel nobre
del estudiante:");
sm2=(pr*3)/100;
sm22=sm22+sm2;
sd2=(pr*8)/100;
Opciones
Transformación de
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;
case3:
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;
case4:
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));
}
}
Impre
sió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:
packageprueba;
import java.text.DecimalFormat;
public classPrueba {
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{
DecimalFormatdf=new DecimalFormat(".00");
opc=JOptionPane.showInputDialog(" LIQUIDO TOTAL DE EMPLEADOSn"+"1.-Administrativon"
+"2.-Ejeutivon"+"3.-Obreron"+"5.-Salir");
op=Integer.parseInt(opc);
switch(op)
{
case1:
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)
{
Librerías
Iniciodel do-while
Diseñodel menú
Iniciodel
switch
Ingresodel nombre
Ingresode las horas
extras
Ingresodel númerode 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
GENERALn"+nom+"nAdministrativo"+"nSueldo "
+ad+"nnIngresos "+ti+"nHoras extras "
+ph+"nCargas familiares "+pi+"nnEgresos "+te+"nIESS "+ie+
"nComisiariato "+co+"nSueldo a recibir "+st);
break;
case2:
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;
JOptionPane.showMessageDialog(null," REPORTE GENERALn"+nom+"nEjecutivo"+"nSueldo "
+ej+"nnIngresos "+ti+"nHoras extras "
break;
case3:
do{
}while(he>8);
ph=he*3.50;
if(h>2)
{
Procesos
Impresión de resultados
Ingresode las horas
extras
Procesos
Ingresodel nombre
Ingresode las horas
extras

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 GENERALn"+nom+"nObrero"+"nSueldo "
+ob+"nnIngresos "+ti+"nHoras extras "
break;
case4:
System.exit(0);
break;
}
opc1=JOptionPane.showInputDialog("Salir1/0:");
op1=Integer.parseInt(opc1);
}while(op1==1);
}
}
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:
packageseisop;
import seisop.funcionesop;
public classSeisop {
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)
{
case1:
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;
Importación de librerías del
programa y paquete
Paquetes del programa
Menú de Opciones
Transforma de String
a int para switch
Ingreso de datos
Llamamos a la clase

56
case2:
do
{
}while(a<b);
res1=funcionesop.resta(a,b);
JOptionPane.showMessageDialog(null,"La resta es:"+res1);
break;
case3:
mult1=funcionesop.multiplicacion(a,b);
JOptionPane.showMessageDialog(null,"La multiplicacion es:"+mult1);
break;
case4:
do
{
}while(a<b);
div1=funcionesop.division(a,b);
JOptionPane.showMessageDialog(null,"La division es:"+div1);
break;
case5:
dato1=JOptionPane.showInputDialog("Base:");
dato2=JOptionPane.showInputDialog("Exponente :");
pot1=funcionesop.potencia(a,b);
JOptionPane.showMessageDialog(null,"La potencia es:"+pot1);
break;
case6:
dato1=JOptionPane.showInputDialog("Numero :");
rad1=funcionesop.radicacion(a);
JOptionPane.showMessageDialog(null,"La raizes:"+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);
}
}
Clasedel programa:
packageseisop;
public classfuncionesop {
public static intsuma1(inta1,intb1)
{
int sumar;
sumar=(a1+b1);
return sumar;
}
public static intresta(inta1,intb1)
{
int restar;
restar=(a1-b1);
return restar;
}
public static intmultiplicacion(inta1,intb1)
{
int multiplicar;
multiplicar=(a1*b1);
return multiplicar;
}
public static doubledivision(doublea1,doubleb1)
{
double dividir;
dividir=(a1/b1);
return dividir;
}
public static doublepotencia(doublea1,doubleb1)
{
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 doubleradicacion(doublea1)
{
double radical;
radical=Math.sqrt(a1);
return radical;
}
}
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:
packagepkg13.operacionesmenu;
import pkg13.operacionesmenu.operaciones;
public classOperacionesmenu {
{
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)
{
case1:
do{
dato1=JOptionPane.showInputDialog
("Ingrese el primer valor:");
("Ingrese el segundo valor:");
suma=operaciones.sumar(num1,num2);
(null,"La Suma es: "+ suma);
opcion=JOptionPane.showInputDialog
("Desea realizar otra suma:1=si / 0=no");
op=Integer.parseInt(opcion);
}while(op==1);
break;
case2
do{
do{
Importación de libreríasdel
programa
Declaración de
double
Opciones
Transformación de
Ingreso de Datos
Llamado de clase o
función
DO WHILE y break
Ingreso de Datos

60
}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;
case3:
do{
multiplicacion=operaciones.multi(num1,num2);
(null,"La Multiplicación es:"+ multiplicacion);
("Desea realizar otra multiplicacion:1=si / 0=no");
}while(op==1);
break;
case4:
do{
do{
}while(num1<num2);
division=operaciones.dividir(num1,num2);
(null,"La División es:"+ division);
("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ónde datos
Validaciónde datos

61
}while(op==1);
break;
case5:
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;
case6:
do{
dato1=JOptionPane.showInputDialog("Ingreseel valor:");
radicacion=operaciones.raiz(num1);
(null,"La Radicacion es:"+ radicacion);
("Desea realizar otra radicación 1=si / 0=no");
}while(op==1);
break;
case7:
System.exit(0);
break;
}// fin del switch
("Desea volver al menu: 1=si / 0=no");
}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
packagepkg13.operacionesmenu;
public classoperaciones
{
public static intsumar(inta,intb)
{
int sumar;
sumar=(a+b);
return sumar;
}
public static intrestar(inta,intb)
{
int restar;
restar=(a+b);
return restar;
}
public static intmulti(inta,intb)
{
int multi;
multi=(a+b);
return multi;
}
public static doubledividir(doublea,doubleb)
{
double dividir;
dividir=(a/b);
return dividir;
}
public static doublepotencia(doublea,doubleb)
{
double potencia;
potencia=Math.pow(a, b);
return potencia;
}
public static doubleraiz(doublea)
{
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
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:
packagemenuseries;
import menuseries.series;
public classMenuseries {
{
String dato1, dato2,dato3;
int op,limite,pares,num,i,p,primos,factor,fibo,opc;
JOptionPane.showMessageDialog(null,"MENU DE SERIES ");
do
{dato1=JOptionPane.showInputDialog("1.PRIMOS n 2. FACTORIAL
n 3. FIBONACCI n 4. PARES n 5. SALIR n Ingrese una opcion: ");
switch(op)
{
case 1:
dato2=JOptionPane.showInputDialog("Ingreseun limite");
primos=series.primos(limite);
Importación de
Declaración de
double
Opciones
Ingreso del límite y
Llamado de clase o
función

64
break;
case 2:
factor=series.facto(limite);
break;
case 3:
fibo=series.fibo(limite);
break;
case 4:
pares=series.par(limite);
break;
case 5:
System.exit(0);
break;
}
dato3=JOptionPane.showInputDialog("Volver al menu 1 Salir 0:");
opc=Integer.parseInt(dato3);
}
while(opc==1);
}
}
CLASE DEL PROGRAMA
packagemenuseries;
public classseries
{
public static intpar (intlimite)
{
int p;
int i;
p=0;
{
p=p+2;
JOptionPane.showMessageDialog(null,+p);
}
return 0;
}
public static intprimos (intlimite)
{
int conta,residuo,i,j;
Llamado de clase o
función
Llamado de clase o
función
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
{
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 intfacto(intlimite)
{
int f,i;
f=1;
i=1;
i=i+1;
{
f=f*i;
JOptionPane.showMessageDialog(null,+i+f);
}
return 0;
}
public static intfibo(intlimite)
{
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
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;
publicclassEdades{
publicstaticvoidmain(String[] args) {
Stringopcion,dato;
intedad1,op,edades;
do
{
opcion=JOptionPane.showInputDialog(null,"***VERIFICACION DEEDAD***n1 a 3 años BEBEn3
a 11 añosNIÑOn12a 17 añosADOLESCENTEn18 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 REPETIR1 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;
publicclassedad{
publicstaticint edades(intedad1)
{
if(edad1>=1&& edad1<=3)
{
JOptionPane.showMessageDialog(null,"BEBE:"+edad1);
}
else
{
{
JOptionPane.showMessageDialog(null,"NIÑO:"+edad1);
}
else
{
{
JOptionPane.showMessageDialog(null,"ADOLESCENTE:"+edad1);
}
else
{
{
JOptionPane.showMessageDialog(null,"ADULTO:"+edad1);
}
else
{
if(edad1>45)
{
JOptionPane.showMessageDialog(null,"ADULTOMAYOR: "+edad1);
}
}
}
}
}
return 0;
Importación de librerías del programa
PROCESO
SE CIERRA LA CLASE

68
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 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;
Importación de
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;
}
}
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:
packageconversiones;
public classConversiones {
{
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ónde librerías
del programa
Declaraciónde variables
String, int y double
Opciones

70
n 3. HEXADECIMAL n 4. SALIR n Ingrese una Opcion: ");
opc=Integer.parseInt(dato);
switch(opc)
{
case1:
dato1=JOptionPane.showInputDialog("Ingreseun numero: ");
bi=convers.bi(a);
break;
case2:
oc=convers.oct(a);
break;
case3:
hexa=convers.he(a);
break;
case4:
System.exit(0);
break;
}
dato2= JOptionPane.showInputDialog("VOLVER AL MENU 1 SALIR 0: ");
}
while(op==1);
}
}
CLASE DEL PROGRAMA
packageconversiones;
public classconvers
{
public static intbi (inta)
{
JOptionPane.showMessageDialog(null,"Numero Binario:"+Integer.toBinaryString(a));
return 0;
}
public static intoct(inta)
{
JOptionPane.showMessageDialog(null,"Numero Octal:"+Integer.toOctalString(a));
return 0;
}
public static inthe(inta)
{
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

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

Introducción a JAVA

Más contenido relacionado

La actualidad más candente (19)

Similar a Introducción a JAVA (20)

Último (20)

Introducción a JAVA