Download - Introducion 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ñ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.

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.

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) {


}

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 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..: ");


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;


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 : ");


do

{



}while(n>m);

c=n-m;


Importación de librerías

del programa

Declaración de variables

Inicio del ciclo do

Impresión del Menú de

Opciones

Inicio del switc

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 : ");




c=n*m;


break;

case 4:

d2=JOptionPane.showInputDialog("DIVICION\n"+"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ó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 fig_bas.figuras;

public class Fig_bas {


{

String opc;

int menu, cua, rect, circ, trian;

opc=JOptionPane.showInputDialog("FIGURAS BÁSICAS

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

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

menu=Integer.parseInt(opc);

switch(menu)

{

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;


public class PoteyRadi {


{

String dato1, dato2;

double base, expo, resp;

JOptionPane.showMessageDialog(null,"Potenciacion");

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

base=Integer.parseInt(dato1);


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);

}}


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;


public class PARIMPAR {

@SuppressWarnings("empty-statement")


{

String dato1,dato2;

int num1,num2;

do

{

do

{

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


if(num1<6 ||num1>65)

{

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");


}

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 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;


public class Promediovalidacion {


{

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


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 {




JOptionPane.showInputDial og("VALOR INCORRECTO:");

} }


do {




JOptionPane.showInputDialog("VALOR INCORRECTO:");

} }


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


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 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); } }



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;


public class Ecuacion {


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


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

double c = Double.parseDouble


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);


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

}

else

if(interno>0)

{

interno = Math.sqrt(interno);

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

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


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

x1=-b/(2*a);

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


(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


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;


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);

}

}


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;


public class Comision {


{

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

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

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

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

do

{

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

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

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

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

menu=Integer.parseInt(opcion);

switch(menu)

{


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;


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


respectivos para obtener

sus distintos resultados




42


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)

{




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"

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

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

}

else{

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

{

commarc=vmarc*0.45;





} else

{

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

{

commarc=vmarc*0.06;





}else

{

if(vmarc>45000)

{

commarc=vmarc*0.85;

Impresión del nombre y

datos subtítulos





datos subtítulos





datos subtítulos




44





}

}

}

}

opj=JOptionPane.showInputDialog("Desea realizar una

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


}

while(op==1);

JOptionPane.showMessageDialog(null,"EMPRESA DON LUCHO"

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

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

"\n Comisiones ganadas= " + commarcelo);

break;

case 3:

do

{

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

{

commar=vmar*0.03;

commaria=commaria+commar;


+ "\n \n VENDEDORA MARÍA" + "\n \n # 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;



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


}

else

{

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

{

commar=vmar*0.06;



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

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

}

else

{

if(vmar>45000)

{

commar=vmar*0.85;






datos subtítulos








datos subtítulos

46

CJOptionPane.showMessageDialog(null, "EMPRESA DON LUCHO"

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


}

}

}

}

opj=JOptionPane.showInputDialog("Desea realizar una

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


}

while(op==1);


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

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

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

break;

case 4:

System.exit(0);

break;

}

rept=JOptionPane.showInputDialog("Desea realizar una nueva compra (1 SI/0 NO)");

op=Integer.parseInt(rept);

}

while(op==1);

total=totventj+totventm+totventma;


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

Cierre de sentencias if



while


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 );

}


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 java.text.DecimalFormat;

public class Matriculas {


{

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;

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;


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;

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;


Ingreso de Datos

Procesos


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));

}

}


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)

{


Librerías


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



extras


Procesos

Ingreso del nombre


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 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); } }


Procesos


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 seisop.funcionesop;

public class Seisop {


String dato1,dato2,op,opa;

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

double div1,pot1,rad1;

do{

op=JOptionPane.showInputDialog("ESCOJA UNA OPCION

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

"4.-DIVISION\n5. -POTENCIACION

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

op1=Integer.parseInt(op);

switch(op1)

{

case 1:

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

a=Integer.parseInt(dato1);


b=Integer.parseInt(dato2);

sum1=funcionesop.suma1(a, b);

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

break;

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

case 2:

do

{





}while(a<b);

res1=funcionesop.resta(a, b);

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

break;

case 3:





mult1=funcionesop.multiplicacion(a, b);

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

break;

case 4:

do

{





}while(a<b);

div1=funcionesop.division(a, b);

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

break;

case 5:

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


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


pot1=funcionesop.potencia(a, b);

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

break;

case 6:

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


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;

}

}


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 pkg13.operacionesmenu.operaciones;

public class Operacionesmenu {


{

String dato1,dato2,escoger,opcion;

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

double division, potenciacion, radicacion;

{

escoger=JOptionPane.showInputDialog(null, "

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

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

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

es=Integer.parseInt(escoger);

switch(es)

{

case 1:

do{

dato1=JOptionPane.showInputDialog

("Ingrese el primer valor: ");



("Ingrese el segundo valor: ");


suma=operaciones.sumar(num1, num2);


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

opcion=JOptionPane.showInputDialog

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

op=Integer.parseInt(opcion);

}while(op==1);

break;

case 2

do{

do{



Importación de librerías del

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;

case 3:

do{







multiplicacion=operaciones.multi(num1, num2);


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


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


}while(op==1);

break;

case 4:

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ón de datos

Validación de datos

61


}while(op==1);

break;

case 5:

do{


("Ingrese la base: ");



("Ingrese el exponente: ");


potenciacion=operaciones.potencia(num1, num2);


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


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


}while(op==1);

break;

case 6:

do{

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


radicacion=operaciones.raiz(num1);


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


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


}while(op==1);

break;

case 7:

System.exit(0);

break;

}// fin del switch


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


}while(op==1);

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


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


Declaración de


double


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;


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

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


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;


public class Edades {


String opcion,dato;

int edad1,op,edades;

do

{

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

a 11 años NIÑO\n12 a 17 años ADOLESCENTE\n18 a 45 años ADULTO\n45 en adelante ADULTO

MAYOR\n**INGRESE UNA EDAD** ");

edad1=Integer.parseInt(opcion);

edades=edad.edades(edad1);

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

op=Integer.parseInt(dato);

}while(op==1);

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;


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


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:

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


del programa


String, int y double


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


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

Download - Introducion a java

Top Related