Apuntes ejercicios programacion i

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

PARADIGMAS DE LA PROGRAMACIÓN

BASES DE LA POO

M. A. Bruno Ramos Ortiz 1


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]
x Opciones: Especifica opciones relacionadas con la forma en que el intérprete Java
ejecuta el programa.
x 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.
x 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
x Opciones: Especifica opciones de cómo el compilador ha de crear las clases
ejecutables.
x 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
x Opciones: Especifica cómo ejecutar la applet Java.
x 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]
x 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]
x Opciones: Especifica la forma en la que se han de desensamblar las clases.
x 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
x NombreClase: Nombre de la clase desde la cuál se van a generar archivos fuente C.
x 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
x Opciones: Opciones sobre qué documentación ha de ser generada.
x 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 char final int

boolean class float null

byte default for package

case do if public

catch else import 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:
x Para pertenecer a un paquete se utiliza la siguiente sintaxis:
package nombrepaquete;

x 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:
x de instancia
x de clase
x 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

x Un tipo de dato primitivo
x El nombre de una clase
x 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
x Declarar
x Inicializar
x Usar

TIPOS DE DATOS PRIMITIVOS

Tipo Descripción
boolean Tiene dos valores true o false.
Caracteres Unicode de 16 bits Los caracteres alfa-numéricos son los mismos que
char 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)
Tamaño 32 bits. El intervalo de valores va desde -231 hasta 231-1 (-2147483648 a
int
2147483647)
Tamaño 64 bits. El intervalo de valores va desde -263 hasta 263-1 (-
long
9223372036854775808 a 9223372036854775807)
Tamaño 32 bits. Números en coma flotante de simple precisión. Estándar IEEE 754-
float
1985 (de 1.40239846e–45f a 3.40282347e+38f)
Tamaño 64 bits. Números en coma flotante de doble precisión. Estándar IEEE 754-
double
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
r
carro
tabulador
t
horizontal
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:



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

x 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.
x 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 { }

x Las sentencias podrán ser cero, una única sentencia o un bloque y serán lo que se
repita durante el proceso del ciclo.
x 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.
x 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.
x 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.
x 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:
x Dentro de la clase
x De instancia, de otras clases Cuerpo del método
x 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
N S S S
mismo paquete
Otras clases en el
N S S S
mismo paquete
Subclases en otros
N X S N
paquetes
Otras clases en
N N S N
otros paquetes



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:
x Se llama igual que la clase.
x No devuelve nada, ni siquiera void.
x Pueden existir varios, pero siguiendo las reglas de la sobrecarga de métodos
explicadas en el apartado de abajo del documento.
x De entre los que existan, tan sólo uno se ejecutará al crear un objeto de la clase.
x 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:
nombreAtributo

nombreObjeto . nombreMetodo

punto

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.



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


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
Iconosn1.Errorn2.Informaciónn3.Advertencian4.Preguntan5.Sin iconon6.SalirnElige
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);
case 3:
JOptionPane.showMessageDialog(null,"Icono de
Advertencia","Iconos",JOptionPane.WARNING_MESSAGE);
case 4:



JOptionPane.showMessageDialog(null,"Icono de la
Pregunta","Iconos",JOptionPane.QUESTION_MESSAGE);
case 5:
JOptionPane.showMessageDialog(null,"Sin
icono","Iconos",JOptionPane.PLAIN_MESSAGE);
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+" ");

for(char a='A';a<='Z';a++)
System.out.print(a+" ");

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.


public class EjemploSentenciaWhile
{
{
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.


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.


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

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


public class MetodosdeJava
{
{

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


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ñosn 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
{

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


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

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

{
Trabajador arrayTrabajador[]= new Trabajador[10];//declaracion del arreglo de objetos
int indice=0,i;



String opcion;
do
{
opcion=JOptionPane.showInputDialog("Menu
Trabajadorn<A>ltan<B>ajan<C>onsultan<O>btener salarion<S>alirnElige 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':
if (i>=indice)
else
imprimir(arrayTrabajador,i);
break;
case 'O':
if (i>=indice)
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.


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




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

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

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

}


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

}


//ú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+="nnPERIMETROS"+"nTriángulo: "+ triangulo.Calcular_Perimetro();
resultado+="nCuadrado: "+cuadrado.Calcular_Perimetro();
JOptionPane.showMessageDialog(null,resultado);
System.exit(0);
}
}


Apuntes ejercicios programacion i

Más contenido relacionado

La actualidad más candente

Similar a Apuntes ejercicios programacion i

Apuntes ejercicios programacion i