programacion en java by Jhos Suarez

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.

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

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.

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

double

else

extends

false

final

finally

float

for

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.

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

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.

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

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

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

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,

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

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.

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.

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

continúa

siendo

patrocinador

principal

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.

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:

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.

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.

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

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

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

clase

holamundo.

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]

}

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

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.

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

imprimimos

respuesta

con

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

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;

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

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

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

perímetro

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;

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;

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

} }

CORRIDO

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

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

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

while(num2==1); }

Cierra completamente el programa. }

CORRIDO

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;

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

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:

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

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

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

librería

principal

que

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

(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

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

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.

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

}

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

}

CORRIDO

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

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

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

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

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