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

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("SUMAn"+"INGRESE EL PRIMER DATO : ");
n=Integer.parseInt(d2);
d3=JOptionPane.showInputDialog("INGRESE EL SEGUNDO DATO : ");
m=Integer.parseInt(d3);
c=n+m;
JOptionPane.showMessageDialog(null,"RESPUESTA : "+c);
break;
case 2:
d2=JOptionPane.showInputDialog("RESTAn"+"INGRESE EL PRIMER DATO : ");
do
{
}while(n>m);
c=n-m;
break;
case 3:
d2=JOptionPane.showInputDialog("MULTIPLICACION
n"+"INGRESE EL PRIMER DATO : ");
c=n*m;
break;
case 4:
d2=JOptionPane.showInputDialog("DIVICIONn"+"INGRESE EL PRIMER DATO : ");
do
{
}while(n>m);
c=n/m;
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
nn1.- Cuadrado n2.- Rectángulo n3.- Círculo n4.- Triángulo
n5.- Salir nnQue desea realizar");
menu=Integer.parseInt(opc);
switch(menu)
{
case 1:
cua=figuras.cuadrado();
break;
case 2:
rect=figuras.rectandulo();
break;
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.

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
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 {
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
programaDeclaració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

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

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

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;
public class Prueba {
String opc1,opc,nom,ce;
double ad=540,ej=1200,ob=340,he,ph,h,pi,ie,co,te,ti,st,sp,op1;
int a,op;
librerías
Inicio del programa
Inicio del do-while

64
|
do{
DecimalFormat df=new DecimalFormat(".00");
opc=JOptionPane.showInputDialog(" LIQUIDO TOTAL DE EMPLEADOSn"+"1.-
Administrativon"
+"2.-Ejeutivon"+"3.-Obreron"+"5.-Salir");
op=Integer.parseInt(opc);
switch(op)
{
case 1:
nom=JOptionPane.showInputDialog("Nombre: ");
do{
he=Double.parseDouble(JOptionPane.showInputDialog("Horas extras: "));
}while(he>8);
ph=he*3.50;
h=Double.parseDouble(JOptionPane.showInputDialog("Hijos: "));
if(h>2)
{
pi=h*4.50;
}
else
{
pi=h*6.20;
}
ti=ph+pi;
ie=ad*0.115;
co=ad*0.025;
te=ie+co;
sp=ad+ph+pi;
st=sp-ie-co;
JOptionPane.showMessageDialog(null," REPORTE
GENERALn"+nom+"nAdministrativo"+"nSueldo "
+ad+"nnIngresos "+ti+"nHoras extras "
+ph+"nCargas familiares "+pi+"nnEgresos "+te+"nIESS "+ie+
"nComisiariato "+co+"nSueldo a recibir "+st);
break;
case 2:
do{
}while(he>8);
ph=he*3.50;
if(h>2)
{
pi=h*4.50;
}
else
{
pi=h*6.20;
}
ti=ph+pi;
ie=ej*0.115;
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;
GENERALn"+nom+"nEjecutivo"+"nSueldo "
+ej+"nnIngresos "+ti+"nHoras extras "
break;
case 3:
do{
}while(he>8);
ph=he*3.50;
if(h>2)
{
pi=h*4.50;
}
else
{
pi=h*6.20;
}
ti=ph+pi;
ie=ob*0.115;
co=ob*0.025;
te=ie+co;
sp=ob+ph+pi;
st=sp-ie-co;
GENERALn"+nom+"nObrero"+"nSueldo "
+ob+"nnIngresos "+ti+"nHoras extras "
break;
case 4:
System.exit(0);
break;
}
opc1=JOptionPane.showInputDialog("Salir 1/0: ");
op1=Integer.parseInt(opc1);
}while(op1==1);
}
}
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 seisop.funcionesop;
public class Seisop {
String dato1,dato2,op,opa;
int a,b,op1,sum1,res1,mult1,opb;
double div1,pot1,rad1;
do{
op=JOptionPane.showInputDialog("ESCOJA UNA OPCION
n1.-SUMAn2.-RESTAn3.-MULTIPLICACIONn"+
"4.-DIVISIONn5. -POTENCIACION
n6.-RADICACIONn7.-SALIR");
op1=Integer.parseInt(op);
switch(op1)
{
case 1:
dato1=JOptionPane.showInputDialog("Dato 1 :");
a=Integer.parseInt(dato1);
b=Integer.parseInt(dato2);
sum1=funcionesop.suma1(a, b);
JOptionPane.showMessageDialog(null,"La suma es: "+sum1);
break;
case 2:
do
{
}while(a<b);
res1=funcionesop.resta(a, b);
JOptionPane.showMessageDialog(null,"La resta es:"+res1);
break;
case 3:
mult1=funcionesop.multiplicacion(a, b);
JOptionPane.showMessageDialog(null,"La multiplicacion es:"+mult1);
break;
case 4:
do
{
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
|
}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(null,"La potencia es:"+pot1);
break;
case 6:
dato1=JOptionPane.showInputDialog("Numero :");
rad1=funcionesop.radicacion(a);
JOptionPane.showMessageDialog(null,"La raiz es:"+rad1);
break;
}
opa=JOptionPane.showInputDialog("INGRESE 1 CONTINUAR
Y 0 PARA SALIR:");
opb=Integer.parseInt(opa);
}while(opb==1);
}
}
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 nn 1. Suma n 2. Resta n
3. Multiplicación n 4. División n 5. Potenciación n
6. Radicación n 7. Salir nn Escoja una opcion:");
es=Integer.parseInt(escoger);
switch(es)
{
case 1:
do{
dato1=JOptionPane.showInputDialog
("Ingrese el primer valor: ");
("Ingrese el segundo valor: ");
suma=operaciones.sumar(num1, num2);
(null, "La Suma es: "+ suma);
opcion=JOptionPane.showInputDialog
("Desea realizar otra suma: 1=si / 0=no");
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 menuseries.series;
public class Menuseries {
{
String dato1, dato2,dato3;
int op,limite,pares,num,i,p,primos,factor,fibo,opc;
JOptionPane.showMessageDialog(null, "MENU DE SERIES ");
do
{dato1=JOptionPane.showInputDialog("1. PRIMOS n 2. FACTORIAL
n 3. FIBONACCI n 4. PARES n 5. SALIR n Ingrese una opcion: ");
switch(op)
{
case 1:
dato2=JOptionPane.showInputDialog("Ingrese un limite");
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
Case 2

76
|
break;
case 2:
factor=series.facto(limite);
break;
case 3:
fibo=series.fibo(limite);
break;
case 4:
pares=series.par(limite);
break;
case 5:
System.exit(0);
break;
}
dato3=JOptionPane.showInputDialog("Volver al menu 1 Salir 0: ");
opc=Integer.parseInt(dato3);
}
while(opc==1);
}
}
package menuseries;
public class series
{
public static int par (int limite)
{
int p;
int i;
p=0;
{
p=p+2;
JOptionPane.showMessageDialog(null, +p);
}
return 0;
}
public static int primos (int limite)
{
int conta,residuo,i,j;
{
conta=0;
for(j=1;j<=i;j++)
Llamado de clase o
función
Case 3
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;
{
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
BEBEn3 a 11 años NIÑOn12 a 17 años ADOLESCENTEn18 a 45 años ADULTOn45 en
adelante ADULTO MAYORn**INGRESE UNA EDAD** ");
edad1=Integer.parseInt(opcion);
edades=edad.edades(edad1);
dato=JOptionPane.showInputDialog(null,"DESEA REPETIR 1 O 0 PARA SALIR: ");
op=Integer.parseInt(dato);
}while(op==1);
}
}
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;
public class Conversiones {
{
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: ");
bi=convers.bi(a);
break;
case 2:
oc=convers.oct(a);
break;
case 3:
hexa=convers.he(a);
break;
case 4:
System.exit(0);
break;
}
dato2= JOptionPane.showInputDialog("VOLVER AL MENU 1 SALIR 0: ");
}
while(op==1);
}
}
package conversiones;
public class convers
{
public static int bi (int a)
{
JOptionPane.showMessageDialog(null, "Numero Binario:
"+Integer.toBinaryString(a));
return 0;
}
public static int oct (int a)
{
JOptionPane.showMessageDialog(null, "Numero Octal:
"+Integer.toOctalString(a));
return 0;
}
public static int he(int a)
{
JOptionPane.showMessageDialog(null, "Numero Hexadecimal:
"+Integer.toHexString(a));
return 0;
}
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

PROGRAMACIÓN EN JAVA

Más contenido relacionado

La actualidad más candente

Destacado

Similar a PROGRAMACIÓN EN JAVA

Más de Jhos Ayneth Suarez

Último

PROGRAMACIÓN EN JAVA