PROGRAMACIÓN EN JAVA

1

|

UNIVERSIDAD TÉCNICA DE AMBATO

FACULTAD DE CIENCIAS HUMNAS Y DE LA

EDUCACIÓN

Carrera: Docencia en Informática

Modalidad Presencial

Tercer Semestre

PROGRAMACIÓN II

Lenguaje de Programación

Orientado a Objetos

Docente: Ing. Wilma Gavilanes.

Estudiante: Zapata Suarez Jhoselyn Ayneth

AMBATO – ECUADOR

Período: Febrero 2014-Agosto.

2

|

INDICE

INTRODUCCIÓN ................................................................................................................................... 3

¿QUÉ UTILIDAD TIENE ESTE PROGRAMA? .......................................................................................... 3

EXPRESIONES ....................................................................................................................................... 4

OPERADORES ....................................................................................................................................... 5

Operadores unarios. ........................................................................................................................ 5

OPERADORES BINARIOS. ................................................................................................................. 6

PRECEDENCIA DE OPERADORES ...................................................................................................... 6

SENTENCIAS ......................................................................................................................................... 7

CONVERSIÓN DE TIPOS ....................................................................................................................... 8

CARACTERÍSTICAS ................................................................................................................................ 9

CLASES ............................................................................................................................................... 11

BOOLEAN ....................................................................................................................................... 11

DOUBLE ......................................................................................................................................... 11

FLOAT ............................................................................................................................................ 11

INTEGER ......................................................................................................................................... 11

MATH ............................................................................................................................................. 12

STRING ........................................................................................................................................... 12

CONCEPTO DE INMUTABILIDAD .................................................................................................... 13

STRINGBUFFER .............................................................................................................................. 13

SYSTEM .......................................................................................................................................... 14

¿QUÉ ES NETBEANS? ......................................................................................................................... 14

BIBLIOTECAS DE JAVA........................................................................................................................ 16

SINTAXIS ............................................................................................................................................ 16

CÓDIGO BÁSICO EN JAVA .................................................................................................................. 17

BIBLIOGRAFÍA. ................................................................................................................................... 22

EJERCICIOS RESUELTOS DE JAVA EN NETNEANS ...................................................... 23

3

|

INTRODUCCIÓN

Java es un lenguaje de programación orientado a objetos, desarrollado por Sun

MicroSystems a principios de la década de 1990. Este lenguaje toma la estructura de

sintaxis (escritura de código fuente) de C y C++ incorporando un modelo de objetos

más simples y eliminando las herramientas de bajo nivel (que suele inducir muchos

errores como la manipulación de punteros en C y C++). El surgimiento de Java es

propiciado porque en la década de 1980 aparecieron varios lenguajes orientados a

objetos y también se realizaron versiones orientadas a objetos (o semi-orientados a

objetos) de lenguajes clásicos. Una de las más famosas fue el lenguaje orientado a

objetos creado a partir del C tradicional; se le llamó C++ indicando con esa simbología

que era un incremento del lenguaje C (en el lenguaje C, como en Java, los símbolos ++

significan incrementar) (Sánchez, 2004). La Programación Orientada a Objetos (POO)

permite desarrollar aplicaciones de forma más parecida al pensamiento humano, de

hecho simplifica el problema de programación (principalmente en el desarrollo de

aplicaciones de código largo) dividiéndolo en objetos, permitiendo centrarse en cada

objeto, de esa manera se elimina la complejidad de escribir código largo. En este

capítulo se abordará la historia de Java, su evolución, su filosofía y entornos de

desarrollo así como los distintos IDEs (interfaz de entorno de desarrollo) desde consola

hasta las aplicaciones móviles haciendo referencia al IDE NetBeans pues este IDE

constituye el enfoque sobre el cual se fundamenta este manual.

¿QUÉ UTILIDAD TIENE ESTE PROGRAMA?

Existe un gran número de aplicaciones y sitios Web que no funcionan a menos que

Java esté instalado, y muchas más que se crean a diario. Java es rápido, seguro y fiable.

De portátiles a centros de datos, de consolas de juegos a superequipos científicos, de

teléfonos móviles a Internet, Java está en todas partes.

4

|

EXPRESIONES

Las expresiones son un conjunto de elementos o tokens junto con literales que son

evaluados para devolver un resultado. Los tokens son elemento más pequeño de un

programa que es significativo, e interpretado o entendido por el compilador, en java

los tokens se dividen en cinco categorías que son:

Identificadores: Son las representaciones que se les da a los nombres que se asignan a

las variables, clases, paquetes, métodos y constantes en el código de java para que el

compilador los identifique y el programador pueda entenderlos. En java los

identificadores pueden diferenciar entre mayúsculas o minúsculas por ser case

sensitive, por lo que la variable cuyo nombre sea “Mivariable”, no es igual a

“mivariable”, ya que java identifica estas como variables diferentes por el case

sensitive, también se puede utilizar números, o el signo “_” para asignar un

identificador.

abstract boolean break byte case

catch char class continue default

do double else extends false

final finally float for if

implements import instanceof int interface

long native new null package

private protected public return short

static super switch syncronized this

throw throws transient true try

5

|

void volatile while var rest

byvalue cast const future generic

goto inner operator outer

Las palabras que se encuentran en negrilla, son palabras claves para java aunque

actualmente no se utilicen en la versión de java, pero se pretenden integrar en las

siguientes versiones de java.

Literales y constantes: Los literales son sintaxis para asignar valores a una variable, es

decir el valor que puede tomar una variable, también es un valor constante que puede

ser de tipo numérico. Las constantes son variables que tienen un valor fijo y no puede

ser modificado en el trascurso de la ejecución del código, estas se declaran por medio

de los modificadores final y static.

final static double pi= 3.1416;

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 operandos, y el

resultado que generan.

Número de operandos. 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 operandos.

Operadores unarios.

Operador Descripción

- Cambio de signo

! Operador NOT

~ Complemento a 1

6

|

OPERADORES BINARIOS.

Operadores Descripción

+ - * / % Operadores aritméticos

== != < > <= >= Operadores relacionales

&& || ^ Operadores booleanos

^ << >> >>> Operadores a nivel de bit

+ Concatenación de cadenas

PRECEDENCIA DE OPERADORES

Los operadores son una parte principal en las expresiones, el tipo y forma de uso es

fundamental a la hora de programas, pero para su uso se tiene que tener en cuenta

una serie de normas, como lo son la precedencia de los operadores.

Tipo de operadores Operadores

Operadores posfijos [ ] . ( parámetros) expr++ expr--

Operadores unarios ++expr –expr +expr -expr ~ !

Creación o conversión New (tipo) expr

Multiplicación * / %

Suma + -

Desplazamiento << >> >>>

Comparación < > <= >= instanceof

Igualdad == !=

AND a nivel bit &

OR a nivel bit |

XOR a nivel bit ^

AND lógico &&

OR lógico ||

Condicional ? :

Asignación = += -= *= /= %= &= ^= |= <<= >>= >>>=

Un ejemplo de la precedencia de los operadores en java podría ser el siguiente, en

donde tenemos un código que se encargará de realizar una serie de operaciones

aritméticas.

7

|

int numero1 = 3; int numero2 = 4; int resultado; resultado = numero1 + numero2 * 3; System.out.println (resultado); //esto imprime el valor de 15

según la precedencia de los operadores la multiplicación * tiene mayor prioridad que

la suma +, por lo que primero se ejecuta la multiplicación y luego se realiza la suma.

int numero1 = 3; int numero2 = 4; int resultado; resultado = (numero1 + numero2) * 3; System.out.println (resultado); //esto imprime el valor de 21

En este caso el resultado cambia ya que primero se evalúan los parámetros que están

dentro del paréntesis y luego se evalúa el resto de parámetros. Una de las

recomendaciones que da java para el desarrollo es el uso de los paréntesis en las

operaciones con más de 3 operandos, así de esta forma el código se hace más legible y

se evitan errores al momento de compilar.

SENTENCIAS

Las sentencias son una representación de una secuencia de acciones que se realizan en

java, la clave fundamental de las sentencias es su punto final que indica que ha

finalizado la sentencia y puede continuar con la siguiente, el indicador utilizado es el

signo de punto y coma (;). Contamos en java con sentencias que pueden ir desde

sentencias de asignación, de bucles, condicionales, y de salto. Las sentencias se

conforman comúnmente por una instancia, y un operador, un ejemplo es la sentencia

de asignación que se conforma por una instancia de una variable, el signo de

asignación y una expresión, un ejemplo es:

Las sentencias de asignación son aquellas en las que se asigna un valor a una variable o

constante. Las sentencias condicionales son las que expresan una condición para

definir el flujo de ejecución del programa, entre ellas tenemos if-else y switch. Las

sentencias de bucles se encargar de realizar una acción cierta cantidad de tiempo

dado, o hasta que se cumpla con una condición, entre ellas tenemos el while, do-while,

y for. Las sentencias de salto llevan al compilador a un punto específico del programa o

8

|

hacia la siguiente sentencia de ejecución, entre ellas tenemos break, continue, y

return.

CONVERSIÓN DE TIPOS

En algunos casos suele ser necesario convertir un tipo de dato a otro, esto se le conoce

como conversión de tipos, modelado, o tipado, así de esta forma poder realizar las

operaciones necesarias sobre el valor que se desea convertir. Se debe tener en cuenta

el tipo de dato que se va a convertir, ya que si se convierte un dato que tenga una

cantidad menor de bit al anterior este tendrá perdida de información, un ejemplo de

tipado puede ser un número long que se desea convertir a int, el compilador eliminara

los primeros 32bit del long para ajustarlo al int ya que el int es de 32bit y el long de 64.

Si la conversión se realiza a un tipo de datos de menos bit a un tipo de datos con

mayor bit, la conversión se realiza automáticamente llamada conversión implícita,

pero si se realiza de un tipo de datos con mayor bit a menor bit se tiene que realizar

una conversión explicita, la cual se realiza con un casting, al usar este método se obliga

a realizar la conversión por lo cual puede haber perdida de datos en la conversión.

Para realizar una conversión explicita se tiene que poner el tipo de dato que se desea

realizar la conversión entre paréntesis, luego el valor o la variable que se desea

convertir. Un ejemplo de conversión de tipo explicito puede ser:

Int numero1 = 32; byte numero2; numero2 = (byte) numero1;

Las siguiente tabla muestra la los tipos de datos que se pueden realizar una conversión

implícita desde el dato origen, hasta el dato destino que es el dato en el que se va a

convertir.

Tipo origen Tipo destino

byte double, float, long, int, char, short

short double, float, long, int

char double, float, long, int

int double, float, long

long double, float

9

|

float double

Los tipos de datos booleanos no pueden ser convertidos a otro tipo de datos, por

ningún método mencionado anteriormente. Otro tipo de conversión que no se

encuentre en esta tabla desde el origen al destino, tiene que realizarse por medio de

una conversión explícita por casting. Cuando se desea realizar una conversión de un

tipo string como origen a otro tipo, es necesario utilizar una función que se encarga de

convertir el tipo de dato, la función necesaria se compone de la variable que va

almacenar el resultado, y dependiendo de la variable se usa el parámetro que inicia

con el tipo de dato a convertir, Integer, Byte, Short, o Long, seguida de punto “. “, el

cual indica que se cargarán los atributos del parámetro, en donde cargaremos el

parseInt si queremos convertir a interger o parseByte si queremos convertir a byte, o

dependiendo del tipo de dato, seguido de paréntesis en donde se agregara el valor de

string a convertir. Algunos ejemplos puede ser:

int numero1; long numero2; byte numero3; String texto= “2013”; numero1 = Integer.parseInt ( texto ); numero2 = Long.parseLong ( texto); numero3 = Byte.parseByte ( texto );

esto suele ser usado para realizar una conversión de texto cuando se ingresan valores

numéricos por una entrada a java, la cual los detecta como string, así de esta forma

puede convertir el texto que se ingresa a un número para realizar operaciones, como

una calculadora.

CARACTERÍSTICAS

Lenguaje totalmente orientado a Objetos. Todos los conceptos en los que se

apoya esta técnica, encapsulación, herencia, polimorfismo, etc., están presentes

en Java.

Disponibilidad de un amplio conjunto de bibliotecas. Como ya se mencionó

anteriormente, Java es algo más que un lenguaje. La programación de aplicaciones

con Java se basa no solo en el empleo del juego de instrucciones que componen el

10

|

lenguaje, sino, fundamentalmente, en la posibilidad de utilizar el amplísimo

conjunto de clases que Sun pone a disposición del programador y con las cuales es

posible realizar prácticamente cualquier tipo de aplicación.

Lenguaje simple. Java posee una curva de aprendizaje muy rápida. Resulta

relativamente sencillo escribir applets interesantes desde el principio. Todos

aquellos familiarizados con C++ encontrarán que Java es más sencillo, ya que se

han eliminado ciertas características, como los punteros. Debido a su semejanza

con C y C++, y dado que la mayoría de la gente los conoce aunque sea de forma

elemental, resulta muy fácil aprender Java. Los programadores experimentados en

C++ pueden migrar muy rápidamente a Java y ser productivos en poco tiempo.

Seguro (?). Dada la naturaleza distribuida de Java, donde las applets se bajan

desde cualquier punto de la Red, la seguridad se impuso como una necesidad de

vital importancia. A nadie le gustaría ejecutar en su ordenador programas con

acceso total a su sistema, procedentes de fuentes desconocidas. Así que se

implementaron barreras de seguridad en el lenguaje y en el sistema de ejecución

en tiempo real.

Portable. La indiferencia a la arquitectura representa sólo una parte de su

portabilidad. Además, Java especifica los tamaños de sus tipos de datos básicos y

el comportamiento de sus operadores aritméticos, de manera que los programas

son iguales en todas las plataformas. Estas dos últimas características se conocen

como la Máquina Virtual Java (JVM).

Dinámico. El lenguaje Java y su sistema de ejecución en tiempo real son dinámicos

en la fase de enlazado. Las clases sólo se enlazan a medida que son necesitadas. Se

pueden enlazar nuevos módulos de código bajo demanda, procedente de fuentes

muy variadas, incluso desde la Red.

Produce applets. Java puede ser usado para crear dos tipos de programas:

aplicaciones independientes y applets. Las aplicaciones independientes se

comportan como cualquier otro programa escrito en cualquier lenguaje, como por

ejemplo el navegador de Web HotJava, escrito íntegramente en Java. Por su parte,

11

|

las applets son pequeños programas que aparecen embebidos en las páginas Web,

como aparecen los gráficos o el texto, pero con la capacidad de ejecutar acciones

muy complejas, como animar imágenes, establecer conexiones de red, presentar

menús y cuadros de diálogo para luego emprender acciones, etc.

CLASES

En cuanto a lo que respecta a clases, todas son casi imprescindibles de conocer, ya que

son básicas y por eso están en el paquete java.lang pero vamos a destacar unas

cuantas por considerarlas principales.

BOOLEAN

La clase Boolean ya la conocemos. Es lo que se llama un wrap o envoltorio, que es una

clase que permite manejar los datos equivalentes de tipo primitivo. En este caso la

clase Boolean es un wrap del tipo primitivo boolean. Los métodos de esta clase

permiten el manejo de los valores primitivos true o false, su modificación o su

comparación ya que implementa la interfaz Comparable.

DOUBLE

Es la clase wrap correspondiente al tipo primitivo double, por lo que lo métodos son

muy parecidos a los de la clase Boolean, pero manejando los tipos primitivos para

double. Permitiendo obtener, modificar, comparar, etc valores de tipo double.

FLOAT

Al igual que las anteriores también es

un wrap pero para el tipo básico o

primitivo float.

INTEGER

Esta es quizás la clase de todos los

wrappers más utilizada con diferencia

12

|

y por tanto maneja tipos primitivos de tipo int. Tiene una gran cantidad de métodos

sobre todo para poder convertir el entero a otros tipos como long, float, double, etc.

MATH

La clase Math tiene una gran cantidad de métodos para poder hacer operaciones

matemáticas, como las funciones sin (double a) que calcula el seno del valor a, tan

(double a) que calcula la tangente de a, etc.

STRING

La clase String, quizás hasta más utilizada que la Integer, es una clase que permite la

definición y manejo de cadenas de caracteres. Pero un inconveniente posible es que se

define como constante y tras su creación no puede ser cambiada (se dice que es

inmutable, como explicaremos más adelante).

Por ejemplo si quisiéramos tener una cadena con valores “abc” bastaría con definir

una variable de la Clase String de la siguiente manera:

String str = "abc";

Esto automáticamente es correcto aunque quizás fuera más formal lo siguiente:

char data[] = {'a', 'b', 'c'};

String str = new String(data);

La amplia funcionalidad y manejo de String se puede ver en la gran cantidad de

métodos que disponemos en esta clase para su manejo, donde podemos hacer

comparaciones entre cadenas, comparaciones ignorando mayúsculas (muy útil cuando

por ejemplo queremos comparar si la contraseña de un usuario es la correcta),

concatenación de cadenas, consulta de carácter en una posición determinada de la

cadena, reemplazar caracteres, convertir a mayúsculas, o minúsculas, etc.

13

|

CONCEPTO DE INMUTABILIDAD

Veamos el significado de inmutable, que no es precisamente sencillo de explicar.

Consideremos que un objeto ocupa un espacio de memoria. Ahora diremos que hay

dos tipos de objetos:

a) Objetos mutables: son aquellos cuyo espacio de memoria puede ser reemplazado

por un contenido definido con posterioridad a la creación del objeto. En este caso,

cuando usamos métodos modificadores es el objeto original el que sufre el cambio.

b) Objetos inmutables: son aquellos cuyo espacio de memoria permanece ocupado

con el objeto tal y como se creó inicialmente. ¿Significa esto que no podemos usar

métodos modificadores? No, no significa eso. Significa que cuando usamos métodos

modificadores en vez de redefinirse el objeto original, la variable apuntadora pasa a

apuntar a un nuevo objeto que se crea, permaneciendo el original en su espacio de

memoria, podemos decir que en algunos casos “inaccesible”, pero estando.

En Java, la mayoría de los objetos "esenciales" son inmutables: Long, Integer, Boolean,

String, , etc. Un objeto se considera inmutable si su estado no puede cambiarse luego

de ser construido. Este comportamiento está ampliamente aceptado como una

estrategia robusta para crear código simple y confiable. La inmutabilidad se considera

efectiva en aplicaciones concurrentes (hablamos de concurrencia para referirnos a dos

tareas que transcurren durante el mismo intervalo de tiempo) donde la mutabilidad

(cambiar los objetos su estado), podría dar lugar a que los objetos se corrompieran o

llegaran a tener un estado inconsistente.

STRINGBUFFER

Es una versión mejorada o ampliada de la clase String, ya que permite su modificación

después de su creación, es decir, los objetos de tipo StringBuffer son objeto mutables.

El método más utilizado de esta clase es insert, que permite insertar cualquier objeto

de cualquier tipo como String a la secuencia de StringBuffer.

14

|

SYSTEM

Por último la clase System es una de las clases más usuales. Define tres campos err, in

y out que respectivamente son la salida estándar de error, entrada estándar y salida

estándar. Los métodos para el manejo de estas entradas y salidas estándares de datos

son bastante utilizados, al igual que el método currentTimeMillis() que devuelve la

fecha actual en milisegundos. También es muy usual el uso del métodogetenv() para

acceder a variables de entorno o propiedades del sistema. Cuando se invoca este

método, se nos devuelve información sobre el sistema con que estamos trabajando.

¿QUÉ ES NETBEANS?

NetBeans es un proyecto exitoso de código abierto con una gran base de usuarios, una

comunidad en constante crecimiento, y con cerca de 100 socios (¡y creciendo!) en todo

el mundo. Sun MicroSystems fundó el proyecto de código abierto NetBeans en junio

2000 y continúa siendo el patrocinador principal de los proyectos.

NetBeans IDE es un entorno de desarrollo - una herramienta para que los

programadores puedan escribir, compilar, depurar y ejecutar programas. Está escrito

en Java - pero puede servir para cualquier otro lenguaje de programación. Existe

además un número importante de módulos para extender el NetBeans IDE. NetBeans

IDE es un producto libre y gratuito sin restricciones de uso.

15

|

En una ventana posterior daremos

nombre al proyecto y escogeremos una

ubicación en el disco para almacenarlo.

También nos dará la opción para crear

automáticamente una clase principal, la

que hasta ahora hemos llamado Test, y

que aquí por defecto se llamará Main.

Una vez hecho esto, la ventana de

trabajo nos resultará sin duda compleja,

pero también familiar:

NetBeans nos ofrece un esqueleto de

clase Main, que podemos utilizar para hacer nuestra primera prueba. Por defecto,

NetBeans compila automáticamente los archivos en el momento en que los grabas

(icono del diskette), de forma que únicamente necesitamos utilizar el botón que

representa una flecha

verde, como el play de

un mando a distancia.

Verás el resultado de la

ejecución en la ventana

inferior:

16

|

BIBLIOTECAS DE JAVA, que son el resultado de compilar el código fuente

desarrollado por quien implementa la JRE, y que ofrecen apoyo para el desarrollo en

Java. Algunos ejemplos de estas bibliotecas son:

- Las bibliotecas centrales, que incluyen una colección de bibliotecas para implementar

estructuras de datos como listas, arrays, árboles y conjuntos.

- Bibliotecas para análisis de XML.

- Seguridad: Bibliotecas de internacionalización y localización.

- Bibliotecas de integración, que permiten la comunicación con sistemas externos.

Estas bibliotecas incluyen: La API para acceso a bases de datos JDBC (Java DataBase

Conectivity). La interfaz JNDI (Java Naming and Directory Interface) para servicios de

directorio. RMI (Remote Method Invocation) y CORBA para el desarrollo de

aplicaciones distribuidas.

- Bibliotecas para la interfaz de usuario, que incluyen: El conjunto de herramientas

nativas AWT (Abstract Windowing Toolkit), que ofrece componentes GUI (Graphical

User Interface), mecanismos para usarlos y manejar sus eventos asociados. Las

Bibliotecas de Swing, construidas sobre AWT pero ofrecen implementaciones no

nativas de los componentes de AWT.

- Plugins o conectores que permiten ejecutar applets en los navegadores Web.

- Java Web Start, para la distribución de aplicaciones Java a través de Internet.

- Documentación y licencia.

SINTAXIS

La sintaxis de Java se deriva en gran medida de C++. Pero a diferencia de éste, que

combina la sintaxis para programación genérica, estructurada y orientada a objetos,

Java fue construido desde el principio para ser completamente orientado a objetos.

Todo en Java es un objeto (salvo algunas excepciones), y todo en Java reside en alguna

17

|

clase (recordemos que una clase es un molde a partir del cual pueden crearse varios

objetos).

CÓDIGO BÁSICO EN JAVA

En lenguaje de programación java, absolutamente todo es un objeto. Así desde el

programa principal, las librerías que usemos, y archivos extras que integremos serán

clases para crear objetos, un programa básico en java necesita tener las siguientes

lineas:

La primer linea dice public class HolaMundo es la declaración de la clase:

• public especifica el nivel de acceso, esto quiere decir que la clase sera accesible por

cualquier elemento. También están los niveles private y protected

• class: especifica que es una clase.

• HolaMundo: es el nombre de la clase, tomar en cuenta que el nombre del archivo

debe ser igual al nombre de la clase que contiene el método (función de clase)

principal (main). Deben respetarse mayúsculas y minúsculas.

La segunda linea de código public static void main(String[ ] args) es la declaración de el

método principal de la aplicación de java:

• public: especifica el nivel de acceso a la método, esto quiere decir que es accesible

por cualquier método que pueda acceder a la clase de objetos .

• static: especifica que la función principal solo sera creada una vez, e invocada desde

la clase.

• void: dice que el retorno de este método sera de tipo genérico (flujo de bits),

convertible a cualquier tipo de dato.

• main: nombre del método, para este caso este nombre se reserva para el método

principal y sera usado como punto de inicio de la aplicación.

18

|

• String[ ] args: arreglo de parámetros al programa (en caso que se invoque por linea

de comandos).

• System: es una clase estándar java para llamadas al sistema, en esta se encuentras

las operaciones básicas de entrada y salida.

• out: es una clase declarada dentro de system, y se encarga de manejar las salidas

estándar del sistema, por lo general el monitor

• println: es un método de la clase out que recoge como argumento el texto que se

imprimirá en Pantalla Para poner en marcha todo hay que hacer los siguiente:

1. Editar este código en un archivo de texto el cual debe ser guardado con un nombre

como la clase principal, para este caso el archivo se llamara HolaMundo.java.

2. Luego se debe de compilar el archivo con el comando javac, este creara el archivo

HolaMundo.class. Este contiene los bytecodes que interpretara el JVM.

3. Por ultimo ejecutamos el archivo con el JVM por medio del comando java,

mandandole como parámetro el nombre de la aplicación que se creo en el numeral

anterior.

Cómo crear una aplicación nueva

menú Archivo y después pulsaremos en Nuevo proyecto.

19

|

Aparecerá una pantalla en

la que tenemos que

seleccionar qué tipo de

proyecto queremos

realizar. Seleccionaremos

la categoría Java y en el

panel de la derecha Java

Application. Después

pulsamos Next.

En la siguiente pantalla se nos preguntará por las propiedades generales del proyecto:

nombre, la carpeta donde lo queremos guardar, si queremos utilizar una carpeta

específica para guardar las librerías, si queremos crear una clase principal y si

queremos establecerla como proyecto principal.

Las opciones de arriba las podéis configurar como queráis, dejad la casilla de las

librerías desmarcada, y por último, como vemos en la fotografía, activaremos las dos

casillas de la parte inferior. Esto es necesario para que el sistema sepa que lo que

vamos a escribir será lo que tenga que ejecutar cuando finalicemos. En el cuadro de

texto he escrito “HolaMundo”, que será la aplicación que hayamos creado. Por último

pulsamos en

Finish.

La ventana de

proyectos

20

|

Ventana de código

Todo lo que aparece en color gris claro son comentarios. Es muy importante que nos

acostumbremos a realizar comentarios en nuestros programas. Esto tiene muchas

utilidades como poder recordar mejor en un futuro qué es exactamente lo que hacía

este código y también que si otra persona lo ve, pueda entender mejor cómo resuelve

el problema nuestro programa.

Para hacer un comentario de varias líneas usaremos /* para iniciarlo y */ para

finalizarlo. Si vamos a hacer un comentario de una sóla línea podemos comenzarlo por

//

En la línea 11 definimos la clase

holamundo, el cuerpo de la clase

queda encerrado entre { y},

cualquier cosa que coloquemos

entre esas llaves será el código

que pertenezca a la clase

holamundo.

21

|

En la línea 16 se ha iniciado el método principal main. Cuando se ejecuta una

aplicación, Java espera que haya un método main, ya que será lo primero que ejecute.

Este método define el punto de entrada y salida de la aplicación.

La clase define los atributos y métodos comunes a los objetos de ese tipo, pero luego,

cada objeto tendrá sus propios valores y compartirán las mismas funciones.

Debemos crear una clase antes de poder crear objetos (instancias) de esa clase. Al

crear un objeto de una clase, se dice que se crea una instancia de la clase o un objeto

propiamente dicho.

La estructura de una clase es:

class [nombre de la clase] {

[atributos o variables de la clase]

[métodos o funciones de la clase]

[main]

}

22

|

BIBLIOGRAFÍA.

http://recursostic.educacion.es/observatorio/web/ca/software/programacion/911-

monografico-java?start=2

http://es.wikipedia.org/wiki/Java_(lenguaje_de_programaci%C3%B3n)

http://es.wikibooks.org/wiki/Programaci%C3%B3n_en_Java/Caracter%C3%ADsticas_d

el_lenguaje

http://www.aprenderaprogramar.com/index.php?option=com_content&view=article

&id=583:el-paquete-javalang-interfaces-clases-string-integer-stringbuffer-concepto-

de-inmutabilidad-cu00909c&catid=58:curso-lenguaje-programacion-java-nivel-

avanzado-i&Itemid=180

http://recursostic.educacion.es/observatorio/web/ca/software/programacion/911-monografico-java?start=2

http://recursostic.educacion.es/observatorio/web/ca/software/programacion/911-monografico-java?start=2

http://es.wikipedia.org/wiki/Java_(lenguaje_de_programaci%C3%B3n)

http://es.wikibooks.org/wiki/Programaci%C3%B3n_en_Java/Caracter%C3%ADsticas_del_lenguaje

http://es.wikibooks.org/wiki/Programaci%C3%B3n_en_Java/Caracter%C3%ADsticas_del_lenguaje

http://www.aprenderaprogramar.com/index.php?option=com_content&view=article&id=583:el-paquete-javalang-interfaces-clases-string-integer-stringbuffer-concepto-de-inmutabilidad-cu00909c&catid=58:curso-lenguaje-programacion-java-nivel-avanzado-i&Itemid=180




23

|

UNIVERSIDAD TÉCNICA DE AMBATO

FACULTAD DE CIENCIAS HUMNAS Y DE LA

EDUCACIÓN

Carrera: Docencia en Informática

Modalidad Presencial

Tercer Semestre

PROGRAMACIÓN II

EJERCICIOS RESUELTOS DE

JAVA EN NETNEANS

Docente: Ing. Wilma Gavilanes.

Estudiante: Zapata Suarez Jhoselyn Ayneth

AMBATO – ECUADOR

Período: Febrero 2014-Agosto.

24

|

ENUNCIADO

Utilizando el lenguaje de programación orientado a objetos JAVA realizar una

suma ingresando dos números enteros desde teclado

ANÁLISIS

Este programa nos permite relizar la suma ded dos números ingresados por

teclado mediante la función JOptionPane.showInputDialog y luego la

convertimos en dato en tero con la función Integer.parseInt(); y realizamos la

respectiva suma e imprimimos la respuesta con la función

JOptionPane.showMessageDialog(null," " + );

CODIFICACIÓN

package sumadenumeros1;

import javax.swing.JOptionPane;

/**

*

* @author Lab03-PC02

*/

public class Sumadenumeros1 {

/**

* @param args the command line arguments

*/

public static void main(String[] args)

{

String dato1, dato2;

int num1, num2, num3;

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

num1=Integer.parseInt(dato1);

dato2=JOptionPane.showInputDialog("Ingrese el dato 2..: ");


num3=num1+num2;

JOptionPane.showMessageDialog(null,"la suma es..: " + num3);

// TODO code application logic here

}

}

Nombre del programa o proyecto

Librería

Inicio del programa

Declaración de variables de tipo

caracter

Ingresamos el 1er

numero Ingresamos el 2do

numero

Operación para hacer la suma

Visualizamos el

resultado

25

|

CORRIDO

ENUNCIADO:

Diseñar un programa en JAVA que me permita resolver las operaciones

básicas.

ANÁLISIS:

Codificaremos un programa que realice las operaciones básicas (suma, resta,

multiplicación, división), para lo cual en la suma y multiplicación no tendremos

problema ya no importa si el primer término o el segundo término sea mayor o

menor, a diferencia de la resta y la división que el primer término deberá ser

mayor que el segundo, para esto utilizaremos un controlador en estos dos

casos; y un suitch para una mejor presentación.

CÓDIFICACION

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;

Importación de librerías

del programa

Declaración de variables

26

|

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;


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;


Inicio del ciclo do

Impresión del Menú de

Opciones

Inicio del switc

Case 1 en este case

esta el proceso para la

suma con

impresiones, proceso

y una ultima

impresión para el

resultado.

Case 1 en este case


resta con impresiones,

proceso y una ultima

impresión para el

resultado. Con un

control de ingreso

Case 1 en este case


multiplicación con

impresiones, proceso

y una ultima

impresión para el

resultado

Case 1 en este

case esta el

proceso para la

división con

impresiones,

proceso y una

ultima impresión

para el resultado.

Con un control

27

|

break;

}

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

op1=Integer.parseInt(d5);

}while(op1==1);

}

}

CORRIDO

Fin del ciclo do while

Llaves de finalización del programa

28

|

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.

ANÁLISIS

Para calcular el área del cuadrado solo debo ingresar un lado y multiplicarlo

(área=l*l) mientras que para el perímetro lo sumo cuatro veces

(perímetro=l+l+l+l). Para el rectángulo, calcular el área es muy simple, solo

debo multiplicar la base por su altura, para el perímetro debo en cambio sumar

todos sus cuatro lados. Para calcular el área del triángulo debemos multiplicar

la base por su altura dividido para 2, para calcular el perímetro debemos sumar

todos sus tres lados. Ahora para el círculo solo hace falta ingresar el radio (el

perímetro es el doble del radio), su perímetro se calcula multiplicando el

diámetro por pi (PI 3.14159265) y el área se encuentra multiplicando pi por

radio al cuadrado.

DOCUMENTACIÓN

package fig_bas;


import fig_bas.figuras;

public class Fig_bas {


{

String opc;

int menu, cua, rect, circ, trian;

opc=JOptionPane.showInputDialog("FIGURAS BÁSICAS

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


del programa

Inicio del programa principal


Menú de opciones

Inicio del menú de opciones

Case 1: para encontrar el perímetro y

el área de un cuadrado


el área de un rectángulo

29

|

case 3:

circ=figuras.circulo();

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;


el área de un círculo


el área de un triángulo

Case 5: para l salir del menú

Clase (subprograma) para

calcular el perímetro y el

área de un cuadrado.



área de un rectángulo.

Inicio para crear

clases.

30

|


DEL RECTÁNGULO= " + per);


RECTÁNGULO= " + ar);

return 0;

}

public static int circulo()

{

String radio;

int r;

double pi, ar, per;

radio=JOptionPane.showInputDialog("Ingrese el radio

del círculo");

r=Integer.parseInt(radio);

pi=3.1416;

ar=pi*r*r;

per=2*pi*r;

JOptionPane.showMessageDialog(null, "ÁREAL DEL

CÍRCULO= " + ar);


DEL CÍRCULO= " + per);

return 0;

}

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.

31

|

}

}

CORRIDO

32

|

ENUNCIADO

Diseñe un programa que me permita realizar la potenciación y radicación.

ANALISIS

En este programa podemos realizar la potenciación y la radicación; para la

potenciación debemos declarar los variables de tipo carácter y de tipo enteras,

luego ingresamos la base y el exponente por teclado; por ultimo realizamos el

proceso de Math.pow(base, expo); para que se pueda realizar la potenciación,

por ultimo visualizamos la respuesta.

Para la radicación primero ingresamos un numero para poder realizar la

radicación, luego ingresamos la formula Math.sqrt(radicando); para que se

pueda realizar la radicación, por ultimo visualizamos la respuesta.

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

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

Nombre del programa o

proyecto Librerí

a

Inicio del

programa Declaración de variables de tipo

Declaración de variables de tipo

Ingresamos la base

de la potenciación

Ingresamos el exponente

Formula o proceso para poder realizar la potenciación

Visualizamos el resultado

Ingresamos el

índice de la raíz

Formula o proceso para poder realizar la radicación

Visualizamos el resultado

33

|

}}

CORRIDO

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.

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.

DOCUMENTACION

package par.impar;

Importación de librerías al programa

34

|


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

}

}

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


}

Declaración de las variables tanto String como enteras.

Sentencia repetitiva que en este caso se utiliza para

repetir el programa las veces que desee el usuario.

Este do while lo utilizamos para validar datos.

Pedimos que ingrese el número.

Utilizamos la condición if para

validar los datos.

Si la condición no se cumple indicamos un mensaje entonces pedimos

que ingrese otro número y cerramos la condición if.

Cerramos la sentencia do while e indicamos el rango que

queremos en el que se encuentre los números.

Utilizamos la condición if para determinar si es para o impar.

Si la condición se cumple imprimimos que es par y cerramos las llaves.

Caso contrario, abrimos llaves.

Se imprime que es impar y cierra las llaves.

Escribimos un mensaje para repetir o no el programa.

Se cierra la sentencia do while que permite repetir el proceso

varias veces.

Paquete del programa.

35

|

while(num2==1);

}

}

CORRIDO

Cierra completamente el programa.

36

|

ENUNCIADO:

6.- Diseñe un programa que me permita ingresar 3 valores flotantes desde

teclado que estén entre 1 y 10, obtenga el promedio correspondiente y

determine su equivalencia: aprobado, reprobado y suspenso

Si el promedio es > = 7 Aprobado

Si el promedio es > 5 y < 7 Suspenso

Si el promedio es < = 5 Reprobado

ANALISIS

Debemos llamar a las librerías para que se habilite procesos propios del

programa, luego ingresaremos los datos como: nombre, materia, y las tres

notas las cuales son validadas que deben estar entre uno y diez ;para lo cual

utilizaremos un do While y una condición si nos cumple pondremos un mensaje

para que ingrese nuevamente la nota.

Después haremos los cálculos y si la nota es mayor de siete aprobara e

imprimirá el nombre su promedio y la materia.

Si su nota es menor de siete y mayor que cinco se queda a suspenso e

imprimirá el nombre su promedio y la materia.

Si la nota es menor que cinco pues reprobara la materia e imprimirá el nombre

su promedio y la materia

Y por último utilizaremos otro do While para repetir el proceso las veces que el

usuario desee.

DOCUMENTACION

package prom

ediovalidacion;


public class Promediovalidacion {


del programa

37

|


{

String dato1, dato2,dato3,dato4, nom, mat;

float num, nombre, materia, nota1, nota2, nota3,pro;

int op;

do {

nom=JOptionPane.showInputDialog("INGRESE EL NOMBRE:");

mat=JOptionPane.showInputDialog("INGRESE EL MATERIA:");

do {

dato1= JOptionPane.showInputDialog("INGRESE LA NOTA1:");

nota1= Float.parseFloat(dato1);

if(nota1<1||nota1>11) {

JOptionPane.showInputDialog("VALOR INCORRECTO:");

} }

while(nota1<1||nota1>11);

do {





} }


do {




Ingreso de variables

Ingreso de datos

nombre y materia

del estudiante

Ingreso de la

primera nota

Condición de la nota ingresada

mensaje

Ingreso de la segunda

nota

Validación de la nota entre 1 y 10

mensaje

Condición de la nota ingresada


Ingreso de la tercera

nota

mensaje

38

|


} }


pro= (nota1+nota2+nota3)/3;

JOptionPane.showMessageDialog(null,"EL PROMEDIO ES:"+pro );

if(pro>=7) {

JOptionPane.showMessageDialog(null, " ... APROBADO ...");

JOptionPane.showMessageDialog(null, "EL ESTUDIANTE: "+nom );

JOptionPane.showMessageDialog(null, "ESTA APROBADO CON: "+pro );

JOptionPane.showMessageDialog(null, "EN LA MATERIA DE: "+mat );

}

else { if(pro>=5&&pro<7) {

JOptionPane.showMessageDialog(null, "... SUSPENSO ...");


JOptionPane.showMessageDialog(null, "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); }


Procesos promedio de notas

Impresión de

datos de

aprobado:

Nombre

Promedio

Condición de la nota >7

Impresión de

datos de

suspenso:

Nombre

Promedio

Impresión de

datos de

reprobado:

Nombre

Promedio

Ciclo

repetitivo n

veces para el

proceso.

39

|

CORRIDO

ENUNCIADO

Diseñe un programa que me permita ingresar desde teclado un límite y un

factor cualquiera y generar las tablas de multiplicar.

ANÁLISIS

En este programa podemos realizar las tablas de multiplicar; debemos declarar

los variables de tipo enteras, luego ingresamos el límite y el factor, por ultimo

visualizamos la respuesta.

DOCUMENTACION

public class Tabla {

public static void main(String[] args) { String dato1,dato2,dato3,dato4; int limite,factor,i,mult,op=0,opci,a,b,c,factorial; do { JOptionPane.showMessageDialog(null, " << SERIE DE DATOS >> \n" + "TABLA DE MULTIPLICAR");


Declaración de variables String,

int

Ingreso de Datos

Inicio del ciclo do-while

40

|

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

CORRIDO

Proceso de

multiplicación e

impresión de

resultado

Fin del ciclo do-while

41

|

ENUNCIADO

Diseñe un programa que me permita resolver un sistema de Ecuación de

Segundo Grado (ax^2 + bx +c)

ANÁLISIS

En este programa podemos realizar la Ecuación de Segundo Grado donde

debemos importar la librería principal que es import

javax.swing.JOptionPane; para este programa debemos declarar los

variables de tipo double, carácter y de tipo enteras, luego ingresamos los tres

valores posteriormente realizamos el proceso para poder sacar la ecuación

para esto debemos utilizar la formula Math.sqrt para poder sacar la raíz

cuadrada y por ultimo preguntamos si el usuario desea realizar nuevamente

otros procesos o si desea salir

DOCUMENTACIÓN

package ecuacion;


public class Ecuacion {


String dato2;

int op ;

do

{

JOptionPane.showMessageDialog

(null,"ECUACION DE SEGUNDO GRADO" );

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

42

|


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

}

}

}

CORRIDO

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

43

|

ENUNCIADO

Diseñe un programa que me permita calcular el valor total a pagar por consumo

de energía eléctrica considerando los siguientes parámetros, se leen el valor

anterior y el valor actual de consumo, en donde siempre el valor actual debe

ser mayor al valor anterior.

La diferencia entre los dos valores se devuelve el consumo actual. El costo por

vatio es $0,49

Existen 3 impuestos que se deben facturar:

3% Correspondiente a Bomberos

4% Correspondiente a taza municipal

2% otros

Visualice subtotales parciales u e total a pagar en una sola ventana

ANALISIS

Importación de bibliotecas principales que utilizaremos (import

javax.swing.JOptionPane; e importjava.text.DecimalFormat;).

Debemos declarar las variables String, double y formato para decimales.

Inicialización de ciclo do while para que el programa se repita n veces.

Ingreso del valor anterior e inicialización del ciclo do while.

Ingreso del valor actual, fin ciclo do while y validación del valor anterior debe

ser mayor que el valor actual.

44

|

Obtención de los impuestos de bomberos, taza municipal y otros los mismos

que su porcentaje será multiplicado y dividido para 100.

Impresión en una sola pantalla del consumo actual, anterior, real , costo, valor

del consumo e impuestos de bomberos, taza municipal, otros y finalmente el

total a pagar y finalización del ciclo do while principal y preguntamos si el

usuario desea realizar nuevamente otros procesos o si desea salir.

DOCUMENTACION

packageplanilla.de.luz;

importjava.text.DecimalFormat;

importjavax.swing.JOptionPane;

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

Paquetes del programa

Importación de

librerías del programa


String y double

Impresión de titulo

Escaneo del

primer

valor

Escaneo del

segundo

valor

Inicio del ciclo do while

Validación del valor 1 y valor 2

Instrucción formato para

decimales

Inicio ciclo do while principal

45

|

Dif =valor2-valor1;

Cost=dif*0.89;

Bomb= (cost*3)/100;

Tasa= (cost*4)/100;

Otros = (cost*2)/100;

Tot=cost+bomb+tasa+otros;

JOptionPane.showMessageDialog (null," CONSUMO ANTERIOR: "

+valor1+"\n CONSUMO ACTUAL: "

+valor2+ "\n CONSUMO REAL: "

+ dif + "\n COSTO: 0.89”

+ "\n << VALOR CONSUMO: "

+ f.format (cost) +"\n BOMBEROS (3%): "

+g.format (bomb) +"\n TASA MUN (4%): "

+g.format (tasa)+"\n OTROS (2%): "

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

}

}

Procesos para operaciones

Impresión de

resultados

Escaneo de

opción para

repetición del

proceso

Fin ciclo do while validado a 1

Fin del programa

46

|

CORRIDO

47

|

ENUNCIADO

Diseñe una aplicación que me permita calcular el valor de las comisiones

ganadas de los vendedores de una empresa, según lo siguientes parámetros:

la empresa dispone de 3 vendedores que realizan las ventas de sus vehículos.

Las comisiones se las concede en función de los valores facturados:

Si el valor >= 8000 <=11000 Recibe una comisión de 3% de la venta

Si el valor >11000 <=25000 Recibe una comisión de 4,5% de la

venta

Si el valor >25000 <=45000 Recibe una comisión de 6 % de la

venta

Si el valor >40000 Recibe una comisión de 8,5% de la venta

Se necesita conocer el valor acumulado por cada vendedor y el valor total

generado por comisión

ANÁLISIS

Debemos importar las bibliotecas que vayamos a utilizar en el programa, en

este caso deberemos importar la librería principal (import

javax.swing.JOptionPane ;); Debemos declarar las variables string y las

variables enteras que necesitemos. En la variable de escoger una opción

imprimimos el menú que vamos a presentar para realizar los diferentes

procesos. Convertimos la variable escoger (de string) a entero y asignamos el

valor de correspondiente. Utilizamos un swtich para realizar cada proceso del

menú. En cada case debemos ingresar los dos valores que usaremos para las

operaciones y convertirlos a datos de tipo entero. Llamamos a la variable en

que almacenaremos el resultado que será igual al nombre de la clase que

usaremos y del bloque al que pertenece, ubicando entre paréntesis las

variables de los datos ingresados. Imprimimos la variable resultante del

proceso Utilizamos un do while para preguntar al usuario si desea volver a

realizar el proceso con diferentes valores Repetimos el proceso en cada case

48

|

con la variación de realizar las posteriores operaciones a la suma. En el último

case utilizamos una instrucción que nos permitirá salir del programa mientras

este corriendo, esto es: System.exit(0); Preguntamos si el usuario desea

realizar nuevamente otros procesos o si desea salir.

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)

{

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;

Paquetes del

programa

Declaración

de variables

String, int y

double

Impresión del

Menú de

Opciones

Transformación de

variables String a

int

Incio del Switch con

Case1

Procesos para

operaciones

Decisión if y procesos

49

|

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;




comj);

}

else

{

if(vjuan>45000)

{

comj=vjuan*0.85;




comj);

}

}

}

}

opj=JOptionPane.showInputDialog

("Desea realizar una nueva venta con nuestro vendedor Juan

(1 SI/0 NO)");

op=Integer.parseInt(opj);

}

while(op==1);


respectivos para

obtener sus distintos

resultados


respectivos para


resultados


respectivos para


resultados

Cierre de sentencias if

Proceso de repetición,

mensaje y cierre del

do while

50

|

JOptionPane.showMessageDialog(null,"EMPRESA DON LUCHO" + "\n \n VENDEDOR JUAN" +

"\n \n # VENTAS: " + numj + "\n \n Total de ventas=" + totventj + "\n Comisiones ganadas= " +

comjuan );

break;

case 2:

do

{

ventmarc=JOptionPane.showInputDialog("EMPRESA DON LUCHO"

+ "\n \n VENDEDOR MARCELO" + "\n \n Valor de la venta");

vmarc=Integer.parseInt(ventmarc);

nummarc=nummarc+1;

totventm=totventm+vmarc;

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

{

commarc=vmarc*0.03;

commarcelo=commarcelo+commarc;

JOptionPane.showMessageDialog(null, "EMPRESA DON LUCHO"

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

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

}

else

{

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

{

commarc=vmarc*0.45;





}

else

{

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

{

commarc=vmarc*0.06;





}

else

{

if(vmarc>45000)

Case 2 y Do While

Impresión del

nombre y datos

subtitulos


respectivos para


resultados

Impresión del

nombre y datos

subtitulos


respectivos para


resultados

Impresión del

nombre y datos

subtitulos


respectivos para


resultados

Impresión del

nombre y datos

subtitulos


respectivos para


resultados

51

|

{

commarc=vmarc*0.85;





}

}

}

}

opj=JOptionPane.showInputDialog("Desea realizar una

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


}

while(op==1);

JOptionPane.showMessageDialog(null,"EMPRESA DON LUCHO"

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

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

"\n Comisiones ganadas= " + commarcelo);

break;

case 3:

do

{

ventmar=JOptionPane.showInputDialog("EMPRESA DON LUCHO"

+ "\n \n VENDEDORA MARÍA" + "\n \n Valor de la venta");

vmar=Integer.parseInt(ventmar);

nummar=nummar+1;

totventma=totventma+vmar;

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

{

commar=vmar*0.03;

commaria=commaria+commar;


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

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

}

else

{

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

{

commar=vmar*0.45;


Impresión del

nombre y datos

subtitulos




do while

Case 3 y Do While

Impresión del

nombre y datos

subtitulos

Impresión del

nombre y datos

subtitulos


respectivos para


resultados

Impresión del

nombre y datos

subtitulos


respectivos para


resultados

52

|


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


}

else

{

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

{

commar=vmar*0.06;



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

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

}

else

{

if(vmar>45000)

{

commar=vmar*0.85;


CJOptionPane.showMessageDialog(null, "EMPRESA DON LUCHO"

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


}

}

}

}

opj=JOptionPane.showInputDialog("Desea realizar una

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


}

while(op==1);


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

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

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

break;

case 4:

System.exit(0);

break;

}

rept=JOptionPane.showInputDialog("Desea realizar una

Impresión del

nombre y datos

subtitulos

Impresión del

nombre y datos

subtitulos


respectivos para


resultados


respectivos para


resultados

Impresión del

nombre y datos

subtitulos




do while

Impresión del

nombre y datos

subtitulos

Case 4 Opción Salir

53

|

nueva compra (1 SI/0 NO)");

op=Integer.parseInt(rept);

}

while(op==1);

total=totventj+totventm+totventma;


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

+ numj + "\n \n Total de ventas=" + totventj +

"\n Comisiones ganadas= " + comjuan +

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

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

"\n Comisiones ganadas= " + commarcelo + "\n \n

VENDEDOR MARÍA"

+ "\n \n # VENTAS: " + nummar + "\n \n Total de ventas="

+ totventma + "\n Comisiones ganadas= " + commaria+

"\n \n TODAL DE LAS VENTAS= " + total );

}}

Repetir el Programa

n veces

Suma total de las

comisiones de vendedores

Impresión de

subtítulos, para

cada vendedor y en

forma general, total,

comisiones

ganadas y

respuestas finales

Cierre del programa con

sus respectivas llaves

54

|

CORRIDO

58

|

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.

ANALISIS

Iniciamos el programa para ello debemos importar las bibliotecas que vayamos

a utilizar en el programa, en este caso deberemos importar la librería principal

(import javax.swing.JOptionPane; ) y la librería de la clase que usaremos

(import pkg13.operacionesmenu.operaciones;).

Debemos declarar las variables string y las variables enteras que necesitemos.

En la variable de escoger una opción imprimimos el menú que vamos a

presentar para realizar los diferentes procesos.

59

|

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

DOCUMENTACIÓN

package matriculas;


import java.text.DecimalFormat;

public class Matriculas {


{

String nombre,tipo,ret,repet;

int t,op1, op;

double p=120,pr=190,f1=140,con1=0,con2=0,con3=0,

sm1,sd1,si1,t1,sm2,sd2,si2,t2,sm3,sd3,si3,t3,sm11=0,

sd11=0,si11=0,sm22=0,sd22=0,si22=0,sm33=0,sd33=0,

si33=0,pt=0,prt=0, ft=0,cont, mt, smt, sit,sdt,st,tt;

DecimalFormat f=new DecimalFormat(".00");

do

{

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;


del programa


Inicio del programa

Declaración de

variables String, int y

double


Opciones

Transformación de

variables String a int


Case1 (primera opción)

Do-while proceso de

repetición

Ingreso de Datos

Procesos

60

|

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;

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;

Impresión de resultados

Break cierre de la

primera opción (case 1)

Inicio Case2 (segunda

opción)

Contadores

Ingreso de Datos

Procesos


Break cierre de la


Inicio Case3 (tercera

opción)

Contadores

Ingreso de Datos

Procesos

61

|

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;

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

}

}


Break cierre de la


Case4 (Opción Salir) Cierre del switch

Fin del proceso de repeticion

Procesos Finales

Impresión final

Fin del Programa

62

|

CORRIDO

63

|

ENUNCIADO

Diseñe un programa que me permita simular el funcionamiento de un sistema

de rol de pagos bajo los siguientes parámetros:

el nominal se ingresa conforme a la categoría si es administrativo gana Usd.

540, si es ejecutivo gana Usd 1’200,00 si es obrero gana Usd 340,00

Obtenga el valor ingresado Horas Extras tomando en puede tener un máximo

de número de horas extras 8 y cada hora cuesta Usd 3,50

Obtenga el valor de cargas familiares la misma que esta condicionada. Si el

empleado tiene más de dos hijos se le paga Usd. 4,5 por cada hijo caso

contrario se le reconoce Usd 6,2 por cada hijo

Obtenga el valor del IESS que es el 11,5 % del nominal

Se le descuenta a todos los empleados por concepto de comisariato el 2,5%

del nominal

Obtenga el total de ingreso, egresos y líquido a recibir

ANÁLISIS

En este programa hemos utilizado Do-While ya la estructura Switch para

realizar un menú de opciones en cada case va el miso proceso, en la

declaración de variables utilizamos un doublé para cantidades con decimales,

para la impresión hemos utilizando la JOptionPane.showMessageDialog y al

final cada case un break.

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;


librerías


Inicio del programa

Inicio del do-while

64

|

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

Diseño del menú

Ingreso de la opción

Inicio del switch

Ingreso del nombre

Ingreso de las horas

extras

Ingreso del número de hijos

Proceso

Proceso


Cierre del case

Ingreso del nombre


extras


Proceso

65

|

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


Cierre del case 2

Ingreso del nombre


extras


Proceso


Proceso

Cierre del case 3

Proceso par salir

Cierre del case 4

Cierre del while

Ingreso para la opción do-while

66

|

CORRIDO

ENUNCIADO

Diseñe un programa que me permita realizar las operaciones básicas a través

de un menú de opciones.

ANÁLISIS

En este programa utilizamos un switch para realizar un menú de opciones y en

cada case hacemos procesos diferentes que nos permiten hacer el cálculo de

las seis operaciones básicas en el programa principal solo ingresamos los

datos e imprimimos y llamamos al proceso que está en las funciones y lo

llamamos desde el programa principal.

Debemos importar las bibliotecas q vayamos a utilizar en nuestro programa en

este caso (import javax.swing.JOptionPane;)

67

|

DOCUMENTACION

package seisop; import javax.swing.JOptionPane; import seisop.funcionesop; public class Seisop { public static void main(String[] args) { String dato1,dato2,op,opa; int a,b,op1,sum1,res1,mult1,opb; double div1,pot1,rad1; do{ op=JOptionPane.showInputDialog("ESCOJA UNA OPCION \n1.-SUMA\n2.-RESTA\n3.-MULTIPLICACION\n"+ "4.-DIVISION\n5. -POTENCIACION \n6.-RADICACION\n7.-SALIR"); op1=Integer.parseInt(op); switch(op1) { case 1: dato1=JOptionPane.showInputDialog("Dato 1 :"); a=Integer.parseInt(dato1); dato2=JOptionPane.showInputDialog("Dato 2 :"); b=Integer.parseInt(dato2); sum1=funcionesop.suma1(a, b); JOptionPane.showMessageDialog(null,"La suma es: "+sum1); break; case 2: do { dato1=JOptionPane.showInputDialog("Dato 1 :"); a=Integer.parseInt(dato1); dato2=JOptionPane.showInputDialog("Dato 2 :"); b=Integer.parseInt(dato2); }while(a<b); res1=funcionesop.resta(a, b); JOptionPane.showMessageDialog(null,"La resta es:"+res1); break; case 3: dato1=JOptionPane.showInputDialog("Dato 1 :"); a=Integer.parseInt(dato1); dato2=JOptionPane.showInputDialog("Dato 2 :"); b=Integer.parseInt(dato2); mult1=funcionesop.multiplicacion(a, b); JOptionPane.showMessageDialog(null,"La multiplicacion es:"+mult1); break; case 4: do { dato1=JOptionPane.showInputDialog("Dato 1 :");


del programa y paquete


Declaración de

variables

Menú de Opciones

Ingreso de datos

Llamamos a la clase

Impresión del mensaje

Do-while para el control

en la resta

Ingreso de datos

Llamamos a la clase


Ingreso de datos

Llamamos a la clase


Control para el proceso de la división

Ingreso de datos

68

|

a=Integer.parseInt(dato1); dato2=JOptionPane.showInputDialog("Dato 2 :"); b=Integer.parseInt(dato2); }while(a<b); div1=funcionesop.division(a, b); JOptionPane.showMessageDialog(null,"La division es:"+div1); break; case 5: dato1=JOptionPane.showInputDialog("Base :"); a=Integer.parseInt(dato1); dato2=JOptionPane.showInputDialog("Exponente :"); b=Integer.parseInt(dato2); pot1=funcionesop.potencia(a, b); JOptionPane.showMessageDialog(null,"La potencia es:"+pot1); break; case 6: dato1=JOptionPane.showInputDialog("Numero :"); a=Integer.parseInt(dato1); rad1=funcionesop.radicacion(a); JOptionPane.showMessageDialog(null,"La raiz es:"+rad1); break; } opa=JOptionPane.showInputDialog("INGRESE 1 CONTINUAR Y 0 PARA SALIR:"); opb=Integer.parseInt(opa); }while(opb==1); } } 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);

Llamamos a la clase


Ingreso de datos

Llamamos a la clase


Ingreso de datos

Llamamos a la clase


Mensaje de do-while para

enviar un mensaje si desea

repetir

Nombre del programa principal

Proceso de suma

Proceso de resta

Proceso de multiplicación

Proceso de división

69

|

return dividir; } public static double potencia(double a1, double b1) { double poten; poten=Math.pow(a1,b1); return poten; } public static double radicacion(double a1) { double radical; radical=Math.sqrt(a1); return radical; } }

CORRIDO

Proceso de potencia

Proceso de radicación

70

|

ENUNCIADO

Diseñe un menú de opciones que me permita realzar las 6 operaciones básicas

con datos enteros ingresados desde teclado, utilizando clases.

ANALISIS

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 ingresar los dos valores que usaremos para las

operaciones (a excepción de la radicación) y convertirlos a datos de tipo entero.

Llamamos a la variable en que almacenaremos el resultado que será igual al

nombre de la clase que usaremos y del bloque al que pertenece, ubicando

entre parentesis las variables de los datos ingresados.

Imprimimos la variable resultante del proceso

Utilizamos un do while para preguntar al usuario si desea volver a realizar el

proceso con diferentes valores

Repetimos el proceso en cada case con la variación de realizar las posteriores

operaciones a la suma.

En el ultimo case utilzamos una instrucción que nos permitirá salir del programa

miestras este corriendo, esto es: System.exit(0);

71

|

Preguntamos si el usuario desea realizar nuevamente otros procesos o si

desea salir

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{


del programa


Declaración de


double


Opciones

Transformación de

variables String a int


Case1

Ingreso de Datos

Llamado de clase o

función

DO WHILE y break

Case 2 y Do While

72

|







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


Ingreso de Datos

Llamado de clase o

función

DO WHILE y break

Case 3 y Do While

Ingreso de Datos

Llamado de clase o

función

DO WHILE y break

Case 4 y Do While

Ingreso de Datos

Llamado de clase o

función

Validación de datos

Validación de datos

73

|

(null, "La División es: "+ division);


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


}while(op==1);

break;

case 5:

do{


("Ingrese la base: ");



("Ingrese el exponente: ");


potenciacion=operaciones.potencia(num1, num2);


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


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


}while(op==1);

break;

case 6:

do{

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


radicacion=operaciones.raiz(num1);


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


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


}while(op==1);

break;

case 7:

System.exit(0);

break;

}


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


DO WHILE y break

Case 5 y Do While

Ingreso de Datos

Llamado de clase o

función

DO WHILE y break

Case 6 y Do While

Ingreso de Datos

Llamado de clase o

función

DO WHILE y break

Case 7 Opción Salir

Fin del Switch

Repetir el Programa n

veces

74

|

}while(op==1);

}

}

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)

Fin del Programa

Nombre del Programa

principal

Inicio de Clase o

Función

Proceso de suma

Proceso de resta

Proceso de

multiplicación

Proceso de división

Proceso de

potenciación

75

|

{

double raiz;

raiz=Math.sqrt(a);

return raiz;

}

}

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.

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.

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"); limite=Integer.parseInt(dato2); primos=series.primos(limite);

Proceso de radicación


del programa

Declaración de


double


Opciones

Inicio del Switch con

Case1

Ingreso del límite y

Llamado de clase o

función Inicio del Switch con

Case 2

76

|

break; case 2: dato2=JOptionPane.showInputDialog("Ingrese un limite"); limite=Integer.parseInt(dato2); factor=series.facto(limite); break; case 3: dato2=JOptionPane.showInputDialog("Ingrese un limite"); limite=Integer.parseInt(dato2); fibo=series.fibo(limite); break; case 4: dato2=JOptionPane.showInputDialog("Ingrese un limite"); limite=Integer.parseInt(dato2); pares=series.par(limite); break; case 5: System.exit(0); break; } dato3=JOptionPane.showInputDialog("Volver al menu 1 Salir 0: "); opc=Integer.parseInt(dato3); } while(opc==1); } } package menuseries; import javax.swing.JOptionPane; public class series { public static int par (int limite) { int p; int i; p=0; for(i=1;i<=limite;i++) { p=p+2; JOptionPane.showMessageDialog(null, +p); } return 0; } public static int primos (int limite) { int conta,residuo,i,j; for(i=1;i<=limite;i++) { conta=0; for(j=1;j<=i;j++)


Llamado de clase o

función Inicio del Switch con

Case 3 Ingreso del límite y

Llamado de clase o

función Inicio del Switch con Case 4


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

Serie de numeros primos

77

|

{ residuo=i%j; if(residuo==0) { conta=conta+1; } } if(conta==2) { JOptionPane.showMessageDialog(null, +i); } } return 0; } public static int facto(int limite) { int f,i; f=1; i=1; i=i+1; for(i=1;i<=limite;i++) { f=f*i; JOptionPane.showMessageDialog(null, +i+f); } return 0; } public static int fibo(int limite) { int m,i,j,c,a = 0,b=1; m=1; for(j=1;j<=limite-1;j++) { m=m+3; } for(i=0;i<=limite-2;i++) { c=a+b; a=b; b=c; JOptionPane.showMessageDialog(null, +a); } return 0; } }

Serie de numeros primos

Serie de la factorial

Serie del Fibonacci

78

|

CORRIDO

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

ANALISIS

Este programa permite verificar la edad a que categoría corresponde. 1.

Importación de bibliotecas principales que utilizaremos (import

javax.swing.JOptionPane; e importjava.text.DecimalFormat;). Debemos

declarar las variables String, double y formato para decimales. Inicialización de

ciclo do while para que el programa se repita n veces, llamamos a las clases.

En las clases hacemos el proceso correspondiente mediante un if, else e

impresiones de pantalla.

79

|

CODIFICACION

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

}

}

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

Importación de librerías del programa


Declaración de variables String y double

Inicio ciclo do while principal

LLAMA A LAS FUNCIONES

SE CIERRA EL LAZO REPETITIVO

Importación de librerías del programa

PROCESO

80

|

{

if(edad1>=18 && edad1<=45)

{

JOptionPane.showMessageDialog(null, "ADULTO: "+edad1);

}

else

{

if(edad1>45)

{

JOptionPane.showMessageDialog(null, "ADULTO MAYOR: "+edad1);

}

}

}

}

}

return 0;

}

}

CORRIDO

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

SE CIERRA LA CLASE

81

|

ANÁLISIS

Necesitaremos una variable tipo int para generar la descomposición en sus

unidades

Documentación

package decompocicion;


import decompocicion.descomponer;

public class Decompocicion {


String num;

int a,res;

do{

num=JOptionPane.showInputDialog("NUMERO");

a=Integer.parseInt(num);

}while(a<1 || a>9999);

res=descomponer.descomponer(a);

}

}

Clase

package decompocicion;


public class descomponer {

public static int descomponer(int a)

{

int um,c,d,u;

um=a;

um=(um/1000)*1000;

c=a;

c=c-um;

c=(c/100)*100;

d=a;

d=d-um-c;

d= (d/10)*10;

u=(a-um)-c-d;

JOptionPane.showMessageDialog(null,"Unidad "+u+"\nDecena "+d+"\nCentena "+c

+"\nUnidad de mil "+um+"\nTotal "+a);

return 0;

}

}


del programa


Declaración de variables tipo int y string

Fin del programa principal

Programa principal importación de librerías e inicio de clases

Clase descomposición

con su respectivo

proceso para realizar

una descomposición en

sus unidades

82

|

CORRIDO

ENUNCIADO

Diseñe un menú de opciones utilizando clases que me permita diseñar un

sistema de conversiones de numeros de diferentes bases.

Se necesita convertir un numero entero a su binario correspondiente, un entero

a octal y un entero a hexadecimal.

ANALISIS

Para realizar este proyecto primero debemos importar las bibliotecas que

vayamos a utilizar, Declarar datos del tipo que necesitemos y empezar el

programa con títulos y un menú de opciones que nos permita escoger la

conversión que deseemos realizar, seguido de una clase para realizar cada

conversion, también con la opción de repetir el proceso las veces que desee el

usuario presentando al fin los resultados respectivos que queremos.

DOCUMENTACIÓN

package conversiones; 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 {


del programa

Declaración de


double


Opciones

83

|

dato=JOptionPane.showInputDialog("1. BINARIO \n 2. OCTAL \n 3. HEXADECIMAL \n 4. SALIR \n Ingrese una Opcion: "); opc=Integer.parseInt(dato); switch(opc) { case 1: dato1=JOptionPane.showInputDialog("Ingrese un numero: "); a=Integer.parseInt(dato1); bi=convers.bi(a); break; case 2: dato1=JOptionPane.showInputDialog("Ingrese un numero: "); a=Integer.parseInt(dato1); oc=convers.oct(a); break; case 3: dato1=JOptionPane.showInputDialog("Ingrese un numero: "); a=Integer.parseInt(dato1); hexa=convers.he(a); break; case 4: System.exit(0); break; } dato2= JOptionPane.showInputDialog("VOLVER AL MENU 1 SALIR 0: "); op=Integer.parseInt(dato2); } while(op==1); } }

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

Inicio del Switch con

Case1 Ingreso el número que

deseo transformar a

binario y llamamos a la

clase

Ingreso el número que

deseo transformar a

octal y llamamos a la

clase

Fin del Programa

Nombre del Programa

principal

Transformación de un

número decimal a binario

Inicio del Switch

con Case 3

Fin del Switch con Case 4

Repetir el Programa

n veces

Ingreso el número que deseo transformar a

hexadecimal y llamamos a la clase


número decimal a octal


número decimal a

hexadecimal

84

|

}

CORRIDO

PROGRAMACIÓN EN JAVA

Education

Transcript of PROGRAMACIÓN EN JAVA