Apuntes ejercicios programacion i

Ejercicios de la materia de Programación I F.FCCA

M. A. Bruno Ramos Ortiz 1

PARADIGMAS DE LA PROGRAMACIÓN

BASES DE LA POO



CONCEPTOS BÁSICOS DE LA POO



CARACTERÍSTICAS DE LA POO

HISTORIA DE JAVA El lenguaje Java así como la máquina virtual, comenzaron como un proyecto interno de Sun Microsystems en 1990. Los ingenieros de Sun no estaban satisfechos con el rendimiento del lenguaje C++, por lo que James Gosling, Mike Sheridan y Patrick Naughton, junto con otros más, comenzaron a desarrollar un nuevo lenguaje, que en principio pensaron dedicar a la programación de todo tipo de aparatos, tales como microondas, neveras, teléfonos móviles, etc.. Ellos pensaban que éstos generarían muchas e importantes aplicaciones para la tecnología del futuro.

El lenguaje tendría que obviar problemas que presenta C++, en campos tales como la programación distribuída, las aplicaciones multihilo, el manejo de la memoria y ser más sencillo de manejar que C++. Finalmente se deseaba que los programas fueran portables a todo tipo de aparatos.

Inicialmente el lenguaje se llamó Oak (en español 'roble'), en honor de un roble que había frente a la oficina. En 1992, se presentó como demostración una PDA con interface gráfica y un asistente inteligente representado mediante un muñeco llamado Duke.

Oak fue presentado a concurso, como solución tecnológica, en varios proyectos para la industria del cine y la televisión, pero no fue elegido. En 1994 John Gage, James Gosling, Bill Joy, Patrick Naughton, Wayne Rosing, y Eric Schmidt se se reunieron para reorientar Oak. Decidieron orientarlo hacia la tecnología de la Web, pues se pensaba que tras la aparición del navegador Mosaic, ésta evolucionaría hacia la misma clase de interactividad, que la televisión por cable, para la cual habían estado preparando Oak.



Fue asimismo en 1994 cuando se cambió el nombre de Oak a Java. Poco después, aún en 1994, la plataforma Java 1.0, estaba disponible para descarga en la Web.

En 1995 Netscape anunció que incluiría soporte para Java en sus navegadores, dando con esto un buen apoyo a Java.

CARACTERÍSTICAS DE JAVA

JDK

JDK es el acrónimo de "Java Development Kit", es decir Kit de desarrollo de Java. Se puede definir como un conjunto de herramientas, utilidades, documentación y ejemplos para desarrollar aplicaciones Java. Para la realización de este tutorial se ha trabajado con la versión 1.2.0 del JDK. Componentes del JDK

a.) Introducción

JDK consta de una serie de aplicaciones y componentes, para realizar cada una de las tareas de las que es capaz de encargarse A continuación se explican más en profundidad cada uno de ellos, así como su sintaxis, indicando entre corchetes aquellos elementos que sean opcionales. Se observará que todos los programas permiten la inclusión de una serie de opciones sobre su ejecución antes del primer argumento. Estas opciones se indican precedidas de un menos(-):



programa -opcion1 -opcion2 Parametro1 Todas las opciones que los ejecutables del JDK presentan se muestran llamando al programa sin parámetros o con las opciones -? o -help: programa programa -help programa -?

b.) Intérprete en tiempo de ejecución (JRE)

Permite la ejecución de los programas Java (*.class) no gráficos (aplicaciones). La sintaxis para su utilización es la siguiente: java [Opciones] ClaseAEjecutar [Argumentos]

· Opciones: Especifica opciones relacionadas con la forma en que el intérprete Java ejecuta el programa.

· ClaseAEjecutar: Especifica el nombre de la clase cuyo método main() se desea ejecutar como programa. Si la clase reside en un paquete se deberá especificar su ruta mediante en forma paquete.subpaquete.clase_a_ejecutar.

· Argumentos: Especifica los argumentos que se recibirán en el parámetro s del método main(String s), por si el programa necesita de parámetros de ejecución. Si por ejemplo el programa realiza el filtrado de un archivo, probablemente nos interese recibir como argumento la ruta del fichero a filtrar, y una ruta destino.

c). Compilador

Se utiliza para compilar archivos de código fuente Java (habitualmente *.java), en archivos de clases Java ejecutables (*.class). Se crea un archivo de clase para cada clase definida en un archivo fuente. Este compilador es una utilidad en línea de comandos con la siguiente sintaxis: javac [Opciones] ArchivoACompilar

· Opciones: Especifica opciones de cómo el compilador ha de crear las clases ejecutables.

· ArchivoACompilar: Especifica la ruta del archivo fuente a compilar, normalmente una fichero con extensión ".java".

d.) Visualizador de applets

Es una herramienta que sirve como campo de pruebas de applets, visualizando cómo se mostrarían en un navegador, en lugar de tener que esperar. Al ser activado desde una línea de órdenes abre una ventana en la que muestra el contenido de la applet. Se activa con la sintaxis: appletviewer [Opciones] Applet

· Opciones: Especifica cómo ejecutar la applet Java. · Applet: Indica un URL o una ruta de disco que contiene una página HTML con una

applet Java empotrada.



e.) Depurador

Es una utilidad de línea de comandos que permite depurar aplicaciones Java. No es un entorno de características visuales, pero permite encontrar y eliminar los errores de los programas Java con mucha exactitud. Es parecido en su funcionamiento al depurador gdb que se incluye con las distribuciones del compilador gcc/g++ para C/C++. Se activa con la sintaxis: jdb [Opciones]

· Opciones: Se utiliza para especificar ajustes diferentes dentro de una sesión de depuración.

f.) Desensamblador de archivo de clase

Se utiliza para desensamblar un archivo de clase. Su salida por defecto, muestra los atributos y métodos públicos de la clase desensamblada, pero con la opción -c también desensambla los códigos de byte, mostrándolos por pantalla. Es útil cuando no se tiene el código fuente de una clase de la que se quisiera saber cómo fue codificada. La sintaxis es la siguiente: javap [Opciones] [NombresClases]

· Opciones: Especifica la forma en la que se han de desensamblar las clases. · NombresClase: Especifica la ruta de las clases a desensamblar, separadas por

espacios.

g.) Generador de cabecera y archivo de apéndice

Se utiliza para generar archivos fuentes y cabeceras C para implementar métodos Java en C (código nativo). Esto se consigue mediante la generación de una estructura C cuya distribución coincide con la de la correspondiente clase Java. El generador de cabeceras javah, crea los ficheros de cabecera C/C++ para implementar en esos lenguajes los métodos nativos que presente un programa Java. La sintaxis es la siguiente: javah [Opciones] NombreClase

· NombreClase: Nombre de la clase desde la cuál se van a generar archivos fuente C. · Opciones: Forma en la que se generarán los archivos fuente

h.) Generador de documentación

Es una herramienta útil para la generación de documentación API directamente desde el código fuente Java. Genera páginas HTML basadas en las declaraciones y comentarios javadoc, con el formato /** comentarios */: /** Comentarios sobre la clase */ class MiClase { } La documentación que genera es del mismo estilo que la documentación que se obtiene con el JDK.



Las etiquetas, que se indican con una arroba (@), aparecerán resaltadas en la documentación generada. Su sintaxis es: javadoc Opciones NombreArchivo

· Opciones: Opciones sobre qué documentación ha de ser generada. · NombreArchivo: Paquete o archivo de código fuente Java, del que generar

documentación.

i.) Applets de demostración

El JDK incluye una serie de applets de demostración, con su código fuente al completo. j.) Código fuente la API

El código fuente de la API se instala de forma automática, cuando se descomprime el JDK, aunque permanece en formato comprimido en un archivo llamado "scr.zip" localizado en el directorio Java que se creó durante la instalación.

COMPONENTES DE UNA APLICACIÓN EN JAVA

En un programa de Java, destacan los siguientes elementos:

1. Comentarios: sirven para documentar los programas, en ellos se escriben anotaciones sobre cómo funciona el programa o sobre cómo se ha construido. Los comentarios no son sentencias de programación y son por consiguiente ignorados por el compilador.

Ejemplos:

// este es un comentario de una sola línea

/* estos son comentarios de

Varias líneas */

2. Palabras reservadas: son palabras que tienen un determinado significado para el compilador y no pueden ser utilizadas por otros fines.

Ejemplos:

abstract

boolean

byte

case

catch

char

class

default

do

else

final

float

for

if

import

int

null

package

public

true



3. Sentencias: representa una acción o una secuencia de acciones. Cada sentencia termina con un punto y coma (;)

Ejemplos:

Z = 15; //sentencia que asigna un valor a una variable

println(“Bienvenido a Java”); //sentencia que imprime un texto a pantalla

4. Bloques: son una estructura que agrupa sentencias. Los bloques comienzan con una llave de apertura ({) y termina con una llave de cierre (}). Un bloque puede estar dentro de otro bloque y se dice que el bloque interior está anidado dentro del exterior. Los bloques también limitan el alcance tanto de las clases como de los métodos.

Ejemplo:

{ x=10; x=x+100; if (x > 225) { x=x-5; } println(“El valor de x es:”+x); } 5. Clases: constituyen una plantilla o modelo para fabricar objetos. Un programa consta

de una o más clases y cada una de ellas contiene declaraciones de datos y métodos. Ejemplo: public class Imprimir

{ String texto=”Bienvenidos”; public void Imprime()

{ System.out.println(“La frase a imprimir es:” +texto); } }

6. Métodos: son una colección de sentencias que realizan una serie de operaciones determinadas.

Ejemplo:

JOptionPane.showMessageDialog(null, “Ejemplo de un método”);

//método que manda un mensaje a través de la interfaz gráfica

Método main( ): cada aplicación en Java debe tener un método principal, el cual define dónde comienza el flujo del programa.



Sintaxis: Public static void main (String [ ] args) { //sentencias; } 7. Paquetes: son una colección de clases que proporcionan un medio adecuado para

organizar las clases. La clase puede pertenecer a un paquete o importar un paquete para acceder a las clases que lo integran.

Ejemplo:

· Para pertenecer a un paquete se utiliza la siguiente sintaxis: package nombrepaquete;

· Para importar un paquete se emplea la siguiente sintaxis: import nombrepaquete;

ETAPAS PARA CREAR UN PROGRAMA EN JAVA

1. Crear una carpeta de proyecto; en la que se almacenan todas las clases y archivos significativos.

2. Utilizar un programa editor que introduzca cada línea del programa fuente en memoria y lo guarde en la carpeta proyecto como un archivo con extensión .java

3. utilizar el programa compilador para traducir el programa fuente en bytecode (código en bytes). Si existen errores de sintaxis (error gramatical de una línea en un programa Java), el compilador visualiza esos errores en una ventana.

4. utilizar el programa editor para corregir esos errores, modificando y volviendo a guardar el programa fuente. Cuando el programa fuente está libre de errores, el compilador guarda su traducción en bytecode como un archivo con extensión .class

5. El intérprete de Java (JVM) traduce y ejecuta cada instrucción en bytecode.

6. si el código no funciona correctamente se puede utilizar el depurador para ejecutar el programa paso a paso y examinar el efecto de las instrucciones individuales.

ERRORES DE PROGRAMACIÓN

Los errores de programación son inevitables, incluso para programadores experimentados. El proceso de corregir un error se denomina depuración del programa. Cuando se detecta un error en Java, se visualiza un mensaje de error que devuelve la posible causa del error. Tipos de errores:



Ø Errores de sintaxis; ocurren cuando el código viola una ó más reglas gramaticales de Java. Los errores de sintaxis se detectan y visualizan por el compilador cuando se intenta traducir el programa, por esta razón se denominan errores de compilación. Éstos errores provienen de errores en la construcción del código tales como escribir mal una palabra reservada, omitir algún signo de puntuación o bien utilizar una llave de apertura sin su correspondiente llave de cierre. Son fáciles de detectar ya que el compilador suele indicar dónde se producen las posibles causas.

Ø Errores de ejecución; son errores que producen una terminación anormal y que se detectan y visualizan durante la ejecución del programa. Un error de ejecución se produce cuando el usuario instruye a la computadora para que ejecute una operación no valida, tal como dividir un número por cero o manipular datos indefinidos o no válidos en la entrada. Un error de entrada ocurre cuando el usuario introduce un valor imprevisto que el programa no puede manejar. Por ejemplo si el programa espera leer un número, pero el usuario introduce una cadena de caracteres.

Ø Errores lógicos; ocurren cuando un programa realiza un algoritmo incorrecto y no ejecuta la operación que estaba prevista. Existen muchos tipos de razones para que se produzcan errores lógicos. Son difíciles de detectar, ya que no producen errores en tiempo de ejecución y no visualizan mensajes de error. El único síntoma de que se ha producido un error lógico puede ser la salida incorrecta del programa. Se pueden detectar errores lógicos comprobando el programa en su totalidad y comparando su salida con los resultados calculados. La prevención de éstos errores se puede realizar verificando el algoritmo y el programa correspondiente antes de comenzar el proceso de ejecución.

VARIABLES

Una variable es un nombre que se asocia con una porción de la memoria del ordenador, en la que se guarda el valor asignado a dicha variable. Hay varios tipos de variables que requieren distintas cantidades de memoria para guardar datos. Todas las variables han de declararse antes de usarlas, la declaración consiste en una sentencia en la que figura el tipo de dato y el nombre que asignamos a la variable. Una vez declarada se le podrá asignar valores. Java tiene tres tipos de variables:

· de instancia · de clase · locales

Las variables de instancia o miembros dato como veremos más adelante, se usan para guardar los atributos de un objeto particular. Las variables de clase o miembros dato estáticos son similares a las variables de instancia, con la excepción de que los valores que guardan son los mismos para todos los objetos de una determinada clase. En el siguiente ejemplo, PI es una variable de clase y radio es una



variable de instancia. PI guarda el mismo valor para todos los objetos de la clase Circulo, pero el radio de cada círculo puede ser diferente class Circulo{ static final double PI=3.1416; double radio; //... } Las variables locales se utilizan dentro de las funciones miembro o métodos. En el siguiente ejemplo area es una variable local a la función calcularArea en la que se guarda el valor del área de un objeto de la clase Circulo. Una variable local existe desde el momento de su definición hasta el final del bloque en el que se encuentra. class Circulo{ //... double calcularArea(){ double area=PI*radio*radio; return area; } } En el lenguaje Java, las variables locales se declaran en el momento en el que son necesarias. Es una buena costumbre inicializar las variables en el momento en el que son declaradas. Veamos algunos ejemplos de declaración de algunas variables int x=0; String nombre="Angel"; double a=3.5, b=0.0, c=-2.4; boolean bNuevo=true; int[] datos; Delante del nombre de cada variable se ha de especificar el tipo de variable que hemos destacado en letra negrita. Las variables pueden ser

· Un tipo de dato primitivo · El nombre de una clase · Un array

El lenguaje Java utiliza el conjunto de caracteres Unicode, que incluye no solamente el conjunto ASCII sino también carateres específicos de la mayoría de los alfabetos. Así, podemos declarar una variable que contenga la letra ñ int año=1999; Se ha de poner nombres significativos a las variables, generalmente formados por varias palabras combinadas, la primera empieza por minúscula, pero las que le siguen llevan la



letra inicial en mayúsculas. Se debe evitar en todos los casos nombres de variables cortos como xx, i, etc. double radioCirculo=3.2; Las variables son uno de los elementos básicos de un programa, y se deben

· Declarar · Inicializar · Usar

TIPOS DE DATOS PRIMITIVOS

Tipo Descripción

boolean Tiene dos valores true o false.

char Caracteres Unicode de 16 bits Los caracteres alfa-numéricos son los mismos que los ASCII con el bit alto puesto a 0. El intervalo de valores va desde 0 hasta 65535 (valores de 16-bits sin signo).

byte Tamaño 8 bits. El intervalo de valores va desde -27 hasta 27 -1 (-128 a 127)

short Tamaño 16 bits. El intervalo de valores va desde -215 hasta 215-1 (-32768 a 32767)

int Tamaño 32 bits. El intervalo de valores va desde -231 hasta 231-1 (-2147483648 a 2147483647)

long Tamaño 64 bits. El intervalo de valores va desde -263 hasta 263-1 (-9223372036854775808 a 9223372036854775807)

float Tamaño 32 bits. Números en coma flotante de simple precisión. Estándar IEEE 754-1985 (de 1.40239846e–45f a 3.40282347e+38f)

double Tamaño 64 bits. Números en coma flotante de doble precisión. Estándar IEEE 754-1985. (de 4.94065645841246544e–324d a 1.7976931348623157e+308d.)

CARACTERES En Java los caracteres no están restringidos a los ASCII sino son Unicode. Un carácter está siempre rodeado de comillas simples como 'A', '9', 'ñ', etc. El tipo de dato char sirve para guardar estos caracteres. Un tipo especial de carácter es la secuencia de escape, similares a las del lenguaje C/C++, que se utilizan para representar caracteres de control o caracteres que no se imprimen. Una secuencia de escape está formada por la barra invertida (\) y un carácter. En la siguiente tabla se dan las secuencias de escape más utilizadas.



Carácter Secuencia de escape

retorno de carro

\r

tabulador horizontal

\t

nueva línea \n

barra invertida \\

Variables booleanas En el lenguaje C/C++ el valor 0 se toma como falso y el 1 como verdadero. En el lenguaje Java existe el tipo de dato boolean. Una variable booleana solamente puede guardar uno de los dos posibles valores: true (verdadero) y false (falso). boolean encontrado=false; {...} encontrado=true; Variables enteras Una variable entera consiste en cualquier combinación de cifras precedidos por el signo más (opcional), para los positivos, o el signo menos, para los negativos. Son ejemplos de números enteros: 12, -36, 0, 4687, -3598 Como ejemplos de declaración de variable enteras tenemos: int numero=1205; int x,y; long m=30L; int es la palabra reservada para declarar una variable entera. En el primer caso, el compilador reserva una porción de 32 bits de memoria en el que guarda el número 1205. Se accede a dicha porción de memoria mediante el nombre de la variable, numero. En el segundo caso, las porciones de memoria cuyos nombres son x e y, guardan cualquier valor entero si la variable es local o cero si la variable es de instancia o de clase. El uso de una variable local antes de ser convenientemente inicializada puede conducir a consecuencias desastrosas. Por tanto, declarar e inicializar una variable es una práctica aconsejable. En la tercera línea 30 es un número de tipo int por defecto, le ponemos el sufijo L en mayúsculas o minúsculas para indicar que es de tipo long. Existen como vemos en la tabla varios tipos de números enteros (byte, short, int, long), y también existe una clase denominada BigInteger cuyos objetos pueden guardar un número entero arbitrariamente grande. Variables en coma flotante Las variables del tipo float o double (coma flotante) se usan para guardar números en memoria que tienen parte entera y parte decimal. double PI=3.14159; double g=9.7805, c=2.9979e8;



El primero es una aproximación del número real p, el segundo es la aceleración de la gravedad a nivel del mar, el tercero es la velocidad de la luz en m/s, que es la forma de escribir 2.9979 108. El carácter punto '.', separa la parte entera de la parte decimal, en vez del carácter coma ',' que usamos habitualmente en nuestro idioma. Otras ejemplos son los siguientes float a=12.5f; float b=7f; double c=7.0; double d=7d; En la primera línea 12.5 lleva el sufijo f, ya que por defecto 12.5 es double. En la segunda línea 7 es un entero y por tanto 7f es un número de tipo float. Y así el resto de los ejemplos. Conceptualmente, hay infinitos números de valores entre dos números reales. Ya que los valores de las variables se guardan en un número prefijado de bits, algunos valores no se pueden representar de forma precisa en memoria. Por tanto, los valores de las variables en coma flotante en un ordenador solamente se aproximan a los verdaderos números reales en matemáticas. La aproximación es tanto mejor, cuanto mayor sea el tamaño de la memoria que reservamos para guardarlo. De este hecho, surgen las variables del tipo float y double. Para números de precisión arbitararia se emplea la clase BigDecimal. Valores constantes Cuando se declara una variable de tipo final, se ha de inicializar y cualquier intento de modificarla en el curso de la ejecución del programa da lugar a un error en tiempo de compilación. Normalmente, las constantes de un programa se suelen poner en letras mayúsculas, para distinguirlas de las que no son constantes. He aquí ejemplos de declaración de constantes. final double PI=3.141592653589793; final int MAX_DATOS=150;

SENTENCIA IF

Permite en un programa tomar la decisión sobre la ejecución/no ejecución de una acción o de un grupo de acciones, mediante la evaluación de una expresión lógica o booleana. La acción o grupo de acciones se ejecutan cuando la condición es cierta y en caso contrario no se ejecutan y se saltan. Sintaxis: if (condición) if (condición) sentencia; { //secuencia de sentencias }



SENTENCIA IF-ELSE

Ofrece dos alternativas a seguir, basadas en la comprobación de la condición. La palabra reservada else separa las sentencias utilizadas para ejecutar cada alternativa. Sintaxis: if (condición) if (condición) sentencia1; { else //secuencia de sentencias1 sentencia2; } else { //secuencia de sentencias2 } Si la evaluación de la condición es verdadera, se ejecuta la sentencia1 o la secuencia de

sentencias1, mientras que si la evaluación es falsa se ejecuta la sentencia2 o la secuencia

de sentencias2. Es decir, que las sentencias a realizar tanto cuando se cumple como cuando no se cumple la condición podrán ser simples o compuestas.

SENTENCIAS IF-ELSE ANIDADAS

La construcción if-else-if múltiple, es muy habitual en programación y se suele escribir de la forma siguiente: if (condición1) sentencia1; else if (condición2) sentencia2; else if (condición3) sentencia3; … else if (condiciónN) sentenciaN; else sentenciaX; //opcional

la sentencia anterior realiza una serie de test en cascada hasta que se produce una de las siguientes condiciones:



· Una de las cláusulas especificadas en las sentencias if se cumple; en ese caso la sentencia asociada se ejecuta y no se tiene en cuenta el resto.

· Ninguna de las cláusulas especificadas se cumple y entonces, si existe, se ejecuta la última sentencia else.

SENTENCIA SWITCH

Cuando se tienen muchas alternativas posibles a elegir, el uso de sentencias if-else-if puede resultar bastante complicado, siendo recomendable emplear la sentencia switch. Sintaxis: switch (expresión) { case constante1: sentencias1; //no se requiere cerrarlas entre llaves break; case constante2: sentencias2; break; …. case constanteN sentenciasN; break; default senteciasX; } En la sentencia switch la expresión a evaluar debe ser de tipo entero o carácter. La sentencia break se utiliza con la sentencia switch para abandonar dicha sentencia tras la ejecución de las sentencias asociadas a una determinada cláusula case. El funcionamiento de la sentencia switch es el siguiente:

· Cuando el valor de la expresión coincide con una constante de case, se ejecutan el grupo de sentencias asociadas y si la última sentencia de un grupo es break, tras llegar a ella, el programa sale de la sentencia switch. Si la sentencia break se omite, la ejecución sigue en el siguiente grupo de sentencias.

· La cláusula default es un caso especial de case. Las sentencias que vienen a continuación de ella se ejecutan si ninguna de las constantes que siguen a las diferentes sentencias case coincide con el valor de la expresión de switch.



SENTENCIA FOR

Está diseñado para ejecutar una secuencia de sentencias un número fijo de veces.

Sintaxis:

for (inicialización; condición de terminación; incremento) sentencias; //desde 1 a un bloque delimitado por { }

· Las sentencias podrán ser cero, una única sentencia o un bloque y serán lo que se repita durante el proceso del ciclo.

· La inicialización fija los valores iniciales de la variable o variables de control antes de que el ciclo se procese y ejecute solo una vez. Cuando no se tiene que inicializar, se omite este apartado; sin embargo, nunca se debe omitir el punto y coma que actúa como separador.

· La condición de terminación se comprueba antes de cada iteración del ciclo y éste se repite mientras que dicha condición se evalúe a un valor verdadero. Si se omite no se realiza ninguna prueba y se ejecuta siempre la sentencia for. Cuando la condición es verdadera, el ciclo ejecuta la iteración (todas sus sentencias) y a continuación la variable de control del ciclo se incrementa.

· El incremento se ejecuta después de que se ejecuten las sentencias y antes de que se realice la siguiente prueba de la condición de terminación. Normalmente esta parte se utiliza para incrementar o decrementar el valor de la(s) variable(s) de control y al igual que en la inicialización, se puede usar en ella el operador coma para pegar sentencias. Cuando no se tienen valores a incrementar se puede omitir este apartado.

· Las variables de control que pertenecen a la sentencia for pueden ser de cualquier tipo de datos simples.

SENTENCIA WHILE

Ejecuta una sentencia o bloque de sentencias mientras se cumple una determinada condición; es decir, la acción o acciones se repiten mientras la condición es verdadera. Sintaxis: while (condición) while (condición) sentencia1 { //secuencia de sentencias } Si la condición es verdadera, la sentencia o grupo de sentencias se ejecutan. Cuando la condición es falsa, el ciclo while se termina y el programa reanuda su ejecución en la primera sentencia después del ciclo.



La sentencia while es adecuada para muchas tareas. Un uso típico en programación es asegurar entradas de usuario válidas. Un problema frecuente en programación se produce cuando aparecen ciclo infinitos. Un ciclo infinito es aquel que nunca termina. Los ciclo infinitos se producen debido a que la condición que se comprueba nunca se hace falsa, de modo que el ciclo while ejecuta repetidamente sus sentencias una y otra vez.

SENTENCIA DO-WHILE

Es similar a la sentencia while, excepto que la condición se comprueba después de que el bloque de sentencias se ejecute (mientras que la sentencia while realiza la prueba antes de que se ejecute el bloque de sentencias). Sintaxis: do do sentencia; { while (condición); sentencias; } while (condición);

La(s) sentencia(s) se ejecutan y a continuación se evalúa la condición. Si la condición se evalúa a un valor verdadero, las sentencias se ejecutan de nuevo. Este proceso se repite hasta que la expresión tenga un valor falso, en cuyo momento se sale de la sentecia do-while. Dado que el test condicional se realiza al final del ciclo la sentencia o bloque de sentencias se ejecuta al menos una vez.

MÉTODOS

Definición: son una colección de sentencias que realizan una serie de operaciones determinadas. Declaración del método:

[private|protected|public] [static] [abstract] [final] [native] [synchronized] TipoDevuelto NombreMétodo ( [tipo1 nombre1[, tipo2 nombre2 ]…] ) [throws excepción1 [,excepción2]… ]

Cabecera del método



{ // Declaración de las variables //Asignación a variables //Operaciones matemáticas // Sentencias de control //Llamadas a otros métodos:

· Dentro de la clase

· De instancia, de otras clases

· De clase, de cualquier clase //Excepciones

[return valor de retorno;] } Explicación de la declaración: Básicamente, los métodos implementan operaciones y estructuras de control, el cálculo de algún parámetro que es el que devuelven al objeto que los llama. Sólo pueden devolver un valor (del tipo TipoDevuelto), aunque pueden no devolver ninguno (en ese caso TipoDevuelto es void). El valor de retorno se especifica con la instrucción return, dentro del método. Los métodos pueden utilizar valores que les pasa el objeto que los llama (parámetros), indicados con tipo1 nombre1, tipo2 nombre2… en el esquema de la declaración. Estos parámetros pueden ser de cualquiera de los tipos ya vistos. Si son tipos básicos, el método recibe el valor del parámetro; si son arreglos, clases o interfases, recibe un puntero a los datos (referencia). Java tiene 4 tipos de acceso diferente a las variables o métodos de una clase: privado, protegido, público o por paquete (si no se especifica nada). De acuerdo a la forma en que se especifica un atributo y método, objetos de otras clases tienen distintas posibilidades de accederlos:

Acceso desde: private protected public (Package)

La propia clase S S S S

Subclase en el mismo paquete

N S S S

Otras clases en el mismo paquete

N S S S

Subclases en otros paquetes

N X S N

Otras clases en otros paquetes

N N S N

Cuerpo del método



S: puede acceder N: no puede acceder X: puede acceder al atributo en objetos que pertenezcan a la subclase, pero no en los que pertenecen a la clase madre. Los métodos estáticos (static), son, métodos de clase; si el método no es static es un método de instancia. El significado es: un método static es compartido por todas las instancias de la clase. Los métodos abstractos (abstract) son aquellos de los que se da la declaración pero no la implementación (o sea que consiste sólo del encabezamiento). Cualquier clase que contenga al menos un método abstracto (o cuya clase madre contenga al menos un método abstracto que no esté implementado en la hija) es una clase abstracta. Es final un método que no puede ser redefinido por ningún descendiente de la clase. Las clases native son aquellas que se implementan en otro lenguaje (por ejemplo C o C++) propio de la máquina. Sun aconseja utilizarlas bajo riesgo propio, ya que en realidad son ajenas al lenguaje. Pero la posibilidad de usar viejas bibliotecas que uno armó y no tiene ganas de reescribir existe!. Las clases synchronized permiten sincronizar varios threads para el caso en que dos o más accedan concurrentemente a los mismos datos. Finalmente, la cláusula throws sirve para indicar que la clase genera determinadas excepciones.

CONSTRUCTORES Es un método especial dentro de una clase cuyo objetivo es el de inicializar un objeto cuando éste es creado. El constructor se llama automáticamente cada vez que se crea un objeto de esa clase. Características especiales:

· Se llama igual que la clase.

· No devuelve nada, ni siquiera void.

· Pueden existir varios, pero siguiendo las reglas de la sobrecarga de métodos explicadas en el apartado de abajo del documento.

· De entre los que existan, tan sólo uno se ejecutará al crear un objeto de la clase.

· Dentro del código de un constructor generalmente suele existir inicializaciones de variables y objetos, para conseguir que el objeto sea creado con dichos valores iniciales.



Constructor por defecto Un constructor por defecto es un constructor sin parámetros que no hace nada. Sin embargo será invocado cada vez que se construya un objeto sin especificar ningún argumento, en cuyo caso el objeto será iniciado con los valores predeterminados por el sistema (los atributos numéricos a ceros, los alfanuméricos a nulos, y las referencias a objetos a null). Ejemplo Un constructor por defecto, para la clase Suma quedaría así: public Suma() {} Como se observa el constructor no posee ningún parámetro, ya que como no ha sido definido propiamente por el programador, Java lo hace por default. Si se define un constructor con parámetros, (definido explícitamente) el constructor por default se reemplaza por éste, quedando el siguiente ejemplo: public Suma { private int numero1,numero2; //variables de la clase public Suma (int primero,int segundo){ //parámetros recibidos por el constructor numero1=primero; //inicialización de la variable numero1, asignándole el primer parámetro numero2=segundo; //inicialización de la variable numero2, asignándole el segundo parámetro } //fin del constructor Para invocarlo a la hora de declarar y construir el objeto se mandarán los parámetros necesarios, ejemplo: Suma objeto = new Suma (4,10); Esto indica que el objeto creado tendrá por valores de inicio 4 y 10 asignados a sus variables respectivas.

SOBRECARGA DE MÉTODOS En Java es posible definir dos o más métodos dentro de la misma clase que compartan el mismo nombre pero las declaraciones de sus parámetros deben ser diferentes. A esto es a lo que se conoce como Sobrecarga de Métodos. La Sobrecarga es uno de los procedimientos mediante el cual Java implementa el polimorfismo (en programación orientada a objetos es la capacidad que tienen los objetos

de una clase de responder al mismo mensaje o evento en función de los parámetros

utilizados durante su invocación)



ORIENTACIÓN A OBJETOS

¿Qué es un objeto?. La mejor forma de entenderlo es mediante una analogía. Consideremos una computadora, por ejemplo. Si la abrimos y lo observamos detenidamente, podemos comprobar que está formada por la placa base, el procesador, la memoria, el disco duro, etc. Si, a su vez, examinamos por separado cada parte, veremos que el disco duro está compuesto por varios discos superpuestos, las cabezas lectoras, un circuito controlador, etc. Podemos ver también que cada módulo de memoria está construido a partir de circuitos integrados de memoria más pequeños interconectados entre sí, y lo mismo ocurre con todas las demás partes de la computadora. El todo está formado por piezas, y cada pieza está compuesta por partes más pequeñas. Supongamos que se nos estropea el disco duro y necesitamos comprar otro. Si cada fabricantede PCs diseñara discos duros para sus computadoras basándose en especificaciones propias, estos serían incompatibles entre sí, y nos veríamos obligados a buscar el modelo de disco adecuado para nuestra computadora. Por suerte, existen en la industria estándares gracias a los cuales cada empresa puede fabricar internamente los discos duros como mejor les parezca, siempre y cuando la interfaz de conexión con la computadora cumpla con un estándar determinado y aceptado por todos los fabricantes (IDE,SCSI, etc.). De este modo, tenemos un objeto (el disco duro) que realiza una función determinada (almacenar información) sobre unos atributos (los datos), y que se comunica con el resto del sistema mediante una interfaz determinada y bien conocida. Si no quedo claro usaremos un ejemplo más sencillo. Cualquier juego de construcción como los de Lego o Tente está formado por elementos básicos (las piezas). Cada pieza, por sí sola, no tiene mucha utilidad, pero podemos juntarlas para construir lo que nos dé la gana. Si podemos construir cosas es porque cada pieza trae una serie de hendiduras que encajan en las de las demás. Así que tenemos una serie de objetos (las piezas) con una interfaz común (las hendiduras) y que nos permiten realizar una construcción (el programa). Mediante estos ejemplos ya podemos vislumbrar algunas de las características de los objetos: Ø Realizan una tarea por sí solos. Ø Proporcionan encapsulación: Es posible ocultar las partes internas de la

implementación de un objeto, permitiendo el acceso sólo a través de una interfaz bien conocida y definida.

Ø Son reutilizables. Ø Proporcionan escalabilidad (el programa puede crecer) y modularidad (el programa se

puede dividir en bloques que faciliten su comprensión).



En Java ocurre lo mismo que en los ejemplos anteriores. Programaremos una serie de objetos independientes con una funcionalidad determinada, y los juntaremos para crear un programa. Pero, para crear objetos, primero debemos hablar de las clases. Cuando se escribe un programa en un lenguaje orientado a objetos, no estamos definiendo objetos, sino clases. Una clase es la unidad fundamental en programación, la pieza de Lego. El problema es... que no existe. Es una abstracción. Es la plantilla que utilizaremos posteriormente para crear un conjunto de objetos con características similares. Y para entenderlo se utilizará el ejemplo de los coches. Supongamos que definimos una clase Coche. No tiene entidad física. Hablamos de un coche en general, sin especificar de qué tipo de coche se trata. Podemos asignarle un comportamiento y una serie de características, como se muestra en la siguiente figura.

A partir de esa clase Coche, podremos crear nuestros objetos (también llamados instancias), que serán las realizaciones ”físicas” de la clase. En el ejemplo, se muestran un

Seat Panda, un Opel Corsa, y un Renault Megane. Todos ellos comparten una serie de características comunes por las que podemos identificarlos como coches. Analicemos ahora nuestra figura: - Las clases se definen con la palabra reservada class. Todo el código que pertenezca a

esa clase se encierra entre dos llaves.- Los nombres de las clases, por norma, comienzan con mayúscula. - A continuación tenemos tres atributos, definidos por las variables estadoMotor, color

y modelo. Los atributos nos definen las características que tendrá cada objeto de esa clase, y que podrán ser distintas para cada uno de ellos. Es decir, cada coche será de



un modelo determinado, de un color, y su motor estará encendido o apagado. Por ahora no nos interesa que los tipos sean String o boolean.

- Por último, tenemos dos métodos, arrancar() y detener(). Los métodos nos definen el comportamiento que tendrán los objetos de esa clase.

Para poder implementar dicha clase tendremos que declarar y crear los objetos mostrados en la figura de arriba mediante la siguiente sintaxis:

nombreClase nombreObjeto = new constructorClase( ) ;

Las sentencias en Java quedarían así:

Coche SeatPanda = new Coche( ); Coche OpelCorsa = new Coche( );

Coche RenaultMegane = new Coche( );

Con ellas podemos accesar a cualquiera de los componentes que integran la clase, recordando que la sintaxis que nos permite hacerlo es: nombreObjeto . Ejemplos:

SeatPanda.color = ”Rojo Manzana”; RenaultMegane.arrancar( ); OpelCorsa.modelo = “2010”; RenaultMegane.detener( );

HERENCIA

En orientación a objetos la herencia es el mecanismo fundamental para implementar la reusabilidad y extensibilidad del software. A través de ella los diseñadores pueden construir nuevas clases partiendo de una jerarquía de clases ya existente (comprobadas y verificadas) evitando con ello el rediseño, la remodificación y verificación de la parte ya implementada. La herencia facilita la creación de objetos a partir de otros ya existentes, obteniendo características (métodos y atributos) similares a los ya existentes. Todas las clases en Java existen dentro de una jerarquía. Cada clase tiene una (y sólo una) clase por encima de ella, denominada superclase, y cualquier número de clases (o ninguna) por debajo. A estas últimas se las denomina subclases. Una clase heredará los métodos y variables de su superclase. Del mismo modo, sus subclases heredarán los métodos y variables de esa clase.

nombreAtributo

nombreMetodo

punto



Veamos la siguiente notación UML para ejemplificar la herencia en Java:

En ella se muestran 5 clases y su relación de herencia. Por encima de todas tenemos una superclase Animal, con un atributo peso y un método comer( ) (todos los animales tienen peso y comen).

Debajo de ésta aparecen otras dos clases con tipos de animales: Ovíparos y Mamíferos. Los Ovíparos pueden ponerHuevos( ). Los Mamíferos pueden parir( ) y amamantar() a sus crías, y pueden tener la sangreCaliente, o no. Estas dos clases, aparte de tener su propio comportamiento y sus características, heredan también los métodos y atributos de su superclase. Por ello, tanto los Mamíferos como los Ovíparos pueden comer() y tienen un peso.

Así mismo, la clase Mamífero tiene dos subclases que heredan de ella. Son las subclases Perro y Delfín. El perro, por ejemplo, tendrá un color de pelo determinado, y podrá ladrar. Y además, debido a la herencia, tendrá un peso, podrá comer, tendrá la sangre caliente y amamantará a sus crías. Cada subclase extiende y concreta la funcionalidad y características de su superclase. Es decir, se ”especializa” más.

La manera de especificar que una clase es subclase de otra se hace en la cabecera de la clase utilizando la palabra reservada extends. La sintaxis es la siguiente:

nombreClase extends nombreSuperclase

Cuando en una clase no se especifique nada, heredarán de la clase Object. Esta clase es la superior en la jerarquía de clases de Java, y es la única que no hereda de nadie. El hecho de que una clase de Java sólo pueda heredar de su superclase se denomina herencia simple. Todas las clases heredan de una, y sólo una clase (excepto la clase Object, claro, que no hereda de nadie). En otros lenguajes, como C++, existe el concepto de herencia múltiple, en el que una clase puede heredar de dos o más superclases. Pero no en Java, lo cual simplifica enormemente la programación sin restarle potencia.



FUNDAMENTOS BÁSICOS

Ejercicio1: Ofrecer el primer contacto de Java, a través de conceptos esenciales como son: la construcción de una clase, el método main, declaración de variables, operadores aritméticos y lógicos, uso de comentarios, operación de asignación y muestra de resultados mediante un método de salida. public class MiPrimeraClase { //cuerpo de la clase public static void main (String []args) { //cuerpo del método principal System.out.println("Mi primer programa en Java"); //esta sentencia manda a la consola un mensaje de texto int resultado; resultado=5-9*7/(2+2)%6*4%(4+9-3)*4-3+8; //operadores aritméticos System.out.println("El resultado de la expresion aritmética es "+resultado); boolean A,B,C; A=false; //inicio de secuencia de operaciones de asignación y operadores lógicos B=(9<=4+10/2); C=!(A||B); C= C&&(15!=6*5-15); B=((C||A)&&A); A=!(A&&B&&C); System.out.println("Los resultados de las variables logicas son \nA= "+A+"\nB= "+B+"\nC= "+C); } //fin del método principal } //fin de la clase Ejercicio2: Conocer las dos formas usadas por Java para ofrecer programas interactivos, mediante la entrada de datos por parte del usuario y la salida que muestra el resultado del proceso hecho por el programa. import javax.swing.JOptionPane; //importación de la clase adecuada para tener el ambiente gráfico public class EntradaSalida { public static void main(String [] args) { int primernumero,segundonumero; //variables que guardarán los valores introducidos por el usuario Scanner objetoScanner = new Scanner(System.in);



//declaracion del objeto de la clase Scanner que nos permite leer datos por parte del usuario mediante un ambiente de consola System.out.println("Introduce el primer número entero"); primernumero=objetoScanner.nextInt(); System.out.println("Introduce el segundo número entero"); segundonumero=objetoScanner.nextInt(); System.out.println("El resultado de la suma de los numeros es:"+(primernumero+segundonumero)); String numero; //esta variable recibirá el flujo de caracteres representado por los numeros a sumar numero=JOptionPane.showInputDialog("Introduce el primer numero entero:"); //el metodo showInputDialog muestra una ventana grafica en donde el usuario puede introducir valores desde el teclado primernumero=Integer.parseInt(numero); //el metodo parseInt convierte a un valor entero un flujo de caracteres numero=JOptionPane.showInputDialog("Introduce el segundo numero entero:"); //el metodo showInputDialog muestra una ventana grafica en donde elusuario puede introducir valores desde el teclado segundonumero=Integer.parseInt(numero); //el metodo parseInt convierte a un valor entero unflujo de caracteres JOptionPane.showMessageDialog(null,"La suma es:"+(primernumero+segundonumero) ,"Suma de enteros", JOptionPane.INFORMATION_MESSAGE); //el metodo showMessageDialog muestra una ventana con texto para informarle al usuario de algun proceso o actividad } } Ejercicio3: Mostrar el uso de la sentencia de control selectiva if-else, que permita entender su funcionamiento por medio de un juego de azar sencillo. import javax.swing.JOptionPane; public class SeleccionIfElse { public static void main (String []args) { String numero;//variable que almacenará el número introducido por parte del usuario int compu,usuario; //la variable usuario guardará el numero ya convertido del usuario y la variable compu el generado por la computadora numero=JOptionPane.showInputDialog("Introduce un número entero entre 1 y 5"); usuario=Integer.parseInt(numero); compu=(int)(Math.random()*5)+1; //el método random genera valores aleatorios flotantes entre un rango de 0 a 1 if(usuario == compu)



JOptionPane.showMessageDialog(null, "Acertaste", "Resultados",JOptionPane.ERROR_MESSAGE); else JOptionPane.showMessageDialog(null, "Fallaste", "Resultados", JOptionPane.WARNING_MESSAGE); System.exit(0); //con esta sentencia se la indica a la JVM que la terminación del programa se ha dado } } Ejercicio4: Enseñar el uso de la sentencia múltiple switch, eficaz en el manejo de menús que dan la posibilidad al usuario de elegir de un grupo de alternativas la que requiera. import javax.swing.JOptionPane; public class SeleccionMultiple { public static void main (String[]args) { String opcion; int opcion2; do{ //inicio del ciclo que se ejecuta por lo menos una vez opcion = JOptionPane.showInputDialog("Menu de Iconos\n1.Error\n2.Información\n3.Advertencia\n4.Pregunta\n5.Sin icono\n6.Salir\nElige una opción:"); //creamos el menu de iconos mediante el metodo showInputDialog y el caracter de edicion \n para tener opciones en renglones independientes opcion2=Integer.parseInt(opcion); switch(opcion2){ //inicio del switch case 1: JOptionPane.showMessageDialog(null,"Icono del Error","Iconos",JOptionPane.ERROR_MESSAGE); break; //sentecia que concluye con el flujo del programa del switch case 2: JOptionPane.showMessageDialog(null,"Icono de Información","Iconos",JOptionPane.INFORMATION_MESSAGE); break; //sentecia que concluye con el flujo del programa del switch case 3: JOptionPane.showMessageDialog(null,"Icono de Advertencia","Iconos",JOptionPane.WARNING_MESSAGE); break; //sentecia que concluye con el flujo del programa del switch case 4:



JOptionPane.showMessageDialog(null,"Icono de la Pregunta","Iconos",JOptionPane.QUESTION_MESSAGE); break; //sentecia que concluye con el flujo del programa del switch case 5: JOptionPane.showMessageDialog(null,"Sin icono","Iconos",JOptionPane.PLAIN_MESSAGE); break; //sentecia que concluye con el flujo del programa del switch case 6: JOptionPane.showMessageDialog(null, "Hasta luego!!!!!!"); break; default: JOptionPane.showMessageDialog(null,"No elegiste ninguna opcion del menú"); }//termino del switch }while(opcion2!=6); System.exit(0); } } Ejercicio5: Brindar pequeños ejemplos del uso y manejo de la sentencia repetitiva for para que el alumno reconozca su valor e importancia. public class EjemplosSentenciaFor { public static void main(String []args) { int i; for(i=1;i<=10;i++) System.out.print(i+" "); System.out.println();//nos da un nuevo renglon en la consola for(--i;i>0;i--) System.out.print(i+" "); System.out.println();//nos da un nuevo renglon en la consola for(char a='A';a<='Z';a++) System.out.print(a+" "); System.out.println();//nos da un nuevo renglon en la consola for(double b=10.0;b>=1;b-=0.5) System.out.print(b+" "); } }



Ejercicio6: Demostrar como mediante el empleo de la sentencia repetitiva while, el alumno es capaz de resolver problemas matemáticos simples como determinar si un número es primo o no. import javax.swing.JOptionPane; public class EjemploSentenciaWhile { public static void main (String []args) { String numero; int primo,i; boolean bandera=true; numero=JOptionPane.showInputDialog("Introduce un número entero y positivo"); primo=Integer.parseInt(numero); i=2; while(i<primo&&bandera) { if(primo%i==0) bandera=false;//al cambiar el valor lógico de la bandera permitimos terminar el ciclo anticipadamente i++; } if(bandera)//condición para determinar si es o no primo JOptionPane.showMessageDialog(null,"El numero "+primo+" es primo" ); else JOptionPane.showMessageDialog(null, "El número "+primo+" no es primo"); }//fin del método principal }//fin de la clase

MÉTODOS Ejercicio7: Mostrar como en Java se realiza la construcción de métodos estáticos para uso de la clase propia, enseñar el paso de parámetros por valor y su invocación mediante el método principal. import javax.swing.JOptionPane; public class OperacionesBasicasPorValor { static void suma(int numero1,int numero2,int resultado) {



resultado=numero1+numero2; JOptionPane.showMessageDialog(null,"Numero1="+numero1+"\nNumero2="+numero2+"\nResultado="+resultado); } static int resta(int numero1,int numero2, int resultado) { resultado=numero1-numero2; return resultado; } public static void main(String [] args) { int a=1,b=3,c=0; suma(a,b,c);//invocamos el metodo mediante el pase de parametros por valor JOptionPane.showMessageDialog(null,"Numero1="+a+"\nNumero2="+b+"\nResultado="+c); c=resta(a,b,c);//invocamos el metodo mediante el paso de parametros por valor pero recuperamos la acción del metodo mediante una operacion de asignacion JOptionPane.showMessageDialog(null,"Numero1="+a+"\nNumero2="+b+"\nResultado="+c); } } Ejercicio8: Demostrar el funcionamiento de Java al usar métodos por medio del paso por referencia empleando objetos de clases previamente programadas. import javax.swing.JOptionPane; public class OperacionesBasicasPorReferencia { private int numero1,numero2,resultado; //estas variables pertenecen a la clase OperacionesBasicasPorReferencia()//metodo constructor { numero1=10; numero2=5; resultado=numero1*numero2; }



void suma(OperacionesBasicasPorReferencia aux) { aux.resultado=aux.numero1+aux.numero2; //mediante el objeto aux de la clase OperacionesBasicas, utilizamos todos los componentes que integran la clase } void resta(OperacionesBasicasPorReferencia aux) { aux.resultado=aux.numero1-aux.numero2; } public static void main(String []args) { OperacionesBasicasPorReferencia objeto = new OperacionesBasicasPorReferencia(); //creamos el objeto para poder trabajar tanto con los metodos suma y resta, así como las variables de la clase JOptionPane.showMessageDialog(null,"Los valores iniciales del objeto son:\nNumero1 ="+objeto.numero1+"\nNumero2 ="+objeto.numero2+"\nResultado ="+objeto.resultado); objeto.suma(objeto); JOptionPane.showMessageDialog(null,"Numero1 ="+objeto.numero1+"\nNumero2 ="+objeto.numero2+"\nResultado de la suma ="+objeto.resultado); objeto.resta(objeto); JOptionPane.showMessageDialog(null,"Numero1 ="+objeto.numero1+"\nNumero2 ="+objeto.numero2+"\nResultado de la resta ="+objeto.resultado); } } Ejercicio9: Dar a conocer la gran cantidad de métodos existentes en Java, que el usuario puede emplear con sencillez y eficacia. import javax.swing.JOptionPane; public class MetodosdeJava { public static void main(String []args) { //metodo toHexString, pertenece a la clase Integer y convierte un valor entero a una hexadecimal



JOptionPane.showMessageDialog(null,"El valor entero 15 es en valor hexadecimal: "+Integer.toHexString(15)); //metodo toBinaryString, pertenece a la clase Integer y convierte un valor entero a un valor binario JOptionPane.showMessageDialog(null,"El valor entero 15 es en valor binario: "+Integer.toBinaryString(15)); //método abs, pertenece a la clase Math y devuelve el valor absoluto de un numero JOptionPane.showMessageDialog(null, "El valor absoluto del número -5.68 es: "+Math.abs(-5.68)); //método max,pertenece a la clase Math y éste regresa el mayor de 2 numeros JOptionPane.showMessageDialog(null,"El mayor entre 5 y 3 es: "+Math.max(3,5)); //método pow,pertence a la clase Math y eleva a la potencia un valor base JOptionPane.showMessageDialog(null,"El valor 2 elevado a la 8 es igual a: "+Math.pow(2,8)); //método ceil,pertenece a la clase Math y redondea un valor al próximo valor superior JOptionPane.showMessageDialog(null,"El valor 2.2 redondeado al valor próximo superior es: "+Math.ceil(2.2)); String nombre1="Ana",nombre2="ana"; //método equals, pertenece a la clase String ycompara dos cadenas de caracteres,devuelve un valor true si son iguales if(nombre1.equalsIgnoreCase("ana")) JOptionPane.showMessageDialog(null,"Son tocayos"); else JOptionPane.showMessageDialog(null,"Tienen nombres diferentes"); //método compareTo,pertenece a la clase String y compara 2 cadenas de caracteres y regresa un valor entero //si es igual 0 las cadenas son iguales, si es positivo el objeto que invoco al metodo es mayor y si es negativo //el objeto que invoco al metodo es menor if(nombre1.compareTo(nombre2)<0) JOptionPane.showMessageDialog(null,nombre1+"es menor que "+nombre2); else if(nombre1.compareTo(nombre2)==0) JOptionPane.showMessageDialog(null,nombre1+"es igual a"+nombre2); else JOptionPane.showMessageDialog(null,nombre1+ "es mayor que "+nombre2); //método length, pertenece a la clase String y devuelve la cantidad de caracteres que conforman la cadena JOptionPane.showMessageDialog(null,"La longitud del nombre Ana es: "+nombre1.length()); //metodo charAt, pertenece a la clase String ydevuelve el caracter según la posición entera que nosotros indiquemos



JOptionPane.showMessageDialog(null,"El caracter que se encuentra en la posición 0 de Ana es: "+nombre1.charAt(0)); } } Ejercicio10: Usar el concepto de sobrecarga de métodos, cómo el programarlo, usarlo y comprenderlo, mediante la declaración de dos clases, en la primera se construyen los métodos y en una segunda se declaran objetos de la misma y se invocan cada uno de ellos. import javax.swing.JOptionPane; public class DatosPersonales { void imprimir() //primer método de la sobrecarga { JOptionPane.showMessageDialog(null,"Bienvenido a la clase que imprime tus datos"); } void imprimir(String nombre) //segundo método de la sobrecarga { JOptionPane.showMessageDialog(null,"Tu nombre es: "+nombre); } void imprimir(String direccion,int edad, double estatura) //tercer método de la sobrecarga { JOptionPane.showMessageDialog(null,"Vives en: "+direccion+"\nTienes "+edad +"años\n Mides "+estatura); } void imprimir(char sexo, boolean nacionalidad) //último método de la sobrecarga { String auxiliar; if(nacionalidad) auxiliar="Mexicana"; else auxiliar="Extranjera"; JOptionPane.showMessageDialog(null,"Tu sexo es: "+sexo+"\nY tu nacionalidad es: "+auxiliar); } }



//inicio de la segunda clase en la cual se invocará la sobrecarga de métodos public class PruebaDatosPersonales { public static void main(String []args) { DatosPersonales objeto = new DatosPersonales(); //declaracion del objeto que nos permitirá realizar la sobrecarga de métodos objeto.imprimir("Bruno Ramos Ortiz"); objeto.imprimir(); objeto.imprimir("Hda.Villachuato 92",32,1.70); objeto.imprimir('M',false); } }

ARREGLOS Ejercicio11: Utilizar el tipo de dato estructurado llamado arreglo, declarar algunos de ellos y emplearlos a través de una segunda clase para resolver problemas de la vida real. import javax.swing.JOptionPane; public class Arreglos1 { //declaración de la variable y arreglos de la clase private String nombreMateria; private String [] nombresAlumnos; private double [] promediosAlumnos; Arreglos1(int longitud) //declaración del método constructor para inicializar los arreglos de la clase { nombresAlumnos = new String[longitud]; promediosAlumnos = new double[longitud]; } void setInformacion()//método que solicitará la inf. requerida para el programa { String calif; nombreMateria=JOptionPane.showInputDialog("Introduce el nombre de la materia"); for(int i=0;i<nombresAlumnos.length;i++) { nombresAlumnos[i]=JOptionPane.showInputDialog("Nombre del alumno");



calif=JOptionPane.showInputDialog("Promedio del alumno"); promediosAlumnos[i]=Double.parseDouble(calif); } } void calcularPromedioSeccion()//método que obtendrá el promedio del grupo, según las calificaciones de los alumnos de la seccion { double promedioSeccion=0.0; for(int i=0; i<promediosAlumnos.length;i++) promedioSeccion+=promediosAlumnos[i]; JOptionPane.showMessageDialog(null,"El promedio de la materia "+nombreMateria+" es: "+(promedioSeccion/promediosAlumnos.length)); } void getInformacion()//método que obtiene los valores almacenados en los arreglos y los muestra a pantalla { String resultado="Listado de promedios finales de alumnos de la materia "+nombreMateria; for(int i=0; i<nombresAlumnos.length;i++) resultado+="\nEl promedio de "+nombresAlumnos[i]+ " es "+ promediosAlumnos[i]; JOptionPane.showMessageDialog(null,resultado); } } //segunda clase que invocará los arreglos declarados en la clase anterior public class PruebaArreglos1 { public static void main(String []args) { Arreglos1 objeto = new Arreglos1(5); objeto.setInformacion(); objeto.calcularPromedioSeccion(); objeto.getInformacion(); } } Ejercicio12: Demostrar el impacto del uso de arreglos de objetos para la administración de información a través de acciones como altas, bajas, modificaciones y consultas. public class Trabajador {



public String clave,nombre,departamento; public double salario; public void setDatosLaborales(String clave, String nombre, String departamento) { this.clave=clave; this.nombre=nombre; this.departamento=departamento; } public void calcularSalario(double pagoHr, int hrsTrabajadas) { salario=pagoHr*hrsTrabajadas; } public String getDatosLaborales() { return "Clave del empleado "+clave+"\nNombre: "+nombre+"\nDepartamento: "+departamento+"\nSalario: "+salario; } public void limpiarDatosLaborales() { clave=""; nombre=""; departamento=""; salario=-1.0; } } //segunda clase que declara el arreglo de objetos de la clase anterior y los invoca mediante un menú de opciones. import javax.swing.JOptionPane; public class PruebaTrabajador { public static void alta(Trabajador arrayTrabajador[], int indice) { String clave,nombre,dpto; JOptionPane.showMessageDialog(null,"Alta del trabador"+(indice+1)); clave=JOptionPane.showInputDialog("Teclea la clave del trabajador"); nombre=JOptionPane.showInputDialog("Teclea el nombre del trabajador");



dpto=JOptionPane.showInputDialog("Teclea el departamento donde labora"); arrayTrabajador[indice].setDatosLaborales(clave, nombre, dpto); JOptionPane.showMessageDialog(null,"El trabajador "+ arrayTrabajador[indice].nombre+" se ha dado de alta"); } public static int buscar(Trabajador arrayTrabajador[], int tamaño) { String busqueda; int index=0; busqueda=JOptionPane.showInputDialog("Escribe la clave del trabajador"); while (index < tamaño && !busqueda.equals(arrayTrabajador[index].clave)) index++; return index; } public static void baja(Trabajador arrayTrabajador[], int indice) { arrayTrabajador[indice].limpiarDatosLaborales(); JOptionPane.showMessageDialog(null,"El trabador se dio de baja"); } public static void imprimir(Trabajador arrayTrabajador[],int indice) { JOptionPane.showMessageDialog(null,arrayTrabajador[indice].getDatosLaborales()); } public static void salario(Trabajador arrayTrabajador[],int indice) { String datoEntrada; double pagoHrs; int hrsLaboradas; datoEntrada=JOptionPane.showInputDialog("Teclea el pago por hora"); pagoHrs=Double.parseDouble(datoEntrada); datoEntrada=JOptionPane.showInputDialog("Teclea la cantidad de horas que trabajo en la quincena"); hrsLaboradas=Integer.parseInt(datoEntrada); arrayTrabajador[indice].calcularSalario(pagoHrs, hrsLaboradas); } public static void main(String []args) { Trabajador arrayTrabajador[]= new Trabajador[10];//declaracion del arreglo de objetos int indice=0,i;



String opcion; do { opcion=JOptionPane.showInputDialog("Menu Trabajador\n<A>lta\n<B>aja\n<C>onsulta\n<O>btener salario\n<S>alir\nElige una opción:"); switch(opcion.charAt(0)) { case 'A': arrayTrabajador[indice]= new Trabajador();//inicializar el objeto alta(arrayTrabajador,indice); indice++; break; case 'B': i = buscar(arrayTrabajador,indice); if (i>=indice) JOptionPane.showMessageDialog(null,"El trabajador no existe"); else baja(arrayTrabajador,i); break; case 'C': i = buscar(arrayTrabajador,indice); if (i>=indice) JOptionPane.showMessageDialog(null,"El trabajador no existe"); else imprimir(arrayTrabajador,i); break; case 'O': i = buscar(arrayTrabajador,indice); if (i>=indice) JOptionPane.showMessageDialog(null,"El trabajador no existe"); else salario(arrayTrabajador,i); break; case 'S': JOptionPane.showMessageDialog(null,"Hasta luego"); } } while(opcion.charAt(0)!='S'); } }



HERENCIA

Ejercicio13: Enseñar el empleo de la herencia en Java para obtener sus beneficios, en el ejercicio se declara una superclase de la cual se heredarán dos clases derivadas añadiéndoles tanto sus atributos como métodos propios, los cuales se comprueban en una última clase en donde se declaran y crean un par de objetos, uno de cada clase para hacer efectivo las propiedades de las mismas. import javax.swing.JOptionPane; //superclase del árbol de herencia public class Miembro_Facultad { private String identificador,nombre,direccion,sexo; private int edad; //constructor de la superclase, en donde se inicializan las variables public Miembro_Facultad() { identificador="040011-84"; nombre="Bruno Ramos Ortiz"; direccion="Hacienda Villachuato 92"; sexo="Masculino"; edad=31; } //método que solicitará de manera dinámica la captura de los datos del miembro de la facultad public void setDatos() { identificador=JOptionPane.showInputDialog("Introduce el identificador del integrante de la facultad: "); nombre=JOptionPane.showInputDialog("Introduce el nombre completo: "); direccion=JOptionPane.showInputDialog("Introduce su dirección: "); sexo=JOptionPane.showInputDialog("Introduce su sexo:"); edad=Integer.parseInt(JOptionPane.showInputDialog("Introduce la edad:")); } //método que mostrará toda la información relacionada con el miembro public String getDatos() { return "\nNombre del integrante: " + nombre + "\nIdentificador: " + identificador +"\nDirección: " + direccion + "\nSexo: " + sexo + "\nEdad: " + edad; } }



import javax.swing.JOptionPane; //clase derivada que agrega sus propios atributos y metodos public class Empleado extends Miembro_Facultad { private String profesion, puesto; private double salario; public Empleado() { super();//sentecia que invoca al contructor de la superclase para después inicializar las variables de la clase profesion="Licenciado en Informática"; puesto="Profesor"; salario=40*92.60; //se multiplica las horas a la semana por el pago de la hora } public void setDatos() { super.setDatos(); //invocación del método de la superclase que solicita los datos previos profesion=JOptionPane.showInputDialog("Introduce la profesión del empleado: "); puesto = JOptionPane.showInputDialog("Selecciona de las siguientes opciones el puesto del empleado, escribiéndolo: \nAdministrativo\nAcademico"); } public String getDatos() { return super.getDatos()+ "\nProfesión del empleado: "+profesion+"\nPuesto: "+puesto+"\nSalario quincenal: "+salario; } //método que obtiene el cálculo del salario del empleado según su puesto public void calcularSalario() { int horas; if(puesto.equalsIgnoreCase("Administrativo")) //el método equals compara el contenido de los cadenas si son iguales regresa true en caso contrario false salario=6500;//se establece un salario fijo quincenal según tabulador else if(puesto.equalsIgnoreCase("Académico")) //si es académico se solicitarán las horas de clase a la quincena {



horas=Integer.parseInt(JOptionPane.showInputDialog("Teclea las horas clases dadas a la quincena:")); salario=horas*92.60; } else JOptionPane.showMessageDialog(null,"El puesto del empleado es incorrecto"); } } import javax.swing.JOptionPane; //clase derivada que agrega sus propios atributos y métodos public class Alumno extends Miembro_Facultad { private int seccion, semestre; private double promedio; public Alumno() { super();//sentencia que invoca al constructor de la superclase para después inicializar las variables de la clase seccion=44; semestre=5; promedio=0.0; } //método que solicita la información del alumno más la información de la clase Miembro_Facultad public void setDatos() { super.setDatos(); //invocación del método de la superclase que solicita los datos previos seccion=Integer.parseInt(JOptionPane.showInputDialog("Introduce la sección del alumno: ")); semestre=Integer.parseInt(JOptionPane.showInputDialog("Introduce el semestre: ")); } //método que regresa los datos relacionados con el alumon public String getDatos() { return super.getDatos()+ "\nSección: "+seccion+"\nSemestre: "+semestre+"\nPromedio semestral: "+promedio; }



//método que obtiene el cálculo del promedio semestral del alumno public void calcularPromedio() { int cantidad_mat; double []calif_materias; //declaración del arreglo que guardará las calificaciones del semestre cantidad_mat=Integer.parseInt(JOptionPane.showInputDialog("Escribe la cantidad de materias que llevo en el semestre: ")); calif_materias=new double[cantidad_mat]; //creación del arreglo con el tamaño de las materias que cursó el alumno //ciclo que obtiene cada una de las calificaciones del alumno y las almacena en el arreglo for (int i=0; i<calif_materias.length;i++) calif_materias[i]=Double.parseDouble(JOptionPane.showInputDialog("Calificación materia "+(i+1))); //ciclo que hace la sumatoria total de las calificaciones del alumno for (int i=0; i<calif_materias.length;i++) promedio=promedio+calif_materias[i]; promedio=promedio/calif_materias.length; } } import javax.swing.JOptionPane; //última clase en la cual se declaran los objetos de las clases derivadas public class prueba_herencia { public static void main (String [] args) { Alumno bruno = new Alumno();//objeto que empleará los métodos de la clase Alumno bruno.setDatos(); bruno.calcularPromedio(); JOptionPane.showMessageDialog(null, bruno.getDatos()); Empleado ross = new Empleado();//objeto que usará los métodos de la clase Empleado ross.setDatos(); ross.calcularSalario(); JOptionPane.showMessageDialog(null, ross.getDatos()); } }



POLIMORFISMO

Ejercicio14: Vincular las ventajas del polimorfismo mediante clases y métodos abstractos que posteriormente nos permitirán generar las implementaciones de clases derivadas, se concluye con una clase de prueba para verificar su uso. //clase abstracta que dará la base del polimorfismo abstract public class Objeto_Geometrico { public double altura,base,lado; abstract public double Calcular_Area(); abstract public double Calcular_Perimetro(); } //clase derivada en la cual se implementa el polimorfismo public class Cuadrado extends Objeto_Geometrico { public Cuadrado(double a) { lado = a; } public double Calcular_Area() { return lado*lado; } public double Calcular_Perimetro() { return lado*4; } } //clase derivada en la cual se implementa el polimorfismo public class Triangulo extends Objeto_Geometrico { public Triangulo(double a, double b) { altura = a; base = b; } public double Calcular_Area() { return (base*altura)/2; }



public double Calcular_Perimetro() { return base*3; } } import javax.swing.*; public class Prueba { public static void main(String[] args) { String resultado; Triangulo triangulo = new Triangulo(13.5,6.7); Cuadrado cuadrado = new Cuadrado(12.3); resultado= "ÁREAS"+"\nTriangulo: "+triangulo.Calcular_Area(); resultado+="\nCuadrado: "+ cuadrado.Calcular_Area(); resultado+="\n\nPERIMETROS"+"\nTriángulo: "+ triangulo.Calcular_Perimetro(); resultado+="\nCuadrado: "+cuadrado.Calcular_Perimetro(); JOptionPane.showMessageDialog(null,resultado); System.exit(0); } }

Apuntes ejercicios programacion i

Technology

Transcript of Apuntes ejercicios programacion i