Page 1

|

0


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.

1


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

2


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.

3


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

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 |

identificador.

4


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

Cambio de signo

!

Operador NOT

~

Complemento a 1

|

Operador Descripción

5


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.

6


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

7


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 double, float, long, int, char, short

short

double, float, long, int

char

double, float, long, int

int

double, float, long

long

double, float

|

byte

8


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

9


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,

10


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

wrappers más utilizada con diferencia

|

Esta es quizás la clase de todos los

11


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.

12


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.

13


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.

14


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:

15


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,

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

|

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

16


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.

17


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

18


Aparecerá una pantalla en la

que

tenemos

que

seleccionar qué tipo de proyecto realizar.

queremos 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

19


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.

20


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]

|

}

21


BIBLIOGRAFĂ?A. http://recursostic.educacion.es/observatorio/web/ca/software/programacion/911monografico-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-conceptode-inmutabilidad-cu00909c&catid=58:curso-lenguaje-programacion-java-nivel-

|

avanzado-i&Itemid=180

22


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.

23


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 {

Nombre del programa o proyecto Librería

}

|

/** * @param args the command line arguments */ public static void main(String[] args) Inicio del programa { String dato1, dato2; Declaración de variables de tipo int num1, num2, num3; caracter dato1=JOptionPane.showInputDialog("Ingrese el dato 1..: "); Ingresamos el 1er num1=Integer.parseInt(dato1); numero Ingresamos el 2do dato2=JOptionPane.showInputDialog("Ingrese el dato 2..: "); numero num2=Integer.parseInt(dato2); Operación para hacer la suma num3=num1+num2; JOptionPane.showMessageDialog(null,"la suma es..: " + num3); // TODO code application logic here Visualizamos el } resultado

24


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

Importación de librerías del programa Declaración de variables

|

package operacionesbasicas; import javax.swing.JOptionPane; public class Operacionesbasicas { public static void main(String[] args) { String d1,d2,d3,d4,d5; int op,n,m,a,b,c,op1;

25


Inicio del ciclo do do { d1=JOptionPane.showInputDialog("**OPERACIONES BASICAS**"+"\n 1.-SUMA"+"\n 2.RESTA"+"\n 3.-MULTIPLICACION"+"\n 4.-DIVISION"+"\n 5.-SALIR"); Impresión del Menú de op=Integer.parseInt(d1); Opciones switch(op) Inicio del switc { Case 1 en este case case 1: d2=JOptionPane.showInputDialog("SUMA\n"+"INGRESE EL PRIMER DATO : "); esta el proceso para la suma con n=Integer.parseInt(d2); impresiones, proceso d3=JOptionPane.showInputDialog("INGRESE EL SEGUNDO DATO : "); y una ultima m=Integer.parseInt(d3); impresión para el c=n+m; resultado. JOptionPane.showMessageDialog(null,"RESPUESTA : "+c);

|

break; Case 1 en este case case 2: esta el proceso para la d2=JOptionPane.showInputDialog("RESTA\n"+"INGRESE EL PRIMER DATO : "); resta con impresiones, n=Integer.parseInt(d2); proceso y una ultima do impresión para el { resultado. Con un d3=JOptionPane.showInputDialog("INGRESE EL SEGUNDO DATO : "); control de ingreso m=Integer.parseInt(d3); }while(n>m); c=n-m; JOptionPane.showMessageDialog(null,"RESPUESTA : "+c); break; case 3: Case 1 en este case d2=JOptionPane.showInputDialog("MULTIPLICACION esta el proceso para la \n"+"INGRESE EL PRIMER DATO : "); multiplicación con n=Integer.parseInt(d2); impresiones, proceso d3=JOptionPane.showInputDialog("INGRESE EL SEGUNDO DATO : "); y una ultima m=Integer.parseInt(d3); impresión para el c=n*m; resultado JOptionPane.showMessageDialog(null,"RESPUESTA : "+c); break; Case 1 en este case 4: case esta el d2=JOptionPane.showInputDialog("DIVICION\n"+"INGRESE EL PRIMER DATO : "); proceso para la n=Integer.parseInt(d2); división con do impresiones, { proceso y una d3=JOptionPane.showInputDialog("INGRESE EL SEGUNDO DATO : "); ultima impresión m=Integer.parseInt(d3); para el resultado. }while(n>m); Con un control c=n/m; JOptionPane.showMessageDialog(null,"RESPUESTA : "+c);

26


break; }

Fin del ciclo do while d5=JOptionPane.showInputDialog("DESEA REPETIR 1 O 0 PARA SALIR: "); op1=Integer.parseInt(d5); }while(op1==1); } Llaves de finalizaci贸n del programa }

|

CORRIDO

27


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

Menú de opciones

|

package fig_bas; import javax.swing.JOptionPane; Importación de librerías import fig_bas.figuras; del programa public class Fig_bas { public static void main(String[] args) Inicio del programa principal { String opc; Declaración de variables 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); Inicio del menú de opciones switch(menu) { case 1: Case 1: para encontrar el perímetro y cua=figuras.cuadrado(); el área de un cuadrado break; case 2: Case 2: para encontrar el perímetro y rect=figuras.rectandulo(); el área de un rectángulo break;

28


case 3: circ=figuras.circulo(); break; case 4: trian=figuras.triangulo(); break; case 5: System.exit(0); break;

Case 3: para encontrar el perímetro y el área de un círculo Case 4: para encontrar el perímetro y 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.

Clase (subprograma) para calcular el perímetro y el área de un rectángulo. |

package fig_bas; import javax.swing.JOptionPane; Inicio para crear public class figuras clases. { public static int cuadrado() { String lado; int l, per, ar; lado=JOptionPane.showInputDialog("Ingrese el lado del cuadrado: "); l=Integer.parseInt(lado); per=l*4; ar=l*l; JOptionPane.showMessageDialog(null, "PERIMETRO DEL CUADRADO= " + per); JOptionPane.showMessageDialog(null, "ÁREA DEL CUADRADO= " + ar); return 0; } public static int rectandulo() { String lado1, lado2; int l1, l2, ar, per; lado1=JOptionPane.showInputDialog("Ingrese la base del rectángulo"); l1=Integer.parseInt(lado1); lado2=JOptionPane.showInputDialog("Ingrese la altura del rectángulo"); l2=Integer.parseInt(lado2); per=l1*2+l2*2; ar=l1*l2;

29


JOptionPane.showMessageDialog(null, "PERIMETRO DEL RECTÁNGULO= " + per); JOptionPane.showMessageDialog(null, "ÁREA DEL RECTÁNGULO= " + ar); return 0;

public static int triangulo() { String lado1, lado2, lado3; int l1, l2, l3, per, ar; lado1=JOptionPane.showInputDialog("Ingrese la base del triángulo"); l1=Integer.parseInt(lado1); lado2=JOptionPane.showInputDialog("Ingrese la altura del triángulo"); l2=Integer.parseInt(lado2); lado3=JOptionPane.showInputDialog("Ingrese el lado restante del triángulo"); l3=Integer.parseInt(lado3); per=l1+l2+l3; ar=(l1*l2)/2; JOptionPane.showMessageDialog(null, "PERIMETRO DEL TRIÁNGULO= " + per); JOptionPane.showMessageDialog(null, "ÁREA DEL TRIÁNGULO= " + ar); return 0;

Clase (subprograma) para calcular el perímetro y el área de un círculo.

Clase (subprograma) para calcular el perímetro y el área de un triángulo.

|

} public static int circulo() { String radio; int r; double pi, ar, per; radio=JOptionPane.showInputDialog("Ingrese el radio del círculo"); r=Integer.parseInt(radio); pi=3.1416; ar=pi*r*r; per=2*pi*r; JOptionPane.showMessageDialog(null, "ÁREAL DEL CÍRCULO= " + ar); JOptionPane.showMessageDialog(null, "PERIMETRO DEL CÍRCULO= " + per); return 0; }

30


} }

|

CORRIDO

31


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.

package poteyradi; Nombre del programa o proyecto Librerí import javax.swing.JOptionPane; public class PoteyRadi { a public static void main(String[] args) Inicio del { programa Declaración de variables de tipo String dato1, dato2; double base, expo, resp; Declaración de variables de tipo JOptionPane.showMessageDialog(null,"Potenciacion"); Ingresamos la base dato1=JOptionPane.showInputDialog("Ingrese una base: "); de la potenciación base=Integer.parseInt(dato1); dato2=JOptionPane.showInputDialog("Ingrese el exponente: "); Ingresamos el exponente expo=Integer.parseInt(dato2); Formula o proceso para poder realizar la potenciación resp=Math.pow(base, expo); JOptionPane.showMessageDialog(null, "El resultado es: "+resp); Visualizamos el resultado JOptionPane.showMessageDialog(null,"Radicación"); double radicando, raiz; Ingresamos el dato1=JOptionPane.showInputDialog("Ingrese un indice: "); índice de la raíz radicando=Integer.parseInt(dato1); raiz=Math.sqrt(radicando); Formula o proceso para poder realizar la radicación JOptionPane.showConfirmDialog(null,"La raiz es: "+raiz); Visualizamos el resultado

|

DOCUMENTACION

32


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

33


import javax.swing.JOptionPane; public class PARIMPAR { @SuppressWarnings("empty-statement")

Paquete del programa.

public static void main(String[] args) { String dato1,dato2;

Declaración de las variables tanto String como enteras.

int num1,num2;

Sentencia repetitiva que en este caso se utiliza para repetir el programa las veces que desee el usuario.

do { do

Este do while lo utilizamos para validar datos. { dato1=JOptionPane.showInputDialog("INGRESE EL NUMERO ");

Pedimos que ingrese el número.

num1=Integer.parseInt(dato1); if(num1<6 ||num1>65)

Utilizamos la condición if para validar los datos.

{

JOptionPane.showMessageDialog(null,"EL NUMERO "+num1+" NO ESTA DENTRO DEL RANGO"); }

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.

while(num1<6 || num1>65); if(num1%2==0)

Utilizamos la condición if para determinar si es para o impar. { JOptionPane.showMessageDialog(null,"EL NUMERO "+num1+" ES PAR "); } else

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

{ JOptionPane.showMessageDialog(null,"EL NUMERO "+ num1+" ES IMPAR "); }

Se imprime que es impar y cierra las llaves.

num2=Integer.parseInt(dato2); }

Escribimos un mensaje para repetir o no el programa.

Se cierra la sentencia do while que permite repetir el proceso varias veces.

|

dato2=JOptionPane.showInputDialog("PRESIONE 1 PARA SALIR 0 PARA VOLVER");

34


while(num2==1); }

Cierra completamente el programa. }

|

CORRIDO

35


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;

Importación de librerías del programa

public class Promediovalidacion {

|

import javax.swing.JOptionPane;

36


public static void main(String[] args) { String dato1, dato2,dato3,dato4, nom, mat; Ingreso de variables

float num, nombre, materia, nota1, nota2, nota3,pro; int op; do { nom=JOptionPane.showInputDialog("INGRESE EL NOMBRE:");

Ingreso de datos nombre y materia del estudiante

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

{ Ingreso de la primera nota

dato1= JOptionPane.showInputDialog("INGRESE LA NOTA1:"); nota1= Float.parseFloat(dato1); if(nota1<1||nota1>11) {

Condici贸n de la nota ingresada

JOptionPane.showInputDialog("VALOR INCORRECTO:"); }

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

Validaci贸n de la nota entre 1 y 10

{

dato2= JOptionPane.showInputDialog("INGRESE LA NOTA2:"); nota2= Float.parseFloat(dato2);

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

Condici贸n de la nota ingresada

JOptionPane.showInputDialog("VALOR INCORRECTO:"); }

mensaje

}

while(nota2<1||nota2>11); do

Ingreso de la segunda nota

Validaci贸n de la nota entre 1 y 10

{

dato3= JOptionPane.showInputDialog("INGRESE LA NOTA3:"); nota3= Float.parseFloat(dato3); if(nota3<1||nota3>11)

Ingreso de la tercera nota |

}

mensaje

{ mensaje

37


JOptionPane.showInputDialog("VALOR INCORRECTO:"); }

} Validaciรณn de la nota entre 1 y 10

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

Procesos promedio de notas

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

JOptionPane.showMessageDialog(null,"EL PROMEDIO ES:"+pro ); if(pro>=7)

{

Condiciรณn de la nota >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 );

Impresiรณn de datos de aprobado: Nombre Promedio

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

{

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

Impresiรณn de datos de suspenso:

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

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

} else

{

JOptionPane.showMessageDialog(null, "... REPROBADO ..."); JOptionPane.showMessageDialog(null, "EL ESTUDIANTE: "+nom ); JOptionPane.showMessageDialog(null, "ESTA REPROBADO CON: "+pro ); JOptionPane.showMessageDialog(null, "EN LA MATERIA DE: "+mat );

Promedio

}

dato4= JOptionPane.showInputDialog("CONTINUAR1 TERMINAR 0:"); op= Integer.parseInt(dato4); }

while(op==1);

Nombre

}

Ciclo repetitivo n veces para el proceso. |

}

Impresiรณn de datos de reprobado:

38


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

Nombre del programa o proyecto

Declaración de variables String, int Inicio del ciclo do-while |

public class Tabla {

Ingreso de Datos

39


dato1=JOptionPane.showInputDialog("INGRESE EL LIMITE:"); limite=Integer.parseInt(dato1); dato2=JOptionPane.showInputDialog("INGRESE EL FACTOR:"); factor=Integer.parseInt(dato2); for(i=1;i<=limite;i++) { mult=i*factor; JOptionPane.showMessageDialog(null, " LA TABLA DE MULTIPLICAR ES: \n" + factor + "*" + i + " = " + mult); } dato3=JOptionPane.showInputDialog(" PULSE 1 PARA CONTINUAR O 0 PARA SALIR "); op=Integer.parseInt(dato3); } while(op==1); } }

Proceso de multiplicaci贸n e impresi贸n de resultado

Fin del ciclo do-while

|

CORRIDO

40


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

Nombre del proyecto package ecuacion; import javax.swing.JOptionPane; Librería public class Ecuacion { public static void main(String[] args) { Inicio del String dato2; Declaración programa int op ; de variables do Proceso de { repetición JOptionPane.showMessageDialog Impresión de un (null,"ECUACION DE SEGUNDO GRADO" ); mensaje double a = Double.parseDouble (JOptionPane.showInputDialog ("Ingrese el primer valor de a: ")); double b = Double.parseDouble (JOptionPane.showInputDialog Ingresamos los tres ("Ingrese el segundo valor de b: ")); valores double c = Double.parseDouble

|

DOCUMENTACIÓN

41


(JOptionPane.showInputDialog ("Ingrese el tercer valor de c: ")); double interno=b*b-(4*a*c); if (interno==0){ double x1=-b/(2*a); JOptionPane.showMessageDialog (null, "Existe un valor doble: " + x1 ) ; } else if(interno>0) { interno = Math.sqrt(interno); x1=(-b+interno)/(2*a); x2=(-b-interno)/(2*a); JOptionPane.showMessageDialog (null, "valor de x1 y x2: " + x1 +" \n"+x2 ); x1=-b/(2*a); double resultado= Math.sqrt((-interno/(2*a))); JOptionPane.showMessageDialog (null, "La raiz es imaginaria y vale: " + x1 +" +"+ resultado + "i"+x1+"-"+resultado +"i" ); dato2= JOptionPane.showInputDialog ("Ingrese 1 para continuar y 0 pasa salir"); op= Integer.parseInt(dato2); } while(op==1); } } }

Realizamos el proceso para sacar la ecuaci贸n

Este es el proceso para sacar la ra铆z cuadrada de la ecuaci贸n

Visualizamos el resultado

Proceso para que el usuario realice otro proceso o si desea salir

|

CORRIDO

42


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.

43


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;

Importación de librerías del programa

importjava.text.DecimalFormat; importjavax.swing.JOptionPane; public static void main (String[] args)

Paquetes del programa

{ 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

Declaración de variables String y double Instrucción formato para decimales

Inicio ciclo do while principal {

JOptionPane.showMessageDialog (null," << PLANILLA DE LUZ >> "); dato1=JOptionPane.showInputDialog (" INGRESE EL VALOR ANTERIOR: "); valor1=Integer.parseInt (dato1); do

Impresión de titulo Escaneo del primer valor

Inicio del ciclo do while {

dato2=JOptionPane.showInputDialog ("<< INGRESE EL VALOR ACTUAL: "); valor2=Integer.parseInt (dato2);

Escaneo del segundo valor

While (valor1>valor2);

Validación del valor 1 y valor 2

|

}

44


Dif =valor2-valor1; Cost=dif*0.89; Bomb= (cost*3)/100; Procesos para operaciones 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:

Impresión de resultados

"

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

Escaneo de opción para repetición del proceso

} While (op==1); }

Fin ciclo do while validado a 1

Fin del programa

|

}

45


|

CORRIDO

46


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

47


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; import javax.swing.JOptionPane; public class Comision { public static void main(String[] args) {

Paquetes del programa

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;

Declaración de variables String, int y double

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

Transformación de variables String a int

switch(menu) Incio del Switch con { Case1 case 1: do { ventj=JOptionPane.showInputDialog("EMPRESA DON LUCHO" + "\n \n VENDEDOR JUAN" + "\n \n Valor de la venta"); vjuan=Integer.parseInt(ventj); Procesos para numj=numj+1; operaciones totventj=totventj+vjuan; if(vjuan>=8000 && vjuan<=11000) { Decisión if y procesos comj=vjuan*0.03; comjuan=comjuan+comj;

|

menu=Integer.parseInt(opcion);

Impresión del Menú de Opciones

48


|

c JOptionPane.showMessageDialog(null, "EMPRESA DON LUCHO" + "\n \n VENDEDOR JUAN" + "\n \n # VENTA: " + numj + "\n \n Venta=" + vjuan + "\n Comisión= " + comj); } Decisión if y procesos else respectivos para { obtener sus distintos if(vjuan>11000 && vjuan<=25000) resultados { comj=vjuan*0.45; comjuan=comjuan+comj; JOptionPane.showMessageDialog(null, "EMPRESA DON LUCHO" + "\n \n VENDEDOR JUAN" + "\n \n # VENTA: " + numj + "\n \n Venta=" + vjuan + "\n Comisión= " + comj); } Decisión if y procesos else respectivos para { obtener sus distintos if(vjuan>25000 && vjuan<=45000) resultados { comj=vjuan*0.06; comjuan=comjuan+comj; JOptionPane.showMessageDialog(null, "EMPRESA DON LUCHO" + "\n \n VENDEDOR JUAN" + "\n \n # VENTA: " + numj + "\n \n Venta=" + vjuan + "\n Comisión= " + comj); } else Decisión if y procesos { respectivos para if(vjuan>45000) obtener sus distintos { resultados comj=vjuan*0.85; comjuan=comjuan+comj; JOptionPane.showMessageDialog(null, "EMPRESA DON LUCHO" + "\n \n VENDEDOR JUAN" + "\n \n # VENTA: " + numj + "\n \n Venta=" + vjuan + "\n Comisión= " + comj); } } } Cierre de sentencias if } opj=JOptionPane.showInputDialog ("Desea realizar una nueva venta con nuestro vendedor Juan Proceso de repetición, (1 SI/0 NO)"); mensaje y cierre del op=Integer.parseInt(opj); do while } while(op==1);

49


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: Case 2 y Do While do { Impresión del ventmarc=JOptionPane.showInputDialog("EMPRESA DON LUCHO" nombre y datos + "\n \n VENDEDOR MARCELO" + "\n \n Valor de la venta");

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

Decisión if y procesos respectivos para obtener sus distintos resultados Impresión del nombre y datos subtitulos Decisión if y procesos respectivos para obtener sus distintos resultados

Impresión del nombre y datos subtitulos

}

Decisión if y procesos respectivos para obtener sus distintos resultados

Impresión del nombre y datos subtitulos Decisión if y procesos respectivos para obtener sus distintos resultados

|

else { if(vmarc>25000 && vmarc<=45000) { commarc=vmarc*0.06; commarcelo=commarcelo+commarc; JOptionPane.showMessageDialog(null, "EMPRESA DON LUCHO" + "\n \n VENDEDOR MARCELO" + "\n \n # VENTA: " + nummarc + "\n \n Venta=" + vmarc + "\n Comisión= " + commarc); } else { if(vmarc>45000)

50


{ commarc=vmarc*0.85; 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); } } Cierre de sentencias if } } opj=JOptionPane.showInputDialog("Desea realizar una nueva venta con nuestro vendedor Marcelo (1 SI/0 NO)"); op=Integer.parseInt(opj); } while(op==1); JOptionPane.showMessageDialog(null,"EMPRESA DON LUCHO" + "\n \n VENDEDOR MARCELO" + "\n \n # VENTAS: " + nummarc + "\n \n Total de ventas=" + totventm + "\n Comisiones ganadas= " + commarcelo); break; case 3: do Case 3 y Do While { ventmar=JOptionPane.showInputDialog("EMPRESA DON LUCHO" + "\n \n VENDEDORA MARÍA" + "\n \n Valor de la venta");

Impresión del nombre y datos subtitulos

Proceso de repetición, mensaje y cierre del do while

Impresión del nombre y datos subtitulos

Impresión del nombre y datos subtitulos

|

vmar=Integer.parseInt(ventmar); nummar=nummar+1; Decisión if y procesos totventma=totventma+vmar; respectivos para if(vmar>=8000 && vmar<=11000) obtener sus distintos { resultados commar=vmar*0.03; commaria=commaria+commar; Impresión del JOptionPane.showMessageDialog(null, "EMPRESA DON LUCHO" nombre y datos + "\n \n VENDEDORA MARÍA" + "\n \n # VENTA: " + nummar + subtitulos "\n \n Venta=" + vmar + "\n Comisión= " + commar); } else Decisión if y procesos { respectivos para if(vmar>11000 && vmar<=25000) obtener sus distintos { resultados commar=vmar*0.45; commaria=commaria+commar;

51


Impresión del

JOptionPane.showMessageDialog(null, "EMPRESA DON LUCHO" nombre y datos + "\n \n VENDEDOR MARÍA" + "\n \n # VENTA: " + nummar + subtitulos "\n \n Venta=" + vmar + "\n Comisión= " + commar); } else { Decisión if y procesos if(vmar>25000 && vmar<=45000) respectivos para { obtener sus distintos commar=vmar*0.06; resultados commaria=commaria+commar;

CJOptionPane.showMessageDialog(null, "EMPRESA DON LUCHO" + "\n \n VENDEDOR MARÍA" + "\n \n # VENTA: " + nummar + "\n \n Venta=" + vmar + "\n Comisión= " + commar); } } Cierre de sentencias if } } opj=JOptionPane.showInputDialog("Desea realizar una nueva venta con nuestro vendedor María (1 SI/0 NO)"); op=Integer.parseInt(opj); } while(op==1); JOptionPane.showMessageDialog(null,"EMPRESA DON LUCHO" + "\n \n VENDEDOR MARÍA" + "\n \n # VENTAS: " + nummar + "\n \n Total de ventas=" + totventma + "\n Comisiones ganadas= " + commaria); break; case 4: Case 4 System.exit(0); Opción Salir break; } rept=JOptionPane.showInputDialog("Desea realizar una

Impresión del nombre y datos subtitulos

Decisión if y procesos respectivos para obtener sus distintos resultados

Impresión del nombre y datos subtitulos

Proceso de repetición, mensaje y cierre del do while

Impresión del nombre y datos subtitulos

|

JOptionPane.showMessageDialog(null, "EMPRESA DON LUCHO" + "\n \n VENDEDOR MARÍA" + "\n \n # VENTA: " + nummar + "\n \n Venta=" + vmar + "\n Comisión= " + commar); } else { if(vmar>45000) { commar=vmar*0.85; commaria=commaria+commar;

52


nueva compra (1 SI/0 NO)"); op=Integer.parseInt(rept); } while(op==1); total=totventj+totventm+totventma;

Repetir el Programa n veces

Suma total de las comisiones de vendedores

JOptionPane.showMessageDialog(null,"EMPRESA DON LUCHO" + "\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 ); }}

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

53


|

CORRIDO

54


|

55


|

56


|

57


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.

presentar para realizar los diferentes procesos.

|

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

58


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

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;

Importación de librerías del programa

Paquetes del programa Inicio del programa

Declaración de variables String, int y double Do-while proceso de repetición

Impresión del Menú de Opciones Transformación de variables String a int Incio del Switch con Case1 (primera opción)

Ingreso de Datos

|

package matriculas; import javax.swing.JOptionPane; import java.text.DecimalFormat; public class Matriculas { public static void main(String[] args) { 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 {

Procesos

59


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;

Impresión de resultados Break cierre de la primera opción (case 1)

Inicio Case2 (segunda opción) Contadores

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;

Ingreso de Datos

Procesos

Impresión de resultados Break cierre de la primera opción (case 2) Inicio Case3 (tercera opción) Contadores

Ingreso de Datos

Procesos

|

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;

60


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 Impresión de resultados Deportes"+f.format(si3)+"Total: $" +f.format(t3 )); break; Break cierre de la case 4: primera opción (case 2) System.exit(0); Case4 (Opción Salir) break; Cierre del switch } repet=JOptionPane.showInputDialog("Desea ingresar otra matricula 1 / 0"); op1=Integer.parseInt(repet); }while(op1==1);

Fin del proceso de repeticion

cont=con1+con2+con3; mt=pt+prt+ft; smt=sm11+sm22+sm33; Procesos Finales 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 $ " Impresión final +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)); }

Fin del Programa

|

}

61


|

CORRIDO

62


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.

Nombre del programa o proyecto package prueba; import java.text.DecimalFormat; librerías import javax.swing.JOptionPane; public class Prueba { Inicio del programa 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; Declaración de variables int a,op; Inicio del do-while

|

DOCUMENTACION

63


|

do{ DecimalFormat df=new DecimalFormat(".00"); Diseño del menú opc=JOptionPane.showInputDialog(" LIQUIDO TOTAL DE EMPLEADOS\n"+"1.Administrativo\n" +"2.-Ejeutivo\n"+"3.-Obrero\n"+"5.-Salir"); Ingreso de la opción op=Integer.parseInt(opc); switch(op) Inicio del switch { case 1: Ingreso del nombre nom=JOptionPane.showInputDialog("Nombre: "); do{ Ingreso de las horas he=Double.parseDouble(JOptionPane.showInputDialog("Horas extras: ")); }while(he>8); extras ph=he*3.50; h=Double.parseDouble(JOptionPane.showInputDialog("Hijos: ")); Ingreso del número de hijos if(h>2) { pi=h*4.50; } else { Proceso pi=h*6.20; } ti=ph+pi; ie=ad*0.115; co=ad*0.025; te=ie+co; Proceso sp=ad+ph+pi; st=sp-ie-co; JOptionPane.showMessageDialog(null," REPORTE GENERAL\n"+nom+"\nAdministrativo"+"\nSueldo " +ad+"\n\nIngresos "+ti+"\nHoras extras " Impresión de resultados +ph+"\nCargas familiares "+pi+"\n\nEgresos "+te+"\nIESS "+ie+ "\nComisiariato "+co+"\nSueldo a recibir "+st); break; Cierre del case case 2: nom=JOptionPane.showInputDialog("Nombre: "); Ingreso del nombre do{ Ingreso de las horas he=Double.parseDouble(JOptionPane.showInputDialog("Horas extras: ")); extras }while(he>8); ph=he*3.50; h=Double.parseDouble(JOptionPane.showInputDialog("Hijos: ")); Ingreso del número de hijos if(h>2) { pi=h*4.50; } else { pi=h*6.20; Proceso } ti=ph+pi; ie=ej*0.115;

64


|

co=ej*0.025; te=ie+co; sp=ej+ph+pi; st=sp-ie-co; JOptionPane.showMessageDialog(null," REPORTE GENERAL\n"+nom+"\nEjecutivo"+"\nSueldo " Impresi贸n de resultados +ej+"\n\nIngresos "+ti+"\nHoras extras " +ph+"\nCargas familiares "+pi+"\n\nEgresos "+te+"\nIESS "+ie+ "\nComisiariato "+co+"\nSueldo a recibir "+st); break; Cierre del case 2 case 3: Ingreso del nombre nom=JOptionPane.showInputDialog("Nombre: "); do{ Ingreso de las horas he=Double.parseDouble(JOptionPane.showInputDialog("Horas extras: ")); extras }while(he>8); ph=he*3.50; h=Double.parseDouble(JOptionPane.showInputDialog("Hijos: ")); Ingreso del n煤mero de hijos if(h>2) { pi=h*4.50; } else Proceso { pi=h*6.20; } ti=ph+pi; ie=ob*0.115; co=ob*0.025; Proceso te=ie+co; sp=ob+ph+pi; st=sp-ie-co; JOptionPane.showMessageDialog(null," REPORTE GENERAL\n"+nom+"\nObrero"+"\nSueldo " Impresi贸n de resultados +ob+"\n\nIngresos "+ti+"\nHoras extras " +ph+"\nCargas familiares "+pi+"\n\nEgresos "+te+"\nIESS "+ie+ "\nComisiariato "+co+"\nSueldo a recibir "+st); break; Cierre del case 3 case 4: System.exit(0); Proceso par salir break; Cierre del case 4 } opc1=JOptionPane.showInputDialog("Salir 1/0: "); Ingreso para la opci贸n do-while op1=Integer.parseInt(opc1); }while(op1==1); Cierre del while } }

65


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

66


DOCUMENTACION

package seisop; import javax.swing.JOptionPane; import seisop.funcionesop; public class Seisop { public static void main(String[] args) {

Importación de librerías del programa y paquete

Paquetes del programa

|

String dato1,dato2,op,opa; Declaración de int a,b,op1,sum1,res1,mult1,opb; variables double div1,pot1,rad1; do{ op=JOptionPane.showInputDialog("ESCOJA UNA OPCION \n1.-SUMA\n2.-RESTA\n3.-MULTIPLICACION\n"+ Menú de Opciones "4.-DIVISION\n5. -POTENCIACION \n6.-RADICACION\n7.-SALIR"); op1=Integer.parseInt(op); switch(op1) { case 1: dato1=JOptionPane.showInputDialog("Dato 1 :"); Ingreso de datos a=Integer.parseInt(dato1); dato2=JOptionPane.showInputDialog("Dato 2 :"); b=Integer.parseInt(dato2); sum1=funcionesop.suma1(a, b); Llamamos a la clase JOptionPane.showMessageDialog(null,"La suma es: "+sum1); break; Impresión del mensaje case 2: Do-while para el control do { en la resta dato1=JOptionPane.showInputDialog("Dato 1 :"); a=Integer.parseInt(dato1); dato2=JOptionPane.showInputDialog("Dato 2 :"); Ingreso de datos b=Integer.parseInt(dato2); }while(a<b); res1=funcionesop.resta(a, b); JOptionPane.showMessageDialog(null,"La resta es:"+res1); Llamamos a la clase break; Impresión del mensaje case 3: dato1=JOptionPane.showInputDialog("Dato 1 :"); a=Integer.parseInt(dato1); Ingreso de datos dato2=JOptionPane.showInputDialog("Dato 2 :"); b=Integer.parseInt(dato2); mult1=funcionesop.multiplicacion(a, b); Llamamos a la clase JOptionPane.showMessageDialog(null,"La multiplicacion es:"+mult1); break; Impresión del mensaje case 4: do Control para el proceso de la división { dato1=JOptionPane.showInputDialog("Dato 1 :"); Ingreso de datos

67


|

a=Integer.parseInt(dato1); dato2=JOptionPane.showInputDialog("Dato 2 :"); b=Integer.parseInt(dato2); Llamamos a la clase }while(a<b); div1=funcionesop.division(a, b); Impresiรณn del mensaje JOptionPane.showMessageDialog(null,"La division es:"+div1); break; case 5: dato1=JOptionPane.showInputDialog("Base :"); a=Integer.parseInt(dato1); Ingreso de datos dato2=JOptionPane.showInputDialog("Exponente :"); b=Integer.parseInt(dato2); pot1=funcionesop.potencia(a, b); a la clase JOptionPane.showMessageDialog(null,"La potenciaLlamamos es:"+pot1); break; Impresiรณn del mensaje case 6: dato1=JOptionPane.showInputDialog("Numero :"); Ingreso de datos a=Integer.parseInt(dato1); rad1=funcionesop.radicacion(a); Llamamos a la clase JOptionPane.showMessageDialog(null,"La raiz es:"+rad1); break; Impresiรณn del mensaje } opa=JOptionPane.showInputDialog("INGRESE 1 CONTINUAR Mensaje de do-while para Y 0 PARA SALIR:"); enviar un mensaje si desea opb=Integer.parseInt(opa); repetir }while(opb==1); } } package seisop; Nombre del programa principal public class funcionesop { public static int suma1(int a1, int b1) { int sumar; Proceso de suma sumar=(a1+b1); return sumar; } public static int resta(int a1, int b1) { Proceso de resta int restar; restar=(a1-b1); return restar; } public static int multiplicacion(int a1, int b1) { Proceso de multiplicaciรณn int multiplicar; multiplicar=(a1*b1); return multiplicar; } public static double division(double a1, double b1) { Proceso de divisiรณn double dividir; dividir=(a1/b1);

68


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

Proceso de potencia

Proceso de radicaci贸n

|

CORRIDO

69


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

javax.swing.JOptionPane; ) y

importar

la

librería

principal

(import

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

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

|

operaciones a la suma.

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

70


Preguntamos si el usuario desea realizar nuevamente otros procesos o si desea salir DOCUMENTACIÓN

{ escoger=JOptionPane.showInputDialog(null, " OPERACIONES BASICAS \n\n 1. Suma \n 2. Resta \n 3. Multiplicación \n 4. División \n 5. Potenciación \n 6. Radicación \n 7. Salir \n\n Escoja una opcion:"); es=Integer.parseInt(escoger); switch(es) { case 1: do{ dato1=JOptionPane.showInputDialog ("Ingrese el primer valor: "); num1=Integer.parseInt(dato1); dato2=JOptionPane.showInputDialog ("Ingrese el segundo valor: "); num2=Integer.parseInt(dato2); suma=operaciones.sumar(num1, num2); JOptionPane.showMessageDialog (null, "La Suma es: "+ suma); opcion=JOptionPane.showInputDialog ("Desea realizar otra suma: 1=si / 0=no"); op=Integer.parseInt(opcion); }while(op==1); break; case 2 do{ do{

Importación de librerías del programa

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

Ingreso de Datos

Llamado de clase o función

DO WHILE y break

Case 2 y Do While |

package pkg13.operacionesmenu; import javax.swing.JOptionPane; import pkg13.operacionesmenu.operaciones; public class Operacionesmenu { public static void main(String[] args) { String dato1,dato2,escoger,opcion; int num1,num2,suma,resta,multiplicacion,es,op; double division, potenciacion, radicacion;

71


case 3: do{ dato1=JOptionPane.showInputDialog ("Ingrese el primer valor: "); num1=Integer.parseInt(dato1); dato2=JOptionPane.showInputDialog ("Ingrese el segundo valor: "); num2=Integer.parseInt(dato2); multiplicacion=operaciones.multi(num1, num2); JOptionPane.showMessageDialog (null, "La Multiplicación es: "+ multiplicacion); opcion=JOptionPane.showInputDialog ("Desea realizar otra multiplicacion: 1=si / 0=no"); op=Integer.parseInt(opcion); }while(op==1); break; case 4: do{ do{ dato1=JOptionPane.showInputDialog ("Ingrese el primer valor: "); num1=Integer.parseInt(dato1); dato2=JOptionPane.showInputDialog ("Ingrese el segundo valor: "); num2=Integer.parseInt(dato2); }while(num1<num2); division=operaciones.dividir(num1, num2); JOptionPane.showMessageDialog

Ingreso de Datos

Validación 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

Validación de datos |

dato1=JOptionPane.showInputDialog ("Ingrese el primer valor: "); num1=Integer.parseInt(dato1); dato2=JOptionPane.showInputDialog ("Ingrese el segundo valor: "); num2=Integer.parseInt(dato2); }while(num1<num2); resta=operaciones.restar(num1, num2); JOptionPane.showMessageDialog (null, "La Resta es: "+ resta); opcion=JOptionPane.showInputDialog ("Desea realizar otra resta: 1=si / 0=no"); op=Integer.parseInt(opcion); }while(op==1); break;

Llamado de clase o función

72


case 5: do{ dato1=JOptionPane.showInputDialog ("Ingrese la base: "); num1=Integer.parseInt(dato1); dato2=JOptionPane.showInputDialog ("Ingrese el exponente: "); num2=Integer.parseInt(dato2); potenciacion=operaciones.potencia(num1, num2); JOptionPane.showMessageDialog (null, "La Potenciación es: "+ potenciacion); opcion=JOptionPane.showInputDialog ("Desea realizar otra potenciacion 1=si / 0=no"); op=Integer.parseInt(opcion); }while(op==1); break; case 6: do{ dato1=JOptionPane.showInputDialog("Ingrese el valor: "); num1=Integer.parseInt(dato1); radicacion=operaciones.raiz(num1); JOptionPane.showMessageDialog (null, "La Radicacion es: "+ radicacion); opcion=JOptionPane.showInputDialog ("Desea realizar otra radicación 1=si / 0=no"); op=Integer.parseInt(opcion); }while(op==1); break; case 7: System.exit(0); break; } opcion=JOptionPane.showInputDialog ("Desea volver al menu: 1=si / 0=no"); op=Integer.parseInt(opcion);

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 |

(null, "La División es: "+ division); opcion=JOptionPane.showInputDialog ("Desea realizar otra division 1=si / 0=no"); op=Integer.parseInt(opcion); }while(op==1); break;

73


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

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

|

public static double potencia(double a, double b) { double potencia; potencia=Math.pow(a, b); return potencia; }

Fin del Programa

public static double raiz(double a)

74


{ double raiz; raiz=Math.sqrt(a); return raiz;

Proceso de radicación

} }

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

|

Importación de librerías package menuseries; import javax.swing.JOptionPane; del programa import menuseries.series; public class Menuseries { public static void main(String[] args) Declaración de { variables String, int y String dato1, dato2,dato3; double int op,limite,pares,num,i,p,primos,factor,fibo,opc; JOptionPane.showMessageDialog(null, "MENU DE SERIES "); do Impresión del Menú de {dato1=JOptionPane.showInputDialog("1. PRIMOS \n 2. FACTORIAL Opciones \n 3. FIBONACCI \n 4. PARES \n 5. SALIR \n Ingrese una opcion: "); op=Integer.parseInt(dato1); switch(op) Inicio del Switch con { Case1 case 1: Ingreso del límite y dato2=JOptionPane.showInputDialog("Ingrese un limite"); Llamado de clase o limite=Integer.parseInt(dato2); función primos=series.primos(limite); Inicio del Switch con Case 2

75


break; case 2: dato2=JOptionPane.showInputDialog("Ingrese un limite"); limite=Integer.parseInt(dato2); factor=series.facto(limite); Inicio del Switch con break; Case 3 case 3: dato2=JOptionPane.showInputDialog("Ingrese un limite"); limite=Integer.parseInt(dato2); fibo=series.fibo(limite); Inicio del Switch con Case 4 break; case 4: dato2=JOptionPane.showInputDialog("Ingrese un limite"); limite=Integer.parseInt(dato2); pares=series.par(limite); break; Fin del Switch con Case 5 case 5: System.exit(0); break; } dato3=JOptionPane.showInputDialog("Volver al menu 1 Salir 0: "); opc=Integer.parseInt(dato3); } while(opc==1); }

Ingreso del límite y Llamado de clase o función Ingreso del límite y Llamado de clase o función

Ingreso del límite y Llamado de clase o función

Repetir el Programa n veces

Fin del Programa

} Nombre del Programa principal

Serie de numeros pares

Serie de numeros primos

|

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

76


Serie de numeros primos

Serie de la factorial

Serie del Fibonacci

|

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

77


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

javax.swing.JOptionPane;

e

principales

que

utilizaremos

importjava.text.DecimalFormat;).

(import 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.

78


CODIFICACION

|

Importación de librerías del programa package edades; import javax.swing.JOptionPane; public class Edades { Paquetes del programa public static void main(String[] args) { String opcion,dato; Declaración de variables String y double int edad1,op,edades; do Inicio ciclo do while principal { 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); LLAMA A LAS FUNCIONES edades=edad.edades(edad1); dato=JOptionPane.showInputDialog(null,"DESEA REPETIR 1 O 0 PARA SALIR: "); op=Integer.parseInt(dato); SE CIERRA EL LAZO REPETITIVO }while(op==1); } } package edades; Importación de librerías del programa import javax.swing.JOptionPane; public class edad { public static int edades(int edad1) { if(edad1>=1 && edad1<=3) { JOptionPane.showMessageDialog(null, "BEBE: "+edad1); } else { if(edad1>=4 && edad1<=11) { JOptionPane.showMessageDialog(null, "NIÑO: "+edad1); } else { if(edad1>=12 && edad1<=17) { JOptionPane.showMessageDialog(null, "ADOLESCENTE: "+edad1); } PROCESO else

79


{ if(edad1>=18 && edad1<=45) { JOptionPane.showMessageDialog(null, "ADULTO: "+edad1); } else { if(edad1>45) { JOptionPane.showMessageDialog(null, "ADULTO MAYOR: "+edad1); } } } } } return 0; SE CIERRA LA CLASE } }

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

80


ANÁLISIS Necesitaremos una variable tipo int para generar la descomposición en sus unidades Documentación

}

|

package decompocicion; Importación de librerías import javax.swing.JOptionPane; del programa import decompocicion.descomponer; public class Decompocicion { Paquetes del programa public static void main(String[] args) { String num; int a,res; do{ Declaración de variables tipo int y string num=JOptionPane.showInputDialog("NUMERO"); a=Integer.parseInt(num); }while(a<1 || a>9999); res=descomponer.descomponer(a); } Fin del programa principal } Clase package decompocicion; Programa principal importación de librerías e inicio de clases import javax.swing.JOptionPane; public class descomponer { public static int descomponer(int a) { int um,c,d,u; um=a; um=(um/1000)*1000; c=a; Clase descomposición c=c-um; con su respectivo c=(c/100)*100; proceso para realizar d=a; una descomposición en d=d-um-c; sus unidades 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; }

81


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

Importación de librerías del programa

Declaración de variables String, int y double

JOptionPane.showMessageDialog(null, "CONVERSIONES "); do {

|

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;

Impresión del Menú de Opciones

82


dato=JOptionPane.showInputDialog("1. BINARIO \n 2. OCTAL \n 3. HEXADECIMAL \n 4. SALIR \n Ingrese una Opcion: "); opc=Integer.parseInt(dato); Inicio del Switch con switch(opc) Ingreso el número que { Case1 deseo transformar a case 1: binario y llamamos a la dato1=JOptionPane.showInputDialog("Ingrese un numero: "); a=Integer.parseInt(dato1); clase bi=convers.bi(a); break; Ingreso el número que case 2: deseo transformar a dato1=JOptionPane.showInputDialog("Ingrese un numero: "); octal y llamamos a la a=Integer.parseInt(dato1); oc=convers.oct(a); clase Inicio del Switch break; con Case 3 case 3: dato1=JOptionPane.showInputDialog("Ingrese un numero: "); a=Integer.parseInt(dato1); Ingreso el número que deseo transformar a hexa=convers.he(a); hexadecimal y llamamos a la clase break; case 4: System.exit(0); Fin del Switch con Case 4 break; } Repetir el Programa dato2= JOptionPane.showInputDialog("VOLVER AL MENU 1 SALIR 0: "); n veces op=Integer.parseInt(dato2); } while(op==1); } Fin del Programa }

|

package conversiones; Nombre del Programa import javax.swing.JOptionPane; principal public class convers { public static int bi (int a) { Transformación de un JOptionPane.showMessageDialog(null, "Numero Binario: número decimal a binario "+Integer.toBinaryString(a)); return 0; } public static int oct (int a) { JOptionPane.showMessageDialog(null, "Numero Octal: Transformación de un "+Integer.toOctalString(a)); número decimal a octal return 0; } public static int he(int a) { Transformación de un JOptionPane.showMessageDialog(null, "Numero Hexadecimal: número decimal a "+Integer.toHexString(a)); hexadecimal return 0; }

83


}

|

CORRIDO

84

programacion en java  

ayuda para programar en java

Advertisement