Programación Orientada a Objetos

Ingeniería en Tecnologías de la Información y Comunicaciones

Objetivo del curso o Competencia a desarrollar:

Aplica el paradigma orientado a objetos para el desarrollo de aplicaciones que solucionen

problemas del entorno.

Competencias previas

 Para cursar esta asignatura se requiere de conocimientos básicos y lógicos de

programación como las reglas de diagramación, pseudocódigo, uso de
expresiones de declaración, asignación, condicionales y estructuras cíclicas que
son adquiridos en la asignatura de Fundamentos de Programación.

Aportación del curso al perfil profesional:

Esta asignatura aporta al perfil del egresado habilidades para analizar, modelar
desarrollar e implementar sistemas de información para la gestión de procesos y apoyo en
la toma de decisiones que aumenten la productividad y competitividad de las
organizaciones utilizando metodologías basadas en estándares internacionales.

La asignatura incluye los conceptos y metodología orientada a objetos que permiten la

creación y optimización de aplicaciones basadas en clases y objetos, que propicien un
desarrollo ágil a través de la reutilización de código y aplicación de control de errores.

Temario:

1. Entorno de desarrollo
1.1. Estructura de un proyecto
1.2. Proceso de desarrollo de aplicaciones
1.2.1. Compilación
1.2.2. Archivos que crea el entorno de desarrollo
1.2.3. Depuración

2. Clases y objetos
2.1. Definición de una clase
2.2. Declaración de clases
2.3. Miembros de una clase
2.4. Ámbito referente a una clase
2.5. Especificadores de acceso
2.6. Creación de objetos
2.7. Clases predefinidas
2.8. Definición, creación y reutilización de paquetes/librerías
2.9. Manejo de excepciones

3. Métodos
3.1. Definición de un método.
3.2. Estructura de un método.
3.3. Valor de retorno.
 3.4. Declaración de un método.
3.4.1. De clase
3.4.2. De Instancia
3.5. Ámbito y tiempo de vida de variables.
3.6. Argumentos y paso de parámetros
3.7. Puntero this.
3.8. Sobrecarga de métodos.
3.9. Constructores y destructores

4. Herencia y polimorfismo
4.1. Concepto de herencia y polimorfismo.
4.2. Definición de una clase base.
4.3. Definición de una clase derivada.
4.4. Clases abstractas.
4.5. Interfaces.
4.5.1. Definición
4.5.2. Implementación.
4.5.3. Variable polimórficas
4.6. Reutilización de la definición de paquetes/librerías

5. Arreglos
5.1. Unidimensional
5.2. Multidimensionales

6. Archivos
6.1. Definición de Archivos de texto y archivos binarios.
6.2. Operaciones básicas en archivos texto y binario.
6.3. Manejo de excepciones en archivos.

Bibliografía

1. Ceballos J. (2007) Java 2 Lenguaje y aplicaciones. España: Alfaomega.

2. Ceballos J. (2012) Microsoft C# -Curso de Programación. España: Alfaomega.
3. Dean J. y Dean R. (2009) Introducción a la programación con Java: McGraw Hill
4. Doyle, B (2013) C# Programming: From Problem Analysis to Program Design.
Cengage Learning
5. Eckel, B. (2009) Piensa en Java. España: Prentice Hall.
6. Froufe, A. (2008) Java 2 Manual de usuario y tutorial. España: Alfaomega
7. Groussard, T. (2011) Recursos Informáticos C#4 Los fundamentos del lenguaje-
desarrollar con visual estudio 2010. España: Eni Ediciones
8. Joyanes, L. y Zahonero, I. (2011) Programación en Java 6. España: McGraw Hill
9. Sierra, K. (2008) SCJP Sun Certified Programmer for Java 6. USA: McGraw Hill.
10. Wu T. (2008) Programación en Java. Introducción a la Programación Orientada a
Objetos. España: McGrawHill
Fechas de Exámenes

Ensayo/Producto de
Examen Fecha Unidades
Aprendizaje
1er 1 24 de Agosto
(Unidad 2) 28 de Septiembre
2º. 13 de Octubre 2y3 (Unidad 3) 13 de Octubre
3er 4 de Noviembre 4 4 de Noviembre
(Unidad 5) 23 de Noviembre
4º. 01 de Diciembre 5y6 (Unidad 6) 01 de Diciembre
2ª Oportunidad 07 de Diciembre de 09:00 a 13:00

Calificación Final 09 de Diciembre

Criterios de evaluación y acreditación

 Exámenes 60%
 Productos de Aprendizaje 40% (Ensayos, Productos de Aprendizaje, etc.)
 Portada
 Índice *
 Contenido
 Conclusiones
 Bibliografía*
Notas:
* Puede ir o no, depende del tipo de documento
2ª. Oportunidad de los Ensayos, Productos de Aprendizaje, etc.

Otras Observaciones:

 Hora de entrada
 Asistencia a clase
 2ª Oportunidad
 Revisión equitativa
 Solicitud de Amistad a la cuenta de Facebook Arturo López Ponce
 Solicitar que los agrege al grupo AEB-1054-TC1 Ago-Dic 2016
 Foto para el Face.
1. Entorno de desarrollo

Existen diversos IDEs (Integrated Development Environment/Entorno de Desarrollo

Integrado) para Java, entre los que se encuentran:

a) Eclipse
b) NetBeans
c) BlueJ
d) JBuilder
e) JCreator

1.1. Estructura de un proyecto

Crear proyectos en Eclipse Neon

https://www.eclipse.org/downloads/download.php?file=/oomph/epp/neon/R/eclipse-inst-
win64.exe&mirror_id=272

1. Entra al programa Eclipse Neon

Cuando se corre por primera vez solicitará un directorio de espacio de trabajo:

2. Haga clic en el icono (o Alt + Shift + N), posteriormente selecciona la opción

Java Project o haga clic en File/New/ Java Project.
3. Luego mostrará la siguiente ventana:
4. Teclee el nombre del proyecto y posteriormente Finish.
5. Para crear una clase principal expanda el árbol del nuevo proyecto en el Package
Explorer y en la carpeta src haga clic al botón secundario, posteriormente
seleccione New y aparecerá la siguiente ventana:
6. Seleccione la opción Class y mostrará la siguiente ventana:

7. Teclee el nombre de la clase principal y active la casilla public static void

main(String [] args) y posteriormente hacer clic en Finish.
Crear proyectos en NetBeans:

https://netbeans.org/downloads/index.html

1. Entrar al programa de NetBeans

2. Haga clic en el icono o Archivo/Proyecto Nuevo… o Ctrl + Mayúsculas + N
3. Luego mostrará la siguiente ventana:

4. En la sección “Categorías” de la izquierda selecciona “Java“, y en la sección

“Proyectos” de la derecha selecciona “Java Application“. Luego Clik en Siguiente>.
Les mostrará la siguiente ventana:

5. Ahora solo colocar el nombre al proyecto. Finalmente clic en el botón Terminar.

Luego de cargar los componentes necesarios para nuestra aplicación, verán en la parte
superior izquierda:

Crear un proyecto en Bluej:

1. Ejecute el programa de BlueJ

http://www.bluej.org/

2. Haga clic el menú Project/New Project…

3. Posteriormente proporcione la ruta y el nombre del proyecto.

4. Para elaborar un programa haga clic en el botón y teclee el nombre

de clase por ejemplo HolaMundo, para continuar haga clic en Ok.

5. Para comenzar la edición haga clic en la clase , después aparecerá

un ejemplo predefinido en BlueJ, elimine todo el código, dejando solo la
declaración de la clase principal y las llaves.
 1.2. Proceso de desarrollo de aplicaciones
1.2.1. Compilación

Eclipse:


 Run/ Run
 Ctrl + F11

NetBeans


 Ejecutar/ Ejecutar Project
 F6

BlueJ:

 Dentro de la edición, hacer clic en

 O en la clase, hacer clic en el botón secundario y seleccionar la opción Compile
del menú contextual:

1.2.2. Archivos que crea el entorno de desarrollo

Eclipse:

 Carpeta .settings.- El .settings contiene las preferencias y configuración de eclipse

 Carpeta bin.- En esta carpeta se generarán los archivos “.class” (Bytecode).
 Carpeta src.- Contiene todos los archivos de código fuente .java
 Archivos .classpath y .project.- Contienen información sobre el proyecto.
NetBeans

 Dentro de un proyecto en NetBeans genera algunas carpetas y archivos, de los

cuales solo nos interesa:

“src” se encuentran los archivos fuente

“build” es donde se guardan los archivos compilados (.class).

BlueJ:

 En la carpeta del proyecto se guardan los archivos fuente (.java) y los compilados
(.class).

1.2.3. Depuración

La depuración (debug) permite examinar las aplicaciones para buscar errores, ya que
posibilita observar las líneas que se van ejecutando, así como los valores que van
tomando las variables en cada paso.

Eclipse:

Lo primero que hay que hacer es definir en qué punto o puntos del código queremos que
la ejecución del programa se detenga. Para ello, definiremos puntos de ruptura
(breakpoints) en las líneas de código donde queramos que la ejecución se detenga o
pause.

Para definir un punto de ruptura (o para eliminar uno existente), nos situamos en la línea
que queramos y seleccionamos "Run -> Toggle breakpoint" o Ctrl + Shift + B.

Una vez tenemos definidos los puntos de ruptura que queramos, iniciamos el depurador
seleccionando desde una clase ejecutable "Run -> Debug" o, alternativamente, dando al
botón con el bicho:
Lo primero que vemos es que el Eclipse cambia de la perspectiva Java, a la Perspectiva
Debug. En esta perspectiva, además de el código fuente, el esquema o la consola,
podemos ver la información de las variables y una ventana donde se muestran los hilos
de ejecución.

En la siguiente imagen podemos ver cómo la ejecución se ha detenido en la línea 14 del

main (donde habíamos definido el punto de ruptura) y cómo dicha línea aparece marcada
en el código fuente. En la figura podemos ver el contenido de las variables y objetos que
existen en el momento en que se ha pausado la ejecución, lo cual nos va a ayudar mucho
en la depuración.

Además, podemos indicar que la ejecución siga o se detenga a nuestro gusto utilizando
los botones de la vista Debug (o las opciones del menú "Run"). A continuación explicamos
las básicas.

Resume. Continúa la ejecución del programa hasta el próximo punto de ruptura o

hasta que finaliza la ejecución.

Terminate. Finaliza la ejecución del programa.

Step into. Se ejecuta la línea actual y, en caso de ser una llamada a un método, la
ejecución continúa dentro del método.

Step over. Se ejecuta la línea actual y se pasa a la línea siguiente sin entrar en los
métodos.

Step return. Se sigue ejecutando hasta que se ejecute un return. Es decir, se

ejecuta por completo el método en el que estemos y se pasa a la línea siguiente a la
invocación del método.
NetBeans

Al igual que en Eclipse, en NetBeans se tiene que establecer un punto de ruptura

(breakpoints), esto se realiza mediante:

1. Depurar -> Debug Main Project (Ctrl. + F5)

También pulsando con el botón derecho sobre un proyecto en explorador de proyectos y
seleccionar Debug. El programa se ejecuta hasta llegar al primer breakpoint.

Continuar ejecución (F8) Ejecuta una línea de código. Si la instrucción es una llamada
a un método, ejecuta el método sin entrar dentro del código del método.

Paso a paso (F7) Ejecuta una línea de código. Si la instrucción es una llamada a un
método, salta al método y continúa la ejecución por la primera línea del método.

Entra en el siguiente método (Ctrl + F7) Ejecuta una línea de código. Si la línea de
código actual se encuentra dentro de un método, se ejecutarán todas las instrucciones
que queden del método y se vuelve a la instrucción desde la que se llamó al método.

Ejecuta hasta el cursor (F4) Se ejecuta el programa hasta la instrucción donde se

encuentra el cursor.

Continuar (F5) La ejecución del programa continúa hasta el siguiente breakpoint. Si

no existe un breakpoint se ejecuta hasta el final.

Finaliza sesión del depurador (Mayúsculas + F5). Termina la depuración del

programa.
BlueJ:

El depurador de BlueJ realiza estas tres tareas:

 Poner puntos de ruptura

 Avanzar paso a paso por el código
 Inspeccionar variables.

Para poner un punto de ruptura: Pulsar en el área de puntos de ruptura que está a la
izquierda del texto en el editor.

Una vez puesto el punto de ruptura, ejecute el programa y tan pronto como se alcanza el
punto de ruptura, emerge la ventana del editor, mostrando la línea de código actual y
emerge una ventana de depurador. Esto tiene un aspecto semejante a la siguiente figura:

Paso a paso. Ejecuta una línea de código. Si la instrucción es una llamada a un

método, salta al método y continúa la ejecución por la primera línea del método.

Entra en el siguiente método. Ejecuta una línea de código. Si la línea de código

actual se encuentra dentro de un método, entra al método y se sitúa en la primera línea
del método.
 Continuar. La ejecución del programa continúa hasta el siguiente breakpoint. Si no
existe un breakpoint se ejecuta hasta el final.

Finaliza sesión del depurador. Termina la depuración del programa.

Producto de aprendizaje 1.

Elaborar un Ensayo donde indique cual IDE es el mejor, resaltando sus ventajas,
desventajas de dada uno.

¿Qué es un ensayo?

En el ensayo, el autor expone de manera libre sus argumentos que respaldan una
posición personal ante un determinado tema. Por eso, el ensayo puede incluir o no citas
bibliográficas, se pueden citar trabajos académicos, artículos periodísticos, otros ensayos,
incluir frases o refranes, ofrecer ejemplos, exponer propuestas, contar anécdotas,
experiencias o vivencias, etc.

El género de ensayo puede ser tanto de carácter académico como así también literario,
por lo cual es en esta característica donde radica de manera más notable su esencia de
“género libre”.

Los ensayos, a diferencias de textos académicos como las tesis de investigación o

monografías, no requieren de seguir un método científico de investigación para ser
realizados, pero sí de una gran habilidad de expresión y argumentación por parte de su
autor.

En general, el ensayo consta de tres partes en su estructura. La primera, es la de

presentación del tema, contextualización y exposición de una hipótesis (una suposición
planteada por el autor acerca de determinado tema o problema) o posición personal
acerca del tema central. En la segunda parte, llamada comúnmente desarrollo, el autor
expone argumentos a través de distintos recursos para sostener su hipótesis o posición
personal presentada al principio. Estos recursos pueden ser: comparaciones, ejemplos,
datos, estadísticas, citas bibliográficas, etc.

Por último, en su conclusión, el autor intentará reforzar su hipótesis o posición emitida al

comienzo del escrito. Como vemos, toda la estructura del ensayo se apoya entonces en la
argumentación alrededor de una posición personal sostenida por el autor. La clave está
en la habilidad de exposición del autor para presentar sus argumentos reforzando así todo
el tiempo –o al menos el que dura la lectura- su posición, sin caer en la redundancia y en
la repetición.
2. Clases y objetos

Antes de que un programa pueda crear objetos de cualquier clase, ésta debe ser definida.
La definición de una clase significa que se debe dar un nombre, así como también un
nombre a los elementos que almacenan sus datos, así como describir los métodos que
realizarán las acciones o tareas de la clase.

2.1. Definición de una clase

En el Lenguaje Unificado de Modelado (UML, Unifield Modeling Language), una clase es

representada por un rectángulo que posee tres divisiones:

Nombre de la clase

Atributos

Comportamiento

En donde:

 La parte superior: Contiene el nombre de la Clase

 La intermedia: Contiene los atributos (o variables de instancia) que
caracterizan a la Clase.
 La parte Inferior: Contiene los métodos u operaciones, los cuales son la forma
como interactúa el objeto con su entorno.

La representación gráfica de un objeto en UML:

Objeto : Clase X

Atributo1 = Expresión
… Objeto : Clase X

Método () (b) Notación reducida de un objeto

…

(a) Notación completa de un objeto

 Porsche911 : Carro

Color = “Amarillo”
… Marco : Alumno

ArrancarMotor () (d) Objeto Marco de la clase Alumno

…

(c) Objeto Porsche911 de la clase

Carro

2.2. Declaración de clases

class NombreClase {
Declaración de variables miembro
Constructores
Get’s
Set’s
Otros métodos
}

En general, las declaraciones de clase pueden incluir estos componentes:

a) Modificadores de acceso para las clases public y por defecto.

b) El nombre de la clase con la primera letra en mayúsculas, por convención.
c) El cuerpo de la clase, entre llaves, { }.

2.3. Miembros de una clase

Los miembros de una clase pueden ser:

 Variables: A las variables de una clase se les conoce también como

características, atributos, variables de instancia o variables de
clase.
 Constantes: Otro miembro que se puede declarar dentro de una clase son las
constantes.
 Métodos: También conocidos como comportamiento o métodos de clase o
funciones.

2.4. Ámbito referente a una clase

El ámbito determina en qué partes del programa una entidad puede ser usada y es
aplicable principalmente a las variables declaradas en las clase.

Si una variable es declarada dentro de un bloque (método/función/procedimiento), ésta

será válida solo dentro de ese bloque y se destruirá al terminar el bloque. Adicionalmente,
la variable no podrá verse ni usarse fuera del bloque (en el exterior del bloque). La
variable dentro del bloque es una variable local y solo tiene alcance dentro del bloque que
se creó, una variable definida fuera de cualquier bloque es una variable global y cualquier
bloque puede acceder a ella y modificarla.

2.5. Especificadores de acceso

Atributos y Métodos:

Atributos:

Los atributos o características de una Clase pueden ser de tres tipos, los que definen el
grado de comunicación y visibilidad de ellos con el entorno, estos son:

 public (+, ): Indica que el atributo será visible tanto dentro como fuera de
la clase, es decir, es accesible desde todos lados.

 private (-, ): Indica que el atributo sólo será accesible desde dentro de la
clase (sólo sus métodos lo pueden accesar).

 protected (#, ): Indica que el atributo no será accesible desde fuera de la

clase, pero si podrá ser accesado por métodos de la clase
además de las subclases que se deriven (herencia).
 defecto Si no especifica ningún tipo de acceso, se utiliza el acceso
por defecto, esto significa que la variable es accesible a
todas las clases contenidas en le mismo paquete.

Métodos:

Cada método tiene asociado un tipo que se utiliza para controlar el acceso al método.
Entre estos se encuentra:

 public (+, ): Indica que el método será visible tanto dentro como fuera de
la clase, es decir, es accesible desde todos lados.

 private (-, ): Indica que el método sólo será accesible desde dentro de la
clase (sólo otros métodos de la clase lo pueden accesar).

 protected (#, ): Indica que el método no será accesible desde fuera de la

clase, pero si podrá ser accesado por métodos de la clase
además de métodos de las subclases que se deriven
(herencia).
 defecto Si no especifica ningún tipo de acceso, se utiliza el acceso
por defecto, esto significa que el método es accesible a
todas las clases contenidas en el mismo paquete.
 Modificador Clase Package Subclase Todos

public Sí Sí Sí Sí
private Sí No No No
protected Sí Sí Sí No
por defecto Sí Sí No No

En la siguiente tabla presentamos los 8 tipos de dato primitivos de Java, el número de bits
que ocupan y el rango de valores que pueden tomar.

Tipo Tamaño en bits Rango de valores

boolean 1 true o false Nota: El No. de bits puede variar según la plataforma
char 16 ‘\u0000’ hasta ‘\uFFFF' Conjunto Unicode de ISO
–128 a +127
byte 8
27 a 27 – 1
–32,768 a +32,767
short 16
215 a 215 – 1
–2,147,483,648 a +2,147,483,647
int 32
231 a 231 – 1
–9,223,372,036,854,775,808 a
long 64 +9,223,372,036,854,775,807
263 a 263 – 1
±3.4028234663852886E+38 hasta
float 32
±1.40129846432481707E-45
±1.797693134862157E+308 hasta
double 64
±4.94065645841246544E-324

2.6. Creación de objetos

Al proceso de crear objetos se le llama instanciación. Y se puede realizar de dos formas:

1ª.- Primero se declara la referencia al objeto:

NombreDeClase identificadorObjeto;

Posteriormente se instancia el objeto:

identificadorObjeto = new NombreDeClase(Lista de Argumentos);

2ª.- Declarar la referencia y realizar la instanciación en una sola línea:

NombreDeClase identificadorObjeto = new NombreDeClase(Lista de Argumentos);

Ejercicio 2.1: Elabore una clase llamada Fecha, con tres variables miembro tipo int, que
representan el día, (d), el mes (m) y el año (a), el constructor por defecto inicializa la
variables con 1 para el día, 1 para el mes y 1900 para el año, el constructor alternativo
contara con tres parámetros, Set’s y Get’s, además se sobre carga el método toString el
cual regresa la fecha bajo el formato dd/mm/aaaa (para lograr esto utilice la clase
DecimalFormat que se encuentra en el paquete java.text).

La clase principal Ejercicio_1_1 se deben de instanciar dos objetos (fechaInicial y

fechaNacimiento), al crear el objeto fechaInicial invoca al constructor por defecto, mientras
que el objeto fechaNacimiento invoca al constructor alternativo y con los valores 20 a día,
09 al mes y 2016 al año. Finalmente despliega los datos invocando de forma implícita el
método toString().
Fecha
- int d;
- int m;
- int a;
+ Fecha()
+ Fecha(int vd, int vm, int va)
+ void cambiaDia(int vd)
+ void cambiaMes(int vm)
+ void cambiaAño(int va)
+ int regresaDia()
+ int regresaMes()
+ int regresaAño()
+ String toString()

import java.text.DecimalFormat;

public class Fecha {

private int d;
private int m;
private int a;

private DecimalFormat formato_dym = new DecimalFormat("00");

private DecimalFormat formato_a = new DecimalFormat("0000");

public Fecha() {
d = 1;
m = 1;
a = 1900;
}

public Fecha(int vd, int vm, int va) {

d = vd;
m = vm;
a = (va < 1900 ? 1900: va);
}

public void cambiaDia(int vd) {

d = vd;
}
 public int regresaDia() {
return d;
}

public void cambiaMes(int vm) {

m = vm;
}

public int regresaMes() {

return m;
}

public void cambiaAño(int va) {

a = va;
}

public int regresaAño() {

return a;
}

public String toString() {

return formato_dym.format(d) + "/" +
formato_dym.format(m) + "/" +
formato_a.format(a);
}
}
Clase Principal

Ejercicio 2.2: Elabore una clase llamada Árbol, con dos variables miembro, la primera se
llamará “Tipo” que representa el tipo de Árbol (Naranjo, Manzano, Pino, etc.) y Fruto
(Naranja, Manzana, Sin Fruto, etc.). Con dos constructores, el por defecto le pondrá los
valores de “Sin Tipo” a la variable Tipo y “Sin Fruto” a la variable Fruto, el constructor
alternativo se le mandaran dos parámetros que serán asignados a Tipo y Fruto, además
deberá tener los métodos Set’s y Get’s; la clase principal se debe de llamar
Ejemplo_Arbol, instancie dos objetos, el primero con el constructor por defecto, el
segundo con el constructor alternativa, los valores tendrán que ser capturados y
finalmente despliegue contenido en pantalla de cada objeto.
Ejercicio 2.3: Elabore una clase llamada Hora, con tres variables miembro, Horas,
Minutos y Segundos. Contará con cuatro constructores, el constructor por defecto le
pondrá los valores cero a las tres variables, el primer constructor alternativo recibirá un
valor y se lo asignará a las horas, mientras que a minutos y segundo le asignara cero, el
siguiente constructor alternativo recibirá dos parámetros los cuales se asignarán a las
variables hora y minutos; mientras que a segundos le podrá cero, al tercer constructor
alternativo recibirá tres parámetros los cuales se asignarán a horas, minutos y segundos,
también debe de tener los métodos Set’s y Get’s. Además debe sobrecargara el método
toString el cual regresara los valores almacenados bajo el formato HH:MM:SS. La clase
principal se debe de llamar Ejemplo_Hora y deben instanciar cuatro objeto (cada uno
creado con un constructor diferente) y desplegando el contenido de los objetos en
pantalla.

2.7. Clases predefinidas

Estos son los paquetes más importantes de la API de Java:

Paquete Descripción

java.applet Contiene clases para la creación de applets.

java.awt Contiene clases para crear interfaces de usuario con
ventanas.
java.io Contiene clases para manejar la entrada/salida.
java.lang Contiene clases variadas pero imprescindibles para el
lenguaje, como Object, Math, String, Wrappers, etc.
El paquete java.lang es importado por defecto.
java.net Contiene clases para soportar aplicaciones que
acceden a redes TCP/IP.
java.util Contiene clases que permiten el acceso a recursos del
sistema, etc.
javax.swing Contiene clases para crear interfaces de usuario
mejorando la AWT.

Clase Math

La Clase Math proporciona una gran variedad de métodos matemáticos al igual que
algunas constantes útiles.

Campos Descripción

final static double E Constante e: 2.7182818284590452354

final static double PI Constante pi: 3.14159265358979323846

 Métodos
static double abs(double d)
static float abs(float f)
static long abs(long l)
static int abs(int i)
static double acos(double d)
static double asin(double d)
static double atan(double d)
static double atan2(double d1, double d2)
static double cos(double d)
static double sen(double d)
static double tan(double d)
static double exp(double d)
static double log(double d)
Descripción
Regresa el valor absoluto especificado.
Regresa el inverso del coseno del ángulo
especificado en radianes.
Regresa el inverso del seno del ángulo
especificado en radianes.
Regresa el inverso de la tangente del
número especificado.
Regresa el ángulo definido por las
coordenadas rectangulares (d1, d2)
Regresa el coseno del ángulo especificado en
radianes.
double angulo = 45.0 * Math.PI/180.0;
System.out.println("cos(" + angulo + ") es " +
Math.cos(angulo));
Regresa el seno del ángulo especificado en
radianes.
double angulo = 45.0 * Math.PI/180.0;
System.out.println("sen(" + angulo + ") es " +
Math.sen(angulo));
Regresa la tangente del ángulo especificado en
radianes.
double angulo = 45.0 * Math.PI/180.0;
System.out.println("tan(" + angulo + ") es " +
Math.tan(angulo));
Regresa ed. Ejemplo:
System.out.println("exp(1.0) es " +
Math.exp(1.0));
System.out.println("exp(10.0) es " +
Math.exp(10.0));
System.out.println("exp(0.0) es " +
Math.exp(0.0));
Regresa el logaritmo natural de d (base e).
Ejemplo:
System.out.println("log(1.0) es " +
Math.log(1.0));
System.out.println("log(10.0) es " +
Math.log(10.0));
System.out.println("log(Math.E) es " +
Math.log(Math.E));
 Métodos Descripción

static double max(double d1, double d2) Regresa el valor más grande. Ejemplo:
static float max(float f1, float f2)
static long max(long l1, long l2)
Math.max(2.3,12.7) 12.7
static int max(int i1, int i2) Math.max(-2.3,-12.7) -2.3

static double min(double d1, double d2) Regresa el valor más pequeño. Ejemplo:
static float min(float f1, float f2)
static long min(long l1, long l2)
Math.min(2.3,12.7) 2.3
static int min(int i1, int i2) Math.min(-2.3,-12.7) -12.7

Regresa la raíz cuadrada del valor r

static double sqrt(double r)
espesificado. Math.sqrt(25) 5.0

static double pow(double base, double exp) Regresa baseexp. Ejemplo:

System.out.println("pow(10.0, 3.5) es " +
throws AritmeticException Math.pow(10.0,3.5));

Regresa un número aleatorio comprendido

entre 0.0 y 1.0. 0.0 <= Math.random() <= 1.0
static double random() System.out.println("Número aleatorio: " +
Math.random());
System.out.println("Otro número aleatorio: " +
Math.random());

Función
Significado Ejemplo de uso Resultado
matemática
abs Valor absoluto double x = Math.abs(-2.3); x = 2.3;
atan Arcotangente double x = Math.atan(1); x = 0.78539816339744;
sin Seno double x = Math.sin(0.5); x = 0.4794255386042;
cos Coseno double x = Math.cos(0.5); x = 0.87758256189037;
tan Tangente double x = Math.tan(0.5); x = 0.54630248984379;
exp Exponenciación double x = Math.exp(1); x = 2.71828182845904;
neperiana
log Logaritmo neperiano double x = Math.log(2.7172); x = 0.99960193833500;
pow Potencia double x = Math.pow(2,3); x = 8.0;
round Redondeo double x = Math.round(2.5); x = 3;
random Número aleatorio double x = Math.ramdom(); x = 0.20614522323378;
max Número máximo double x = max(12.5, 3.3); x = 12.5;
min Número mínimo double x = min(12.5, 3.3); x = 3.3

Ejercicio 2.4: El siguiente programa genera 10 números aleatorios, además cada valor
generado lo transforma en un número entre 15 y 35 por medio de cálculos; y
posteriormente los imprime.
Clase String La Clase String proporciona los mecanismos para el manejo de cadenas.
Ya que no se puede cambiar el valor de un String una vez que se ha
creado, esta clase se usa principalmente para analizar, manipular y
obtener los valores de las cadenas. Aunque hay métodos que permiten
modificar y añadir al valor de la cadena, estos métodos no modifican el
String en sí, sino que regresan un nuevo String con los valores deseado.

Métodos Descripción

String() Crea un Objeto String.

Crea un Objeto String basado en el arreglo

String(char ch[])
ch[].

Crea un Objeto String con el valor s

String(String s)
especificado.
 Métodos Descripción

Regresa el carácter que se encuentra en la

char charAt(int pos)
posición pos.

Regresa un int donde:

<0 El valor del String es menor al
otroString.
int compareTo(String otroString) 0 El valor del String es igual a
otroString
>0 El valor del String es mayor a
otroString.

String concat(String str) Regresa la concatenación del String y el str.

Regresa true si otroObjeto es String y tiene

boolean equals(Object otroObjeto)
el mismo valor.

Compara el String con otroString sin

boolean equalsIgnoreCase(String OtroString)
importar las mayúsculas y minúsculas.

int length() Regresa la longitud del String

Regresa la posición donde se encuentra str

int indexOf(String str) en el String, en caso de no encontrarlo
regresa -1.

Regresa la posición donde se encuentra str en

int indexOf(String str, int ini) el String comenzando en la posición ini.

Regresa la primera posición donde se

int indexOf(char ch)
encuentra ch en el String.

Regresa la primera posición donde se

int indexOf(char ch, int ini) encuentra ch en el String comenzando en
la posición ini.

Regresa la última posición donde se

int lastIndexOf(String str)
encuentra str en el String.

Regresa la última posición donde se

encuentra str en el String que se encuentre
int lastIndexOf(String str, int ini)
antes de la posición ini.
 Métodos Descripción

Remplaza todos los caracteres viejoch por

String replace(char viejoch, char nuevoch)
el carácter nuevoch.

Regresa una subcadena desde inicio hasta

String substring(int inicio, int fin)
fin.

Regresa una subcadena desde inicio hasta

String substring(int inicio)
final de la cadena.

String toLowerCase() Regresa el valor del String en minúsculas

String toString() Regresa el valor del String.

String toUpperCase() Regresa el valor del String en mayúsculas.

Regresa la String sin los espacios a la izq y

String trim()
der.

Static String valueOf(double d)

static String valueOf(float f)
static String valueOf(long l) Regresa un String que contiene el valor del
static String valueOf(int i) tipo de dato especificado.
static String valueOf(char ch)
static String valueOf(boolean b)

Regresa un String que representa una

Static String valueOf(Object obj)
cadena del Object.

Ejercicio 2.5: Elabore un programa que lea su nombre, lo imprima Normal y en forma
de espejo.
Ejemplo:
Dame tu nombre: José Pérez
José Pérez-zeréP éseJ

Ejercicio 2.6: Elabore un programa que lea su nombre y lo despliegue por palabra.

Ejercicio 2.7: Elabore un programa que lea su nombre y despliegue cuantas vocales,
literales y espacios tiene.
Clases contenedoras o wrappers

En Java existen una serie de clases predefinidas equivalentes a los tipos primitivos
denominadas wrappers, clases contenedoras o envoltorios. El identificador de cada una
de estas clases es el mismo que el del tipo primitivo correspondiente pero con la letra
inicial en mayúsculas (salvo int - Integer y char - Character). Cada una de estas clases
declaran un conjunto de métodos de gran utilidad.

Tipo primitivo Clase contenedora

boolean Boolean
char Character
byte Byte
short Short
int Integer
long Long
float Float
double Double

2.8. Definición, creación y reutilización de paquetes/librerías

Un paquete en Java es lo que su nombre lo indica, un paquete o conjunto de clases,

lógicamente, que tienen cosas en común. Lógicamente un programado puede agruparlas
con o sin criterio, pero lo ideal es que se dediquen a funciones específicas. También los
paquetes definen una jerarquía de directorios, que permiten igualmente agrupas las
clases, cosa de desplegar los archivos más ordenadamente.

Cuando necesitamos librerías de java, estamos llamando a una clase específica o a todo
un paquete. Por ejemplo, cuando ponemos esto:

import System.io.*;

Estamos importando todas las clases del paquete System.io.

Paquetes en los diferentes IDE’s:

Por medio de la sentencia package se pueden establecer paquetes. Para poder hacer
esto, se tiene que poner dentro de los programas .java esta sentencia y el nombre del
paquete que pertenece la clase.

Por ejemplo, supongamos que las clases Lapiz.java, Boligrafo.java y Goma.java, se van a
organizar para formar el paquete Escritorio, las clases quedarían de la siguiente forma:

package Escritorio; package Escritorio; package Escritorio;

public class Lapiz { public class Goma { public class Boligrafo {

public Lapiz () { public Goma() { public Boligrafo() {
System.out.println("Lápiz"); System.out.println("Goma"); System.out.println("Bolígrafo");
} } }
} } }
Ahora para utilizar estas clases debemos tener un programa que las utilice por ejemplo:

package Escritorio;

public class Ejemplo_Escritorio {

public static void main(String[] args) {

Lapiz l = new Lapiz();
Boligrafo b = new Boligrafo();
Goma g = new Goma();
}

Eclipse:
NetBeans

BlueJ

Para crear los paquetes seleccionamos el menú Edit -> New package, y escribimos el
nombre del package. Nos aparece un icono y haciendo doble click sobre él se nos abre la
ventana del package creado:

Donde el icono tipo carpeta “go up” nos sirve para subir de nivel en la jerarquía de
packages. Situados en la ventana del package repetiremos la operación creando el
package usuarios. Ahora desde el package entradas podemos hacer dos cosas: subir de
nivel hacia la raíz, o profundizar nivel hacia usuarios.

Al ejecutar el programa EjemploDePaquetes tendremos:

2.9. Manejo de excepciones

Una excepción en términos de lenguaje de programación es la indicación de un problema

que ocurre durante la ejecución de un programa. Sin embargo la palabra excepción se
refiere que este problema ocurre con poca frecuencia generalmente cuando existe algún
dato o instrucción que no se apega al funcionamiento del programa por lo que se produce
un error. El manejo de excepciones permite al usuario crear aplicaciones tolerantes a
fallas y robustos (resistentes a errores) para controlar estas excepciones y que pueda
seguir ejecutando el programa sin verse afectado por el problema. En lenguaje Java estas
excepciones pueden manejarse con las clases que extienden el paquete Throwable de
manera directa o indirecta, pero existen diversos tipos de excepciones y formas para
manejarlas.

El término excepción es una forma corta da la frase “suceso excepcional” y puede

definirse de la siguiente forma:

Definición: Una excepción es un evento que ocurre durante la ejecución del programa
que interrumpe el flujo normal de las sentencias.
Las excepciones permiten definir un bloque de código que se “tratará” de ejecutar, y un
segundo bloque alternativo que se ejecuta si dentro del bloque anterior se “dispara” una
excepción.

Estos bloques se conocen como bloques try y catch. Las excepciones se manejan
mediante un bloque try-catch de la siguiente forma:

try {
// Código que puede generar una excepción
…
…
}

catch (TipoDeExcepcion excepcion) {

// Código que maneja el error
…
…
}

Ejercicio 2.8: El siguiente programa captura dos valores tipo entero mediante la clase
JOptionPane, posteriormente se cual calcula la división del numerador entre el
denominador y finalmente se despliega en pantalla los valores del numerador,
denominador y el resultado.
Al ejecutar el programa tenemos:

Qué pasaría si el valor del denominador es cero:

Ocurre una terminación anómala de división por cero.

También puede ocurrir un error al convertir el dato a entero por medio del método parseInt
de la clase envoltorio Integer.
Ocurre un error de Formato de número.

Ejercicio 2.9: Para subsanar estos problemas se utilizaran Excepciones. En el siguiente

programa se utiliza el bloque try-catch, en la sección try se ponen las sentencias que
podría generar una excepción y tiene dos secciones catch, la primera que captura o cacha
la excepción de formato numérico (NumberFormatException) y la segunda es una
excepción aritmética o de división por cero (ArithmeticException).
import javax.swing.JOptionPane;

public class Ejercicio_2_9 {

public static void main(String args[]){

boolean Continua = true;

do {
try {
int numerador = Integer.parseInt(
JOptionPane.showInputDialog("Introduzca un numerador entero:"));
int denominador = Integer.parseInt(
JOptionPane.showInputDialog("Introduzca un denominador entero: "));

int resultado = numerador/denominador;

JOptionPane.showMessageDialog(null, "Resultado: " + numerador + " / " +

denominador + " = " +
resultado);
System.exit ( 0 );
Continua = false;
 }
catch (NumberFormatException errorDeFormatoNumerico) {
JOptionPane.showMessageDialog(null, "Teclee un dato tipo entero.\nIntente de
nuevo");
}
catch (ArithmeticException errorAritmetico) {
JOptionPane.showMessageDialog(null, "División por cero.\nIntente de nuevo");
}
} while (Continua);
}
}

Además utiliza un ciclo en caso de que ocurra una excepción regrese a solicitar los datos
hasta que la variable Continuar = false.

Clases de excepciones, excepciones predefinidas por el lenguaje.

En la siguiente figura se muestra una extracción de la jerarquía de herencia de la clase

Throwable:

Throwable

Exception Error …

RuntimeException IOException AWTError

ArithmeticException EOFException ThreadDeath

ArrayStoreException FileNotFoundException OutOfMemoryError

ClassCastException MalformedURLException …

… …

La clase Error está relacionada con errores de la máquina virtual de Java y no el código,
generalmente estos errores no dependen del programador por lo que no debe
preocuparse por tratarlos.
En la clase Exception se encuentran las excepciones RuntimeException, producidas por
errores de programación. El compilador de Java obliga a corregirlas.

En resumen las excepciones son generadas de tres formas diferentes.

1. La máquina Virtual de Java puede generar una excepción como producto de un

error interno que está fuera de su control. Estas excepciones generalmente no
pueden ser manejadas por el programa.

2. Excepciones estándar: Son excepciones que deben ser manipuladas, se

producen cuando se ejecuta una división por cero o se trata de acceder a un
arreglo con un índice fuera de límites son generadas por errores en el código del
programa.

3. El programador puede generar una excepción manualmente utilizando la

estructura Throw. Sin importar cómo se produjo la excepción, se maneja de la
misma forma.

Descripción de algunas excepciones:

ArithmeticException: Se produce cuando una condición aritmética excepcional, se

ha producido. Por ejemplo, un número entero "división por
cero" genera una instancia de esta clase.

ArrayStoreException: Lanzada para indicar que se ha intentado hacer para

almacenar el tipo equivocado de objeto en una matriz de
objetos. Por ejemplo, el código siguiente genera un
ArrayStoreException:

Objeto x [] = new String [3];

x [0] = new Integer (0);

ClassCastException: Lanzada para indicar que el código ha tratado de convertir un

objeto a una subclase de la cual no es una instancia. Por
ejemplo, el siguiente código genera una ClassCastException:

Objeto x = new Integer (0);

System.out.println ((String) x);

NegativeArraySizeException: Se produce si una aplicación intenta crear una matriz

con el tamaño del negativo.

IllegalMonitorStateException: Lanzada para indicar que un hilo ha intentado que

esperar en el monitor de un objeto o para notificar a
otros subprocesos que esperan en el monitor de un
objeto sin tener que poseer el monitor especificado.

NullPointerException: Se produce cuando una aplicación intenta utilizar nulo en el

caso de que se requiere un objeto. Estos incluyen:
  Llamar al método de instancia de un objeto nulo.
 El acceso o modificar el campo de un objeto nulo.
 Tomando la longitud de nulo como si se tratara de una matriz.
 El acceso o la modificación de las ranuras de cero como si se tratara de una
matriz.
 Lanzar nulo como si se tratara de un valor Throwable.
 Las solicitudes deben generar instancias de esta clase para indicar otros usos
ilegales del objeto nulo.

SecurityException: Lanzado por el gerente de seguridad para indicar una

violación de seguridad.

StringIndexOutOfBoundsException: Producidas por los métodos de cadena para

indicar que un índice es negativo o mayor que el
tamaño de la cadena. Para algunos métodos
tales como el método charAt, esta excepción
también se produce cuando el índice es igual al
tamaño de la cadena.

ArrayIndexOutOfBoundsException: Lanzada para indicar que una serie ha sido

visitada con un índice ilegal. El índice es negativo
o mayor que o igual al tamaño de la matriz.

NumberFormatException: Producida para indicar que la aplicación ha intentado para

convertir una cadena a uno de los tipos numéricos, pero
que la cadena no tiene el formato adecuado.

IllegalThreadStateException: Producida para indicar que un hilo no está en un estado

apropiado para la operación solicitada. Véase, por
ejemplo, la suspensión y reanudación métodos en la clase
Thread.

Propagación:

Consideremos el siguiente caso:

 main() llama al método primero()

 primero() llama al método segundo()
 En segundo() se produce una excepción

main()⇒primero()⇒segundo()

Si segundo() no captura la excepción con un catch, se propaga a primero(); si éste

tampoco la trata, se propaga a main(). Por último, si en main() tampoco se gestiona, se
termina el programa con un error de ejecución.
Clausula finally

try{
// Código protegido que puede provocar excepciones
…
}
catch (TipoDeExcepcion excepcion) {
// Código que maneja el error
…
}
finally{
// Código que se ejecuta siempre al final
…
}

 La cláusula finally define un bloque que se ejecuta siempre independientemente

de que se haya capturado, o no, la excepción.

 Si dentro de try hay alguna sentencia return, se ejecuta final y antes de devolver
el valor

Ejemplo de bloque try-catch-finally

try {
abrirGrifo();
regarCesped();
}
catch (MangueraRotaException e) {
darAlarma();
avisarFontanero();
}
finally{
cerrarGrifo();
}

En el ejemplo anterior en el caso de que ocurra una excepción de manguera rota se

invocara darAlarma() y posteriormente avisarFontanero(), al final se ejecutará el finally en
donde se cerraraGrifo() dado que en el try se abrió. En caso de que no ocurra ningún
error, de todos modos se ejecutará finally cerrando el grifo.

Ejercicio 2.10: Elabore un programa que solicite su nombre y posteriormente solicite por
teclado un valor numérico, a continuación imprima el carácter que este en esa posición,
en caso de que no exista ese carácter cachar la excepción
StringIndexOutOfBoundsException y mandar un mensaje de error.

Excepciones definidas por el usuario.

Si desea que los usuarios puedan distinguir, mediante programación, ciertas condiciones
de error de otras, puede crear sus propias excepciones, a esto se le llama excepciones
definidas por el usuario. Para lograr esto a una clase derivada extiéndala de la clase base
Exception. Cada una de estas clases define una excepción específica, por lo que en
muchos casos sólo hay que detectar la excepción.
Todas las excepciones tienen como clase base la clase Throwable, que está incluida en el
paquete java.lang, y sus métodos son:

 Throwable( String mensaje ); Constructor. La cadena es opcional

 Throwable fillInStackTrace(); Llena la pila de traza de ejecución.
 String getLocalizedMessage(); Crea una descripción local de este objeto.
 String getMessage(); Devuelve la cadena de error del objeto.
 void printStackTrace( PrintStream_o_PrintWriter s ); Imprime este objeto y
su traza en el flujo del parámetro s, o en la
salida estándar (por defecto).
 String toString; Devuelve una breve descripción del objeto.

Creación de una clase derivada del tipo excepción.

Podemos hacer que un método nuestro lance excepciones y lo especificaremos así:

public void writeList() throws IOException,

ArrayIndexOutOfBoundsException {
…
}
Todos los métodos Java utilizan la sentencia throw para lanzar una excepción. Esta
sentencia requiere un sólo argumento, un objeto Throwable. En el sistema Java, los
objetos lanzables son ejemplares de la clase Throwable definida en el paquete java.lang,
como por ejemplo:

throw new EmptyStackException();

Cuando se crea una nueva excepción, derivando de una clase Exception ya existente, se
puede cambiar el mensaje que lleva asociado. La cadena de texto puede ser recuperada
a través de un método.

Normalmente, el texto del mensaje proporcionará información para resolver el problema o

sugerirá una acción alternativa.

En el siguiente ejemplo se declara una clase llamada EdadFueradeRango que se

extiende de la clase Exception. Contiene dos constructores, el primero es el de por
defecto el cual invoca al súper constructor sin argumentos, el segundo (constructor
alternativo) recibe como parámetro un String el cual es invocado al súper constructor.

class EdadFueradeRango extends Exception {

public EdadFueradeRango() {
super();
}
public EdadFueradeRango( String s ) {
super( s );
}
}
Manejo de una excepción definida por el usuario.

Continuando con el ejemplo de la excepción fueran de rango, se declara una clase

Persona con el atributo Edad del tipo entero, además cuenta con un constructor por
defecto que le asigna cero a Edad y un constructor alternativo que recibe un argumento
entero y el cual utiliza un bloque try-catch, en la sección try invoca el método cambiaEdad
enviando como parámetro el valor entero e, en caso de ocurrir un error lo cachara
mediante la instrucción catch y desplegará un mensaje de error donde indicará que la
edad está fuera de rango.

class Persona {

int Edad;

public Persona() {
Edad = 0;
}

public Persona(int e) {
try {
cambiaEdad(e);
}
catch (EdadFueradeRango EdadErronea) {
System.out.println(EdadErronea);
}
}

El método cambiaEdad valida si la edad está entre 0 y 120 año si es así se la asigna a la
variable Edad, en caso contrario lanza una excepción de EdadFueradeRango.

private void cambiaEdad(int e) throws EdadFueradeRango {

if (e >= 0 && e <= 120)
Edad = e;
else
throw new EdadFueradeRango("Edad fuera de rango");
}
}

Mediante la clase principal Ejemplo_Excepcion se instancia un objeto Persona

mandándole una edad negativa que al validarse marcara un error de edad fuera de rango.

public class Ejemplo_ Excepcion {

public static void main(String args[]) {
Persona Manuel = new Persona(-1);
}
}
Producto de Aprendizaje 2: Realice lo que se le indica.

1. Elabore una clase llamada Persona, con los siguientes variables miembro:

 Nombre (String)
 Edad (int)
 Altura (double)
 Peso (double)
 Sexo (String)
 EstadoCivil (String)

El constructor por defecto asignara los siguientes valores a las variables:

 Nombre = “Sin Nombre”

 Edad = -1
 Altura = -1
 Peso == -1
 Sexo = “Hombre”
 EstadoCivil = “Soltero”

El constructor alternativo recibirá seis parámetros y asignara los valores a las

variables correspondientes.

Además tendrá los métodos Set’s y Get’s. Por último tendrá un método Despliega
que regresara un Cadena bajo el siguiente formato:

Nombre = “Nombre de la persona”

Edad = 99
Altura = 99.99
Peso == 99.999
Sexo = “Hombre/Mujer”
EstadoCivil = Soltero/Casado/Viudo/Unión Libre

La clase principal se debe de llamar Ejemplo_Persona, donde se deben de

instanciar dos objetos tipo Persona, el primero objeto deberá ser creado con el
constructor por defecto y el segundo objeto con datos deberán ser capturados
desde teclado y al final despliegue el contenido de los objetos en pantalla.

2. Elabore una clase llamada Estudiante, que maneje la siguiente información:

 No de Control
 Nombre
 Carrera
 Semestre
 Promedio
 Metodos:

 Constructores (por defecto y alternativo)

 Set’s y Get’s
 Sobrecargar toString

Para la clase principal (llamada Ejemplo_Estudiante), instancie cinco elementos de tipo

estudiante, capturar los datos de 5 amigos y al final despliege en pantalla la siguiente
información:

 El estudiante con mayor promedio

 El estudiante con el nombre o apellido más largo
 El estudiante del semestre más bajo

3. Elabore un programa que controle las fallas de los vehículos que llegan al Taller
Mecánico “Tubos y Mofles Galgo”. Los datos que se quieren manejar son:

 Placas
 Marca
 Modelo
 Nombre del dueño
 Tipo de falla:

1. Sistema eléctrico
2. Motor
3. Ruedas, dirección, suspensión y frenos
4. Transmisión
5. Sistema de inyección y carburación
6. Sistema de escape
7. Encendido
8. Sevicio de mantenimiento

 Costo estimado de reparación

o Refacciones
o Mano de obra
 Pagos realizados
 Fecha de entrega
 Porcentaje de avance

Implemente este programa mediante clases, intancia cinco objetos tipo vehículo con
diferentes datos, al final imprima la siguiente información:
  Porcentaje de tipo de fallas
 Resumen de pagos y costos estimados (Placa, Dueño, Costo estimado y Pagos
realizados)
 Resumen de vehículos en reparación (Placa, Dueño, Tipo de falla y Porcentaje de
avance)

4. Modifique el ejercicio 1, para que valide el estado civil por medio de excepciones,
el cual solo puede ser Soltero, Casado, Viudo o Unión Libre.

5. Implemente un programa donde ejemplifique la utilización de la excepción

NegativeArraySizeException
3. Métodos
3.1. Definición de un método.

Un método es un conjunto de instrucciones a las que se les da un determinado nombre de

tal manera que sea posible ejecutarlas en cualquier momento sin tenerlas que reescribir
sino usando sólo su nombre. A estas instrucciones se les denomina cuerpo del método, y
a su ejecución a través de su nombre se le denomina llamada al método.

La ejecución de las instrucciones de un método puede producir como resultado un objeto

de cualquier tipo. A este objeto se le llama valor de retorno del método y es
completamente opcional, pudiéndose escribir métodos que no devuelvan ninguno.

La ejecución de las instrucciones de un método puede depender del valor de unas

variables especiales denominadas parámetros del método, de manera que en función del
valor que se dé a estas variables en cada llamada la ejecución del método se pueda
realizar de una u otra forma y podrá producir uno u otro valor de retorno.

Al conjunto formado por el nombre de un método y el número y tipo de sus parámetros se

le conoce como firma del método. La firma de un método es lo que verdaderamente lo
identifica, de modo que es posible definir en un mismo tipo varios métodos con idéntico
nombre siempre y cuando tengan distintos parámetros. Cuando esto ocurre se dice que el
método está sobrecargado.

3.2. Estructura de un método.

La sintaxis es:

acceso static tipo NombreDelMétodo ([Lista de Argumentos]) {

Declaración de variables del método
Sentencias del método
[return tipo;]
}

Dónde:

acceso Cada método tiene asociado un tipo que se utiliza para controlar el acceso al
método. Entre estos se encuentran:

public Este método público se puede llamar de cualquier código que

tenga acceso a la clase.

private Este método privado solo puede ser llamado desde otros métodos
dentro de la clase en que se definió el método privado.

protected Este método protegido se puede llamar desde otros métodos de la

clase en que el método está definido y por cualquier otro método
de las clases que heredan de la clase en que está definido el
método. También está disponible en cualquier objeto de las clases
pertenecientes al mismo paquete en donde está definida la clase.
 defecto Si no especifica ningún tipo de acceso, se utiliza el acceso por
defecto, esto significa que el método es accesible a todas las
clases contenidas en el mismo paquete, pero no está accesible
fuera de ese paquete.

static Declara el método como método de la clase y no como método del objeto (no
hereda el método).

Nota: Un método declarado como static solo puede ser llamado por otro método
static y hacer referencia a variables static.

tipo Es el tipo de datos que regresara el método. Si se estipula un tipo de dato void
indica el método no regresa ningún valor (void indica ausencia de valor).
Dentro del método para retornar el valor se utiliza la palabra reservada return y
posteriormente el valor, si el tipo de dato del método se declara void no es
necesario utilizar la sentencia return.

NombreDelMétodo Es el nombre que distingue al método y debe estar formado por

un identificador.
Lista de Argumentos Son los valores que se pasarán al método para que realice su
tarea. Para cada argumento se tiene que declarar su tipo de dato.
Por ejemplo, el siguiente método se llama suma2Numeros, recibe
como argumento dos valores tipo long y regresa un valor long
con la suma de los valores que recibe como parámetro.

public static long suma2Numeros( long a, long b ) {

return (a + b);
}

3.3. Valor de retorno.

En Java es imprescindible que a la hora de la declaración de un método, se indique el tipo

de dato que ha de devolver. Si no devuelve ningún valor, se indicará el tipo void como
retorno.

Los métodos pueden devolver una variable u objeto, bien sea por valor (se devuelve una
copia), por puntero o por referencia. Java no soporta punteros, así que no puede devolver
nada por puntero. Todos los tipos primitivos en Java se devuelven por valor y todos los
objetos se devuelven por referencia. El retorno de la referencia a un objeto en Java es
similar a devolver un puntero a un objeto situado en memoria dinámica en C++, excepto
que la sintaxis es mucho más simple en Java, en donde el item que se devuelve es la
dirección de la posición en memoria dinámica donde se encuentra almacenado el objeto.

Para devolver un valor se utiliza la palabra clave return. La palabra clave return va
seguida de una expresión que será evaluada para saber el valor de retorno. Esta
expresión puede ser compleja o puede ser simplemente el nombre de un objeto, una
variable de tipo primitivo o una constante.
 public static long suma2Numeros( long a, long b ) {
return (a + b);
}

public static long suma2Numeros( long a, long b ) {

int c;
c = a + b;
return c;
}

3.4. Declaración de un método.

3.4.1. De clase

Métodos de clase

Un método de clase es aquel que puede ser invocado sin existir una instancia. Para
declarar un método como “Método de la clase” se utiliza la palabra reservada static:

acceso static tipo nombreMetodoClase (Lista de Argumentos) {

Declaración de variables del método
Sentencias del método
[return tipo;]

Para acceder a las variables o métodos de clase se utiliza el operador punto (.). Primero
se pone el nombre de la clase, un punto (.) y posteriormente el nombre de la variable de
clase o nombre del método de clase.

nombreClase.nombreVarClase;
nombreClase.nombreMetodoClase();

3.4.2. De Instancia

Métodos de instancia

Un método de instancia es el que se invoca siempre sobre una instancia (objeto) de una
clase. Para declarar un método de instancia se declara sin la palabra reservada static:

acceso tipo nombreMetodoInstancia (Lista de Argumentos) {

Declaración de variables del método
Sentencias del método
[return tipo;]

Para acceder a las variables o métodos de instancia se utiliza el operador punto (.).
Primero se pone el nombre del objeto, un punto (.) y posteriormente el nombre de la
variable de instancia (solo para cuando se declara como public o tipo de acceso amigable)
o nombre del método de instancia.
Objeto.nombreVarInstancia;
Objeto.nombreMetodoInstancia();

Ejercicio 3.1: Implemente la clase Punto; posteriormente instancie dos objetos tipo Punto,
el primero con los valores del constructor por defecto y el segundo con los valores de 5
para x y 10 para y, finalmente despliegue los valores de x y y por medio del método
regresaXY().

Punto
- int x;
- int y;
+ Punto()
+ Punto(int valorX, int Valory)
+ int regresaX()
+ int regresaY()
+ void asignaX(int valorX)
+ void asignaY(int valorY)
+ String regresaXY()
Que pasaría se deseamos saber cuántos objetos tipo Punto se han creado, para ello se
debe de implementar una variable de clase e incrementarla cada vez que se instancia un
objeto tipo Punto.

Ejercicio 3.2: Se modificará el Ejercicio 3.1, al cual se agregarán una variable de clase
llamada NoObjetosPunto, en cuanto a la clase principal se instanciaran dos objetos tipo
Punto, el primero con los valores del constructor por defecto y el segundo con valores
capturados desde teclado, finalmente despliegue los valores de x y y por medio del
método toString() y se indicarán cuantos objetos tipo Punto se han creado.
Punto
- int x;
- int y;
- static int NoObjetosPunto;
+ Punto()
+ Punto(int valorX, int Valory)
+ int regresaX()
+ int regresaY()
+ void asignaX(int valorX)
+ void asignaY(int valorY)
+ String toString()
+ int regresaNoObjetosPunto()
Ejercicio 3.3: El siguiente programa lee un valor en grados Celsius y por medio de un
método llamado (estático) convierteAFahrenheit convierte los grados Celsius a grados
Fahrenheit.

9
Fahrenheit = C + 32
5
Ejercicio 3.2: Elabore un programa que leean del teclado un dato numérico que
representan los mentros y por medio de los métodos conversionAPies y
converionApulgadas cambia el valor en metros a pies y a pulgadas (donde 1 metro =
39.37 pulgadas y 1 pie = 12 pulgadas)

Ejercicio 3.3: Una tonelada métrica equivale a 35,273.92 onzas. Elabore un programa
que lea desde teclado, el peso que le cabe a una caja en onzas y mediante el método
calculaCajas determine cuantas cajas se pueden llenar con una tonelada métrica de
cereal.

3.5. Ámbito y tiempo de vida de variables.

El ámbito de una variable define su alcance de uso, o lo que es lo mismo, en que

secciones de código una variable estará disponible. Fuera de este ámbito, una variable no
podrá ser accedida (no existe).

Tipos de ámbito

En Java tenemos tres tipos de ámbito que pueden aplicar a una variable:

 Local
 Global
 Estático

Veamos un fragmento de código donde aparecen los tres tipos, antes de pasar a explicar
con un mínimo de detalle cada uno de ellos:

public class Punto {

private int x;
private int y;
private static int NoObjetosPunto;

public Punto() {
x=0;
y=0;
}
 public Punto(int vx, int vy) {
x= vx;
y= vy;
}

public int regresaX() { return x; }

public int regresaY() { return y; }

public void asignaX(int vx) { x=vx; }

public void asignaY(int vy) { y=vy; }

public String toString() {

return "[ " + x + ", " + y + " ]";
}

public int regresaNoObjetosPunto() {

return NoObjetosPunto;
}
}

Variables de ámbito local.- Las variables de ámbito local, o de bloque, son aquellas que
sólo pueden ser accedidas desde el bloque de código en el que han sido declaradas (que
no inicializadas).

Variables de ámbito global.- Las variables de ámbito global, o de instancia, son aquellas
que pertenecen a cada instancia concreta de la clase donde han sido declaradas, y
dependiendo del modificador de visibilidad usado (más tarde hablaremos sobre ésto)
podrían ser sólo accedidas desde la propia instancia a la que pertenecen:

Variables estáticas.- Las variables estáticas, o de clase, son aquellas que pertenecen a
la propia clase donde han sido declaradas, y dependiendo del modificador de visibilidad
usado podrían ser sólo accedidas desde la propia clase en la que han sido declaradas:

3.6. Argumentos y paso de parámetros

Los argumentos son los valores que se pasan al método para que realice un proceso o
tarea y el método recibe estos argumentos en los parámetros designados (variables).

En el paso de parámetros a funciones hay dos aproximaciones clásicas: el paso por valor
y paso por referencia.

 Por valor: En el paso por valor se realiza una copia de los valores que se
pasan, trabajando dentro del método con la copia. Es por ello que cualquier
cambio que sufran dentro, no repercute fuera del método.

 Por referencia: En el paso por referencia no se realiza dicha copia, por lo que
las modificaciones de dentro de los métodos afectan a los parámetros y esos
cambios permanecen al final del método.
En Java el paso por parámetro es por valor, aunque los efectos son de paso por
referencia cuando los argumentos son objetos. ¿Cómo sucede eso? Pues es muy fácil, si
un método tiene como argumento un tipo primitivo (int, float, etc...), en Java se realiza una
copia para la función y cualquier cambio a dicho argumento no afecta a la variable
original. Este paso de parámetros en Java está orientado a utilizar el valor de la variable
para otros cálculos.

En el caso de los objetos es distinto. En realidad lo que sucede es que en Java siempre
tenemos referencias a los objetos. Por eso al pasar a un método como argumento un
objeto, pasamos la referencia al mismo, es decir, aunque se hace una copia para el paso
por valor, como lo que se copia es una referencia, los cambios al objeto referenciado sí
son visibles y afectan fuera de método.

La única excepción es la clase String, cuyos objetos no son mutables. Cualquier

modificación de un objeto String lleva aparejada la creación de una nueva instancia del
objeto. Si deseamos el mismo comportamiento para el paso de parámetros del resto de
objetos, tenemos que recurrir al objeto StringBuffer.

Ejercicio 3.4: En el siguiente programa se declaran 2 variables, la primera es un arreglo

de caracteres (char) y el segundo es un dato tipo int, dentro del método main se
despliegan los datos antes de enviar las variables como parámetros al método Cambia.
En el método Cambia, se modifica el arreglo en el subíndice 2 por el carácter ‘@’ y se
multiplica el valor de la variable int por 4. Cuando termina de ejecutar el método Cambia
se vuelven a desplegar las variables y se puede observar que el arreglo cambió en el
subíndice 2 debido a que fue enviado como por referencia, sin embargo la variable tipo int
no sufrió cambios, debido a que se mando por valor.
 3.7. Puntero this.

Fundamentalmente this tiene dos usos:

 Seleccionar explícitamente un miembro de una clase con el fin de evitar colisión de

identificadores. Por ejemplo:

class Punto {
private int x;
private int y;
...
Punto (int x, int y) {
this.x = x;
this.y = y;
}
class Triangulo {
private double base;
private doble altura;

public void datosTriangulo (double base, double altura) {

this.base = base;
this.altura = altura;
}

 Qué un método devuelva el mismo objeto que le llamó. De esta manera se puede
hacer llamadas en cascada a métodos de la misma clase.
class Circulo {
Punto centro;
int radio;
. . .
public Circulo elMayor(Circulo c) {
if (radio > c.radio)
return this;
else
return c;
}
}

3.8. Sobrecarga de métodos.

En programación orientada a objetos la sobrecarga se refiere a la posibilidad de tener dos

o más métodos con el mismo nombre pero funcionalidad diferente. Es decir, dos o más
métodos con el mismo nombre realizan acciones diferentes. El compilador usará una u
otra dependiendo de los parámetros usados. A esto se llama también sobrecarga de
métodos.

La firma de un método es la combinación del tipo de dato que regresa, su nombre y su

lista de argumentos.

La sobrecarga de métodos es la creación de varios métodos con el mismo nombre pero

con diferentes firmas y definiciones. Java utiliza el número y tipo de argumentos para
seleccionar cuál definición de método ejecutar.

Java diferencia los métodos sobrecargados con base en el número y tipo de argumentos
que tiene el método y no por el tipo que devuelve.

En Java es posible definir dos o más métodos dentro de una misma clase que compartan
el mismo nombre y que las declaraciones de sus argumentos sean diferentes. En este
caso se dice que los métodos están sobrecargados y el fenómeno se conoce como
sobrecarga de métodos. La sobrecarga es uno de los procedimientos mediante el cual se
implementa el polimorfismo.

En la llamada a los métodos sobrecargados, el compilador determina cual es el método

involucrado basándose en el número o tipo de argumentos. Por consiguiente los métodos
sobrecargados deben diferenciarse en el número o tipos de argumentos. Cuando Java
encuentra una llamada a un método sobrecargado, ejecuta la versión del método cuyos
argumentos (número y tipo) coincidan con los argumentos utilizados en la llamada.

Nota: La declaración de los métodos sobrecargados no deben ser ambigua, de modo

que el compilador pueda decidir inequívocamente cuál método ejecutar.

Ejercicio 3.5: El siguiente programa declara una clase llamada Sobrecarga con cuatro
métodos llamados “despliega” que se encuentran sobrecargados. El primer método no
recibe parámetros, el segundo recibo solo un parámetro tipo int, el tercero recibo dos
parámetros tipo int y por último el cuarto método recibe dos parámetros tipo float. El
funcionamiento de cada método depende de los parámetros que reciba, desplegando en
pantalla el número de argumentos recibidos, los tipos y valores (con excepción del
método sin parámetros, el cual solo despliega en pantalla un mensaje).

El programa principal Ejercicio_3_5 instancia un objeto, llamado Sob1, posteriormente

invoca a los métodos “despliega” enviando varios números y tipos de argumentos
diferentes.
Ejercicio 3.6: El siguiente programa declara una clase principal llamada Ejercicio_3_6,
con cuatro métodos llamados “Area” que se encuentran sobrecargados. El primer y
segundo método calcula el área de un cuadrado y reciben un argumento cada uno, el
primer de ellos recibe un tipo int y el segundo lo recibe tipo float. El tercer y cuarto método
calcula en área de un rectángulo, reciben dos argumentos, los parámetros del tercer
método son de tipo int y el cuarto método sus parámetros son de tipo float. Regresan un
valor tipo long (primer y tercer método) y un valor tipo double (el segundo y cuarto
método). Además se utiliza la clase DecimalFormat para formatear los datos de salida.

Ejercicio_3_6

+ Area (int L): long

+ Area (float l): double
+ Area (int b, int a): long
+ Area (float b, float a): double
Ejercicio 3.7: Elabore una clase principal que tenga 6 métodos sobrecargados llamado
areaTriangulo, que realizaran el cálculo del área de un triangulo en base a lo siguiente:

 Con un parámetro, se asume que es un triangulo Equilátero y el área se

calcula:

√3 ∙ 𝑎2
Á𝑟𝑒𝑎 =
4

Donde a es el lado del triangulo

 Con dos parámetros, el área se calcula:

𝑏∙𝑎
Á𝑟𝑒𝑎 =
2

Donde b es la base y a es la altura del triangulo

 Con tres parámetros, el área se calcula::

Á𝑟𝑒𝑎 = √𝑝 ∙ (𝑝 − 𝑎) ∙ (𝑝 − 𝑏) ∙ (𝑝 − 𝑐)
 Donde a, b y c son los valores de las longitudes de los lados del triangulo y
p se calcula así:

(𝑎 + 𝑏 + 𝑐)
𝑝=
2

Los primeros 3 métodos sobrecargados recibirán datos tipo int y los restantes 3,
datos tipo double. El valor de retorno de todos los métodos será double.

Mande a imprimir a pantalla los resultados de todos los métodos.

3.9. Constructores y destructores

Un constructor es un método miembro de propósito específico que se ejecuta

automáticamente cuando se crea un objeto de una clase. Un constructor sirve para
inicializar los miembros de datos o variables de clase.

Los constructores tienen el mismo nombre que la clase, además no tienen valor de
retorno (ni void) y están clasificados en constructores por defecto y
alternativos/sobrecargados.

Constructores

Los constructores tienen el mismo nombre que la clase, además no tienen valor de
retorno (ni incluso void) y están clasificados en constructores por defecto y
alternativos/sobrecargados.

Constructor por defecto

Un constructor que no tiene parámetros se le llama constructor por defecto. Un

constructor por defecto normalmente inicializa las variables con un valor por defecto, por
ejemplo: En el siguiente código se declara la clase Punto, con dos variables miembro tipo
int, el constructor por defecto inicializa las variable x y y con cero, esto ocurrirá cuando se
instancie un objeto tipo Punto.

public class Punto {

private int x; // Coordenada x
private int y; // Coordenada y

public Punto() { // Constructor por defecto

x=0;
y=0;
}

public Punto(int valorX, int valorY) { // Coordinador alternativo

x= valorX;
y= valorY;
}
 public int regresaX() { // Get de x
return x;
}

public int regresaY() { // Get de Y

return y;
}

public void asignaX(int valorX) { // Set de x

x=valorX;
}

public void asignaY(int valorY) { // Set de y

y=valorY;
}
}

Regla: Java crea automáticamente un constructor por defecto cuando no existe otro
constructor. Tal constructor inicializa las variables tipo int, float, double, long con
cero, las booleanas con false y las referencias con null.

Constructor alternativo/sobrecargado

A un constructor con parámetros se le denomina constructor alternativo y su función es

modificar las variables de la clase, con los valores que recibe como parámetros:

public class Punto {

private int x; // Coordenada x
private int y; // Coordenada y

public Punto() { // Constructor por defecto

x=0;
y=0;
}

public Punto(int valorX, int valorY) { // Coordinador alternativo

x= valorX;
y= valorY;
}

Precaución: Tenga cuidado con la declaración de una clase que sólo tenga un
constructor con argumentos. En ese caso si se omite un constructor sin
parámetros no será posible utilizar el constructor por defecto.

Ejemplo: El código que se muestra a continuación declara una clase llamada Punto
con dos variables miembro tipo int (x y y), además tiene un constructor
alternativo (debido a que tiene parámetros), el cual asigna los valores que
se le envían como parámetros a las variables x y y, dado que no tiene un
 constructor por defecto (sin argumentos), al querer instanciar un objeto
del tipo punto (que en este ejemplo lo llamamos primerPunto) marcará
error, debido a que dicho método constructor no existe.

public class Punto {

private int x; // Coordenada x
private int y; // Coordenada y

…
public Punto(int valorX, int valorY) { // Coordinador alternativo
x= valorX;
y= valorY;
}

Al instanciar un objeto tipo Punto, marcara un error debido a que se está invocando al
constructor por defecto, sin embargo esta clase no lo tiene.

Punto primerPunto = new Punto(); // no es posible utilizar este

constructor

Producto de Aprendizaje 3: Elabore los siguientes ejercicios utilizando métodos.

1. Escriba un programa que dado el total a pagar de la compra de X productos y la

cantidad de dinero entregada, calcule el vuelto que hay que dar al cliente por
medio de un método.

2. Escriba un programa que mediante un método determine si una cadena es

palíndromo (un palíndromo es una palabra que se lee igual en sentido directo
como inverso, por ejemplo radar).

3. Escriba un programa que lea dos enteros positivos n y b que llame a un método
cambiarBase para calcular y visualizar la representación del número n en la base
b.

4. Escriba un programa que mediante un método que tome como argumentos las
longitudes de los tres lados de un triangulo (a, b y c), devuelva el área del
triangulo.

Area  p( p  a)( p  b)( p  c)

abc
donde p
2
5. Elabore una clase principal que tenga 6 métodos sobrecargados llamado
areaCuadrilatero, que realizaran el cálculo del área de un cuadrilátero en base a lo
siguiente:

 Dos parámetros, área de un romboide y se calcula:

Á𝑟𝑒𝑎 = 𝑏 ∙ 𝑎

Donde b es la base y a es la altura del romboide

 Tres parámetros, área de un trapezoide o cualquier cuadrilátero y se

calcula así:
 ̅̅̅̅
𝐴𝐶 ∙ ̅̅̅̅
𝐵𝐷 ∙ 𝑠𝑒𝑛 𝜃
Á𝑟𝑒𝑎 =
2

Donde ̅̅̅̅
𝐴𝐶 y ̅̅̅̅
𝐵𝐷 son las diagonales y 𝜃 es el ángulo que lo conforma (Ver
figura).

 O seis parámetros y se calcula así:

𝑎 ∙ 𝑑 ∙ 𝑠𝑒𝑛 𝛼 + 𝑏 ∙ 𝑐 ∙ 𝑠𝑒𝑛 𝛾
Á𝑟𝑒𝑎 =
2
Siendo:
𝛼 ángulo comprendido entre los lados 𝑎 𝑦 𝑑.
𝛾 ángulo comprendido entre los lados 𝑏 𝑦 𝑐

Los primeros 3 métodos sobrecargados recibirán datos tipo long y los restantes 3,
datos tipo double. El valor de retorno de todos los métodos será double.

Mande a imprimir a pantalla los resultados de todos los métodos.

4. Herencia y polimorfismo
4.1. Concepto de herencia y polimorfismo.

La idea de la herencia es permitir la creación de nuevas clases basadas en clases

existentes. Cuando heredamos de una clase existente, reusamos (o heredamos) métodos
y campos, y agregamos nuevos campos y métodos para cumplir con la situación nueva.

4.2. Definición de una clase base.

Al crear una clase, en vez de declarar miembros (variables y métodos) completamente

nuevos, el programador puede designar que la nueva clase herede los miembros de una
clase existente. Esta clase existente se conoce como superclase, y la nueva clase se
conoce como subclase.

4.3. Definición de una clase derivada.

En otros lenguajes de programación, como C++ se refieren a la superclase como clase

base y a la subclase como clase derivada. Una vez creada, cada subclase se puede
convertir en superclase de futuras subclases. Una subclase generalmente agrega sus
propias variables y métodos, por lo tanto, una subclase es más específica que una
superclase y representa un grupo más concreto de objetos.

Superclase
Préstamo

Hipotecario Personal Prendario

Subclases

A veces es difícil decidir cuál es la relación de herencia más óptima entre el diseño de
clases. Consideremos por ejemplo el caso de empleados de una empresa, existen
diferentes tipos de clasificación según sea el criterio de discriminación, por ejemplo por
tipo de empleado:
 Empleado

Directivo Administrativo Obrero

Por tipo de percepción:

Empleado

Confianza Comisión Asalariado

Por tiempo de dedicación laboral:

Empleado

Discontinuo TiempoFijo Horas

Por tipo de contratación:

Empleado

Base Anual Mensual

Como se darán cuenta es difícil establecer cuál de estos modelos es el más adecuado, lo
mejor es decidirse hasta que tenga la aplicación real y el usuario le diga cuál es la mejor
forma de organización de su empresa y así trasladarla al diseño jerárquico de clases.

Declaración.

Una clase derivada (o subclase) es una clase que hereda los atributos y comportamiento
de una clase base (o superclase). Sintaxis:

public class Subclase extends Superclase {

acceso nuevoMiembro
...
public tipo NuevoMétodo (Lista de Parámetros)
…
}

Herencia-Redefinición.- Es cuando un método de una súper clase se redefine en las

subclases. En el siguiente ejemplo se asume que todos los animales duermen (súper
clase Animal), pero al heredar a una clase León el método (dormir) se redefine indicando
que el León duerme sombre el vientre, mientras que en el Oso duerme sobre la espalda y
el tigre duerme sobre un árbol, a esto se le conoce como redefinición de métodos.

Animal dormir (){

System.out.println(“Zzzzz”);
}
dormir()

León Oso Tigre

dormir() dormir() dormir()

dormir (){ dormir (){

System.out.println(“Sobre el vientre”); System.out.println(“En un árbol”);
} dormir (){ }
System.out.println(“Sobre la espalda”);
}

Ejercicio 4.1: En el siguiente ejemplo tenemos la súper clase Préstamo, que contiene las
variables miembro Monto e Interés que son del tipo float con tipo de acceso privado (-),
además cuenta con los siguientes métodos los cuales todos son públicos (+):

 Constructores (por defecto y alternativo)

 calculaIntereses() que no recibe ningún parámetro y regresa el cálculo de los
interés (Monto por Intereses) del tipo float.
 actualizaMonto() que recibe un parámetro tipo float y se lo asigna a Monto.
 actualizaIntereses() que recibe un float como parámetro y se lo asigna a Intereses.
  Muestra() que regresa un String con el Monto: 99999 un salto de línea y el Interes:
99999

Prestamo

- float Monto
- float Interes

+ Presamo()
+ Prestamo (float M, float I)
+ float calculaIntereses()
+ void actualizaMonto(float M)
+ void actualizaInteres(float I)
+ String muestra()

Hipotecario Personal Prendario

-String Inmueble -String TipoDocumento -String Prenda

-int AniosHipo -String FechaVen - float ValorPrenda

+ Hipotecario() + Personal() + Prendario()

+ Hipotecario(float M, + Personal(float M, float I, + Prendario(float M,
float I, String In, int A) String D, String F) float I, String P, float V)
+ String muestra() + String muestra() + String muestra()

Como se puede observar en la jerarquía de clases, la flecha indica que la clase

Hipotecario hereda las características y comportamiento de Préstamo, además define las
variables miembro Inmueble del tipo String que representa el bien inmueble que se
hipotecara para obtener el préstamo y la variable AniosHipo del tipo entera (int) que
representa los años de hipoteca. Estas dos variables tienen el tipo de acceso privado (por
el signo negativo que las precede). Además cuenta con los siguientes métodos públicos
(+):

 Constructores (por defecto y alternativo)

 muestra() que regresa un String con el Préstamo Hipotecario, salto de línea, Bien
Inmueble:XXXXXXXXXX, salto de línea, Años de Hipoteca. 99 y lo que regresa
muestra del a súper clase.

También la clase Personal hereda las características y comportamiento de Préstamo,

además define las variables miembro TipoDocumento del tipo String que representa el
documento que se firma (pagare, letra de cambio, etc.) para obtener el préstamo y la
variable FechaVen del String que representa la fecha de vencimiento del documento.
Estas dos variables tienen el tipo de acceso privado (por el signo negativo que las
precede). Además cuenta con los siguientes métodos públicos (+):

 Constructores (por defecto y alternativo)

 muestra() que regresa un String con el Crédito Personal, salto de línea, Tipo de
Documento: XXXXXXXXXX, salto de línea, Fecha de Vencimiento: XXXXXXXXX y
lo que regresa muestra del a súper clase.
La clase Prendario hereda las características y comportamiento de Préstamo, además
define las variables miembro Prenda del tipo String que representa el la prenda que se
deja en garantía (Joyas, Pinturas, etc.) para obtener el préstamo y la variable ValorPrenda
del tipo entera (int) que representa el valor de la prenda. Estas dos variables tienen el tipo
de acceso privado (por el signo negativo que las precede). Además cuenta con los
siguientes métodos públicos (+):

 Constructores (por defecto y alternativo)

 muestra() que regresa un String con el Crédito Prendario, salto de línea, Prenda:
XXXXXXXXXX, salto de línea, Valor de la prenda: 999999999 y lo que regresa
muestra del a súper clase.

Una vez implementado en BlueJ se tendrá un diseño así:

Elabore las clases Prestamo, Hipotecario, Personal y Prendarios, así como también
elabore la clas principal Ejemplo_Prestamo para que obtenga el siguiente resultado:
 4.4. Clases abstractas.

Cuando pensamos en un tipo de clase, suponemos que los programas crearán objetos de
ese tipo, sin embargo, existen casos en los que es conveniente declarar clases para las
cuales el programador no pretende instanciar objetos. Dichas clases se denominan clases
abstractas, debido a que estas solo se utilizan como superclases en la jerarquía de
herencias, nos referiremos a ellas como superclases abstractas. Estas clases no pueden
utilizarse para instanciar objetos, porque las clases abstractas se declaran incompletas,
las subclases deben declarar las partes faltantes.

El propósito de una clase abstracta es proporcionar una superclase apropiada, a partir de

la cual se puedan heredar otras clases. Las clases que pueden usarse para instanciar
objetos se conocen como clases concretas, dichas clases proporcionan implementaciones
de todos los métodos que declaran. Podríamos tener una superclase llamada
Bidimensional y derivar a partir de ella clases concretas como Cuadrado, Circulo y
Triangulo. También podríamos tener una superclase abstracta llamada Tridimensional y
derivar de ella clases concretas como Cubo, Esfera y Tetraedro. Las clases abstractas
son demasiado genéricas como para crear objetos reales; sólo especifican lo que las
subclases tienen en común. Necesitamos ser más específicos antes de poder crear
objetos. Por ejemplo, si alguien le dice “dibuje una figura”, ¿Qué figura dibujaría?. Las
clases específicas proporcionan los aspectos específicos que hacen que sea razonable el
crear instancias de objetos.
Una jerarquía de clases no necesita contener clases abstractas, sin embargo,
comúnmente se utilizan jerarquías de clases encabezadas por superclases abstractas
para reducir las dependencias de código cliente en un tipos de subclases específicas. Por
ejemplo considere la siguiente jerarquía de clases:

Figura

Bidimensional Tridimensional

Circulo Cuadrado Triangulo Esfera Cubo Tetraedro

En este jerarquía de clases la superclase abstracta Figura, en el siguiente nivel tenemos

otros dos clases abstractas Bidimensional y Tridimensional y en el último nivel se declaran
clases concretas las cuales son para las figuras bidimensionales Circulo, Cuadrado y
Triangulo, mientras que las figuras tridimensionales son Esfera, Cubo y Tetraedro.

Definición

Para que una clase sea abstracta se debe declarar con la palabra reservada abstract.
Una clase abstracta por lo general tiene uno o más métodos abstractos (los métodos
static no pueden ser abstractos). Un método abstracto es un método con la palabra
reservada abstract en su declaración.

public abstract class NombreDeClase {

public abstract tipo Método ();
…
}

Los métodos abstractos no proporcionan implementaciones. Una clase que contiene

métodos abstractos debe declararse como clase abstracta. Cada subclase concreta de
una clase abstracta debe proporcionar implementaciones concretas de los métodos
abstractos de la superclase. Los constructores no se heredan, por los que no pueden
declararse como abstractos.

Aunque no podemos crear instancias de objetos de superclases abstractas, podemos

utilizar superclases abstractas para crear variables que puedan guardar referencias de
subclases concretas derivadas de la superclases.
Redefinición

Considere la siguiente jerarquía de clases:

Figura

Punto

Circulo

Cilindro

Comenzaremos con la superclase abstracta Figura, la cual declara la interfaz para la

jerarquías (es decir, el conjunto de métodos que puede invocar un programa en todos los
objetos Figura), observe también que en el diagrama de clases, el nombre de la clase
abstracta Figura aparece en cursivas.

Métodos

regresaArea regresaVolumen regresaNombre toString

Predeterminado
Figura 0.0 0.0 abstract
de Object
Punto 0.0 0.0 “Punto” [x,y]
Circulo  r2 0.0 “Circulo” [x,y]; Radio = r
[x,y]; Radio = r;
Cilindro 2  r h + 2  r2  r2 h “Cilindro”
Altura = h

La clase Figura proporciona los métodos regresaArea, regresaVolumen y regresaNombre,

además como es una extensión de la clase Object, hereda los 11 métodos, entre ellos se
encuentran toString, por lo que tendrá que ser redefinido.

Ejercicio 4.2: Implemente las clases

Figura, Punto, Circulo, Cilindro y
PruebaHerenciaAbstracta:
La clase Punto se extiende de Figura heredando todo los métodos públicos. Dentro de la
clase Punto se declaran dos variables miembro tipo int llamada x y y, las cuales tienen
tipo de acceso es privado, contiene dos constructores (uno por defecto y otro alternativo),
además tiene los métodos regresaX(), regresaY() que regresan el valor de su
correspondiente variable, cambiaX() y cambiaY() que cambian los valores de sus
correspondientes variables, también se redefine el método abstracto regresaNombre(), el
cual regresa el nombre de la figura “Punto”, con esto deja de ser abstracta y se vuelve
concreta. Finalmente se redefina el método toString().

La clase Círculo se extiende de Punto heredando todo los métodos públicos. Dentro de la
clase Círculo se declara la variable miembro radio del tipo double donde el tipo de acceso
es privado. Contiene dos constructores, uno por defecto y otro alternativo, los cuales al
utilizar el método súper() el cual invocan al súper constructor de la súper clase Punto,
además tiene los métodos regresaRadio() y cambiaRadio() que regresan y cambian el
valor del radio, en este último método se utiliza la selección simple lineal (?), en donde si
la condición es verdadera regresa el primer valor después del signo de interrogación, en
caso de ser falso regresa el valor que se encuentra después de los dos puntos, esto se
realiza para asegurarse que no existan radios negativos. El método regresaDiametro()
devuelve el doble del radio. Y Finalmente se redefine el método regresaNombre(), el cual
regresa el nombre de la figura “Círculo”, se redefine el método regresaArea() y toString().

La clase Cilindro se extiende de Círculo heredando todo los métodos públicos. Dentro de
la clase Cilindro se declara la variable miembro altura del tipo doublé, donde el tipo de
acceso es privado. Contiene dos constructores, uno por defecto y otro alternativo, los
cuales también utilizan el método súper() invocan al súper constructor de la súper clase
Círculo, además tiene los métodos regresaAltura() y cambiaAltura() que regresan y
cambian el valor de la altura. Y se redefine los métodos regresaNombre(), regresaArea(),
regresaVolumen() y toString().
En la clase principal PruebaHerenciaAbstracta se instancias tres objetos, uno tipo Punto,
otro tipo Circulo y un tercero tipo Cilindro asignando los valores a las variables miembro
por medio de la invocación a los constructores alternativos. Se declara una variable tipo
String llamada salida en la cual se acumulan los datos que se mostrarán como resultados,
además se declara un arreglo de tipo Figuras que es ahí donde se realiza el polimorfismo,
debido a que soporta los métodos de cada uno de los objetos mostrando la ejecución de
cada método toString, regresaArea() y regresaVolumne().
 4.5. Interfaces.

4.5.1. Definición

El concepto de Interface lleva un paso más adelante la idea de las clases abstractas. En
Java una interface es una clase abstracta pura, es decir una clase donde todos los
métodos son abstractos (no se implementa ninguno). Permite al diseñador de clases
establecer la forma de una clase (nombres de métodos, listas de argumentos y tipos de
retorno, pero no bloques de código). Una interface puede también contener datos
miembro, pero estos son siempre static y final. Una interface sirve para establecer un
'protocolo' entre clases.

Para crear una interface, se utiliza la palabra clave interface en lugar de class. La
interface puede definirse public o sin modificador de acceso, y tiene el mismo significado
que para las clases. Todos los métodos que declara una interface son siempre public.

Para indicar que una clase implementa los métodos de una interface se utiliza la palabra
clave implements. El compilador se encargará de verificar que la clase efectivamente
declare e implemente todos los métodos de la interface. Una clase puede implementar
más de una interface.

4.5.2. Implementación.

Una interface se declara:

interface nombre_interface {
tipo_retorno nombre_metodo ( lista_argumentos ) ;
...
}

Por ejemplo:

interface InstrumentoMusical {
void tocar();
void afinar();
String tipoInstrumento();
}

Y una clase que implementa la interface:

class InstrumentoViento extends Object implements InstrumentoMusical {

void tocar() { . . . };
void afinar() { . . .};
String tipoInstrumento() {}
}

class Guitarra extends InstrumentoViento {

String tipoInstrumento() {
return "Guitarra";
}
}
La clase InstrumentoViento implementa la interface, declarando los métodos y escribiendo
el código correspondiente. Una clase derivada puede también redefinir si es necesario
alguno de los métodos de la interface.

Es posible crear referencias a interfaces, pero las interfaces no pueden ser instanciadas.
Una referencia a una interface puede ser asignada a cualquier objeto que implemente la
interface. Por ejemplo:

InstrumentoMusical instrumento = new Guitarra();

instrumento.play();
System.out.prinln(instrumento.tipoInstrumento());

InstrumentoMusical i2 = new InstrumentoMusical(); //error.No se puede instanciar

Extensión de interfaces

Las interfaces pueden extender otras interfaces y, a diferencia de las clases, una interface
puede extender más de una interface. La sintaxis es:

interface nombre_interface extends nombre_interface1, nombre_interface2,… {

tipo_retorno nombre_metodo ( lista_argumentos ) ;
…
}

Agrupaciones de constantes

Dado que, por definición, todos los datos miembros que se definen en una interface son
static y final, y dado que las interfaces no pueden instanciarse resulta una buena
herramienta para implantar grupos de constantes. Por ejemplo:

public interface Meses {

int ENERO = 1 , FEBRERO = 2 . . . ;
String [ ] NOMBRES_MESES = { " " , "Enero" , "Febrero" , . . . };
}

Esto puede usarse simplemente:

System.out.println(Meses.NOMBRES_MESES[ENERO]);

Ejercicio 4.3: Implemente la interfaz de Meses e imprime el mes de Enero como lo indica
la instrucción.

El ejemplo que se muestra a continuación es una simplificación de cómo funciona

realmente la gestión de eventos en el sistema gráfico de usuario soportado por el API de
Java (AWT o swing). Se han cambiado los nombres y se ha simplificado para mostrar un
caso real en que el uso de interfaces resuelve un problema concreto.

Supongamos que tenemos una clase que representa un botón de acción en un entorno
gráfico de usuario (el típico botón de confirmación de una acción o de cancelación). Esta
clase pertenecerá a una amplia jerarquía de clases y tendrá mecanismos complejos de
definición y uso que no son objeto del ejemplo. Sin embargo podríamos pensar que la
clase Boton tiene miembros como los siguientes.

class Boton extends . . . {

protected int x , y, ancho, alto; // posicion del boton
protected String texto; // texto del boton
Boton(. . .) {
...
}
void dibujar() { . . .}
public void asignarTexto(String t) { . . .}
public String obtenerTexto() { . . .)
...
}

Lo que aquí nos interesa es ver lo que sucede cuando el usuario, utilizando el ratón pulsa
sobre el botón. Supongamos que la clase Boton tiene un método, de nombre por ejemplo
click(), que es invocado por el gestor de ventanas cuando ha detectado que el usuario ha
pulsado el botón del ratón sobre él. El botón deberá realizar alguna acción como dibujarse
en posición 'pulsado' (si tiene efectos de tres dimensiones) y además, probablemente,
querrá informar a alguien de que se ha producido la acción del usuario. Es en este
mecanismo de 'notificación' donde entra el concepto de interface. Para ello definimos una
interface Oyente de la siguiente forma:

interface Oyente {
void botonPulsado(Boton b);
}

La interface define un único método botonPulsado. La idea es que este método sea
invocado por la clase Boton cuando el usuario pulse el botón. Para que esto sea posible
en algún momento hay que notificar al Boton quien es el Oyente que debe ser notificado.
La clase Boton quedaría:

class Boton extends . . . {

...
private Oyente oyente;
void registrarOyente(Oyente o) {
oyente = o;
}

void click() {
...
oyente.botonPulsado(this);
}
}

El método registrarOyente sirve para que alguien pueda 'apuntarse' como receptor de las
acciones del usuario. Obsérvese que existe una referencia de tipo Oyente. A Boton no le
importa que clase va a recibir su notificación. Simplemente le importa que implante la
interface Oyente para poder invocar el método botonPulsado. En el método click se
invoca este método. En el ejemplo se le pasa como parámetro una referencia al propio
objeto Boton. En la realidad lo que se pasa es un objeto 'Evento' con información
detallada de lo que ha ocurrido.

Con todo esto la clase que utiliza este mecanismo podría tener el siguiente aspecto:

class miAplicacion extends . . . implements Oyente {

public static main(String [] args) {
new miAplicacion(. . .);
...
}
...
miAplicacion(. . .) {
...
Boton b = new Boton(. . .);
b.registrarOyente(this);
}

...
void botonPulsado(Boton x) {
// procesar click
...
}
}

Obsérvese en el método registrarOyente que se pasa la referencia this que en el lado de

la clase Boton es recogido como una referencia a la interface Oyente. Esto es posible
porque la clase miAplicacion implementa la interface Oyente. En términos clásicos de
herencia miAplicacion ES un Oyente.

Ejercicio 4.4: Empleando intefaces implemente una calculadora que realice las
operaciones básicas de suma (+), resta (-), multiplicación (*) y división (/) de dos números
que se capturaren desde teclado y que tenga el siguiente diseño:

Analizando el diseño, tendremos que, por cada elemento se emplearán los siguientes
componentes de Java:
 Titulo de la ventana JTextField

JLabel

JButton
4.5.3. Variable polimórficas

En Java, las variables que contienen objetos son variables polimórficas. El término
polimórfico (literalmente: muchas formas) se refiere al hecho de que una misma variable
puede contener objetos de diferentes tipos (del tipo declarado o de cualquier subtipo del
tipo declarado). El polimorfismo aparece en los lenguajes orientados a objetos en
numerosos contextos, las variables polimórficas constituyen justamente un primer
ejemplo.

public class CD {
private String titulo;
private String artista;
private String comentario;

public CD() {
titulo = "Sin Titulo";
artista = "Sin Artista";
comentario = "";
}

public CD(String titulo, String artista, String comentario) {

this.titulo = titulo;
this.artista = artista;
this.comentario = comentario;
}

public String regresaTitulo() {

return titulo;
}

public void asignaTitulo(String titulo) {

this.titulo = titulo;
}
 public String regresaArtista() {
return artista;
}

public void asignaArtista(String artista) {

this.artista = artista;
}

public String regresaComentario() {

return comentario;
}

public void asignaComentario(String comentario) {

this.comentario = comentario;
}

public String toString() {

return "CD" + "\ntitulo=" + titulo +
"\nartista=" + artista +
"\ncomentario=" + comentario;
}

public class DVD {

private String titulo;
private String director;
private String comentario;

public DVD() {
titulo = "Sin Titulo";
director = "Sin Director";
comentario = "";
}

public DVD(String titulo, String director, String comentario) {

this.titulo = titulo;
this.director = director;
this.comentario = comentario;
}

public String regresaTitulo() {

return titulo;
}

public void asignaTitulo(String titulo) {

this.titulo = titulo;
}

public String regresaDirector() {

return director;
}

public void asignaArtista(String director) {

this.director = director;
}
 public String regresaComentario() {
return comentario;
}

public void asignaComentario(String comentario) {

this.comentario = comentario;
}

public String toString() {

return "DVD" + "\ntitulo=" + titulo +
"\ndirector=" + director +
"\ncomentario=" + comentario;
}

public class Ejemplo_Opticos {

public static void main(String[] args) {
CD ObjetoCD =
new CD("Def Jam Recordings", "Justin Bieber", "Bueno");
DVD ObjetoDVD =
new DVD("The Revenant", "Alejandro González Iñárritu", "Excelente");

Object ObjetoX;

ObjetoX = ObjetoCD;
System.out.println(ObjetoX);
ObjetoX = ObjetoDVD;
System.out.println(ObjetoX);

4.6. Reutilización de la definición de paquetes/librerías

Un paquete en Java es lo que su nombre lo indica, un paquete o conjunto de clases,

lógicamente, que tienen cosas en común. Lógicamente un programado puede agruparlas
con o sin criterio, pero lo ideal es que se dediquen a funciones específicas. También los
paquetes definen una jerarquía de directorios, que permiten igualmente agrupas las
clases, cosa de desplegar los archivos mas ordenadamente. También, cuando
necesitamos librerías de java, igualmente estamos llamando a una clase específica o a
todo un paquete. Por ejemplo, cuando ponemos esto:

import System.io.*;

Estamos importando todas las clases del paquete System.io. Ahora, si hacemos esto:

import javax.swing.JOptionPane;

Estamos importando la clase JOptionPane del paquete javax.swing.

Para definir un paquete solo tenemos que incluir antes que los paquetes a importar, la
definición del paquete al que pertenece la clase, de la forma siguiente:
package org.ruta.del.paquete;

Producto de Aprendizaje 4:

1. El Instituto tecnológico de Aguascalientes desea un programa que controle a

sus Estudiantes de Licenciatura, Maestría y Doctorado. Los estudiaantes de
Licenciatura tiene los Atributos: Nombre, Domicilio, Teléfono, Edad,
Especialidad y Promedio, mientras que los estudiantes de Maestría tiene los
siguientes variables miembro: Nombre, Domicilio, Teléfono, Edad,
Investigación Maestría y Fecha de entrega. Los estudiantes de Doctorado
tiene las siguientes variables: Nombre, Domicilio, Teléfono, Edad, Proyecto
de Doctorado y Monto de la Investigación. Modele las clases empleando
herencia. Además elabore un programa en Java que implemente las clases e
instancie un objeto de cada una, capturando los datos desde teclado.

2. Modifique el ejercicio 4.4 agregando las operaciones de seno, coseno,

tangente, √x, x 𝑛 , 1⁄𝑛, x! y CE; y darle el nombre de Calculadora Científica.
𝑛
5. Arreglos

Los arreglos se pueden definir como objetos en los que podemos guardar más de un
valor, es decir, al tener una estructura organizada en un arreglo se puede guardar
múltiples valores de acuerdo a su tamaño o capacidad, es importante recordar que los
valores a guardar deben ser del mismo tipo, por ejemplo: Si tenemos un arreglo de tipo
Numérico que puede almacenar 10 valores, solo podrá almacenar 10 números diferentes,
no otros tipos de valores como podrían ser datos tipo String, char, boolean, etc.

5.1. Unidimensional

Los arreglos de una unidimensionales (también llamados vector o tablas), son estructuras
de datos de una sola dimensión (de ahí viene su nombre). Un arreglo unidimensional está
constituido por una secuencia de objetos del mismo tipo. A los objetos se les llama
elementos del arreglo y se enumeran del 0 al n-1.

En la siguiente figura se muestra un arreglo llamado Numero, que contiene 5 elementos

(longitud igual a 5), enumerados del 0 a 4.

Numero
0 10
1 15
2 25
3 50
4 21

Operaciones.

Las operaciones básicas sobre un arreglo unidimensional son:

 Declaración del arreglo,

 Creación del arreglo,
 Inicialización de los elementos del arreglo, y
 Acceso a los elementos del arreglo.

Declaración del arreglo

La declaración de un arreglo unidimensional consiste en establecer las características del

arreglo y sus elementos, por medio de la siguiente sintaxis:
Al igual que con cualquier variable en Java, los arreglos se deben declarar antes de ser
utilizados.
 Tipo [ ] identificador ;

Tipo identificador [ ] ;

Donde el Tipo, corresponde al tipo de dato del arreglo, el cual pude ser cualquiera de los
8 básicos de Java o de alguna clase.

Los corchetes pueden colocarse de dos formas:

o Los corchetes colocados después del tipo de dato, esto indica que todos los
identificadores son arreglos.
o Los corchetes colocados después del identificador, indica que solo el
identificador que tenga los corchetes es un arreglo.

Identificador: Es el nombre del Arreglo.

Ejemplo:

int enteros[ ], x, y; enteros en un arreglos unidimensional de tipo int, x y

y son variables tipo int.
float [ ] cal1, cal2, cal3, prom; cal1, cal2, cal3 y prom son arreglos
unidimensionales.

char [ ] letra1, letra2[ ], letra3; letra1 y letra3 son arreglos de una dimensión del
tipo char y mientras que letra2 es una arreglo de
arreglos de tipo char (es decir una matriz).

Creación del arreglo

Esto solo está declarando el nombre del arreglo y el tipo de datos que se van a almacenar
(a esto se le llama también referencia), para declarar el número de elementos del arreglo,
se realiza por medio del operador new.
Ejemplo:

float [ ] CalificacionFinal;
CalificacionFinal = new float [45];
La primera sentencia declara un arreglo unidimensional llamado CalificacionFinal que
manejara tipos de datos float. La segunda sentencia declara que tendrá 45 elementos
(enumerado del 0 al 44). Otra forma de hacer la declaración del arreglo, así como de sus
elementos es:

float [ ] CalificacionFinal = new float [45];

Acceso a los elementos del arreglo

Para almacenar datos en un arreglo basta con poner el nombre del arreglo, el subíndice
(encerredo entre corchetes), el símbolo igual, la expresión que se quiere almacenar y
finalmente punto y coma.
CalificacionFinal[5] = 70;
System.out.println(“La Calificación Final 6 es: “ + CalificacionFinal[5]);

Ejercicio 5.1: El siguiente programa declara un arreglo de 6 elementos llamado Nombres.

Posteriormente por medio de una instrucción for captura las cadena de y asigna los datos
capturados a cada elemento del arreglo y finalmente por medio una instrucción while
despliega el contenido cada elemento del arreglo Nombres.
Ejercicio 5.2: El programa declara un arreglo de 10 elementos llamado Valores.
Posteriormente por medio del método random() de la clase Math y utilizando una
instrucción for carga de manera automática cada elemento del el arreglo. Finalmente
despliega el contenido del arreglo por medio de una instrucción do while.

Ejercicio 5.3: Elabore un programa que lea de teclado 10 calificaciones numéricas entre
0 a 100, posteriormente imprima cada calificación con su correspondiente Nota en base a
la siguiente tabla:

Límite
Nota
Inferior Superior
93 100 A+
90 92 A-
87 89 B+
83 86 B-
80 82 C+
77 79 C-
73 76 D+
70 72 D-
0 69 F
Ejercicio 5.4: Elabore un programa que genere declare y cargue de forma aleatoria un
arreglos de 100 elementos y posteriormente calcule e imprima el rango (valor mayor
menos valor menor).

Inicialización de de los elementos del arreglo

Otra forma de introducir datos en un arreglos es inicializándolo desde la declaración.

Numero
0 10
1 15
int numero[] = {10, 15, 25, 50, 21};
2 25
3 50
4 21
Tamaño de los arreglos (length)

Java considera cada arreglo un objeto, debido a ello se pude conocer el número de
elementos de un arreglo por medio del campo length.

Por ejemplo con la siguiente instrucción imprime “La longitud es 5”.

System.out.println(“La longitud es “ + numero.length);

Ejercicio 5.5: El siguiente ejemplo declara un arreglo de 10 elementos llamado enteros, y

le asigna datos desde la declaración. Posteriormente por medio de un ciclo for recorre los
elementos del arreglo y determina el elemento menor y mayor; al final los imprime.
Ejercicio 5.6: Como se ha venido diciendo los arreglos son referencias, y podemos tener
dos variables apuntando a un mismo arreglo.

Instrucción for mejorada

En los ejemplos anteriores demostramos cómo las instrucciones for controladas por un
contador intera a través de los elementos del arreglo. Ahora veremos la instrucción for
mejorada, la cual itera a través de los elementos de un arreglo o colección sin utilizar un
contador.

Sintaxis de la instrucción for mejorada:

for(parámetro: nombreArreglo)
Instrucción;

Donde parámetro tiene dos partes: un tipo y un identificador (por ejemplo int valor), y
nombreArreglo es el arreglo a través del cual se iterará. El tipo del parámetro debe
concordar con el tipo de los elementos en el arreglo.
Ejercicio 5.7: Muestra el contenido el arreglo numero utilizando el for mejorado.

Método de ordenamiento por Burbuja:

La Ordenación de burbuja (Bubble Sort en inglés) es un sencillo algoritmo de

ordenamiento. Funciona revisando cada elemento de la lista que va a ser ordenada con el
siguiente, intercambiándolos de posición si están en el orden equivocado. Es necesario
revisar varias veces toda la lista hasta que no se necesiten más intercambios, lo cual
significa que la lista está ordenada. Este algoritmo obtiene su nombre de la forma con la
que suben por la lista los elementos durante los intercambios, como si fueran pequeñas
"burbujas". También es conocido como el método del intercambio directo. Dado que solo
usa comparaciones para operar elementos, se lo considera un algoritmo de comparación,
siendo el más sencillo de implementar.

Algoritmo:

Realiza
Movimientos = 0
Para I=0 hasta Arreglo.longitud – 1
Si Arreglo[I+1] < Arreglo[I]
Arreglo[I] <-> Arreglo[I+1] // Intercambiar
Movimiento++
Fin_Si
Fin_para
Mientras (Movimiento != 0)
Dónde:

El símbolo <-> Significa intercambio, es decir el valor que se encuentra en Arreglo[I] se

intercambia a Arreglo[I+1] y el valor que está en Arreglo[I+1] se intercambia e la posición
Arreglo[I].

Ejemplo: Se tiene el siguiente arreglo cargado con los datos:

Ejercicio 5.8: Elabore un programa en Java que genere 10 números aleatorios (entre 100
y 999), ordénelos en forma ascendente mediante el método de la burbuja y presente los
datos como se muestra en la siguiente figura.

Método de ordenamiento por Selección

Los métodos de ordenación por selección se basan en dos principios básicos:

Seleccionar el elemento más pequeño (o más grande) del arreglo. Colocarlo en la

posición más baja (o más alta) del arreglo. A diferencia del método de la burbuja, en este
método el elemento más pequeño (o más grande) es el que se coloca en la posición final
que le corresponde.

Algoritmo:

Para I=0 hasta Arreglo.longitud – 1

Para J= I+1 hasta Arreglo.longitud
Si Arreglo[J] < Arreglo[I]
Arreglo[I] <-> Arreglo[I+1] // Intercambiar
Fin_Si
Fin_para
Fin_para
Ejercicio 5.9: Elabore un programa en Java que genere 10 números aleatorios (entre 100
y 999), ordénelos en forma ascendente mediante el método selección y presente los datos
como se muestra en la siguiente figura.

5.2. Multidimensionales

Los arreglos vistos anteriormente se conocen como arreglos unidimensionales y se

caracterizan por tener un solo subíndice. Los arreglos multidimensionales son aquellos
que tienen más de una dimensión y, en consecuencia, más de un índice (o subíndice).
Los arreglos más usuales son los de dos dimensiones, conocidos como matrices.

Un arreglo de dos dimensiones equivale a una tabla con filas y columnas:

n 0 1 2 3
0
1
2
3
4

Operaciones.

Las operaciones básicas sobre un arreglo bidimensional son:

 Declaración del arreglo,

 Creación del arreglo,
 Inicialización de los elementos del arreglo, y
 Acceso a los elementos del arreglo.
Declaración de arreglos bidimensionales (matriz)

Tipo [ ] [ ] identificador ;

Tipo identificador [ ] [ ] ;

,
Ejemplo:

int puestos[ ][ ], x, y; puestos en un arreglos de dos dimensiones del tipo

int, x y y son variables tipo int.

float [ ][ ] cal1, cal2, cal3, prom; cal1, cal2, cal3 y prom son arreglos
bidimensionales.

Creación del arreglo

Como ya se mencionó estas declaraciones son simplemente referencias, para declarar el

número de elementos del arreglo se hace por medio del operador new.
Ejemplo:

float [ ][ ] Calificaciones;
Calificaciones = new float [45][4];

La primera sentencia declara un arreglo Calificaciones que manejara tipos de datos float.
La segunda sentencia crea el arreglo e indica que manejara 45 filas (del 0 al 44) y 4
columnas (del 0 al 3). Otra forma de hacer la declaración y creación del arreglo es:

float [ ][ ] Calificaciones = new float [45][3];

Inicialización de los elementos del arreglo

Al igual que los arreglos unidimensionales, los arreglos multidimensionales se pueden

inicializar desde la declaración.
Ejemplo:

int tabla1[][] = { {51, 24, 33}, {32, 23, 45} };

Se define una matriz de 2 filas por 3 columnas

También se puede utilizar otros formatos como los siguientes:

int tabla1[ ][ ] = { {51, 24, 33},

{32, 23, 45} }

tabla1[ ][ ]
int tabla1[ ][ ] = { 0 1 2
{51, 24, 33},
{32, 23, 45} 0 51 24 33
};
1 32 23 45

int tabla2[ ][ ] = { tabla2[ ][ ]

{ 1, 2, 3, 4},
{ 5, 6, 7, 8}, 0 1 2 3
{ 9, 10, 11, 12} 0 1 2 3 4
};
1 5 6 7 8
2 9 10 11 12

Java trata los arreglos de dos o más dimensiones como un arreglo de arreglos, por tanto
puede crear arreglos no proporcionales.

Por ejemplo:

a) double datos[ ][ ] = { {1.5, -2.5}, {5.0, 0.0, 1.5} };

Se ha creado un arreglo con dos filas, la 1ª con dos columnas y la 2ª. con 3.

b) int [ ] a = { 1, 3, 5 }, b = { 2, 4, 6, 8, 10 };
int z[ ][ ] = { a, b };

Primero se definió el arreglo a con 3 elementos y después el arreglos b con 5 elementos,

posteriormente se define la matriz z con dos filas, la primera con 3 elementos (los del
arreglo a) y la segunda con 5 elementos (los del arreglo b).

Método length con los arreglos bidimensionales

Para saber la longitud de la última dimensión se debe especificar los subíndices

precedentes,

Ejercicio 5.10: Para el siguiente ejemplo se declara una matriz f no proporcional, donde
el primer subíndice tiene 4 elementos, el segundo 2 y el último 6.
Acceso a los elementos del arreglo bidimensional

Por ejemplo si tenemos la siguiente matriz:

int [ ][ ] a = new int [3][4];

a
Columna 0 Columna 1 Columna 2 Columna 3
Fila 0 a[0][0] a[0][1] a[0][2] a[0][3]
Fila 1 a[1][0] a[1][1] a[1][2] a[1][3]
Fila 2 a[2][0] a[2][1] a[2][2] a[2][3]
Índice de la columna
Índice de la fila
Nombre del arreglo

Para almacenar datos en una matriz basta con poner el nombre del arreglo, el subíndice
de las filas y el subíndice de las columnas, el símbolo igual y la expresión que se quiere
almacenar y finalmente después punto y coma. Por ejemplo:

a[1][3] = Expresión;

Ejercicio 5.11: El siguiente programa lee una matriz de enteros de n renglones y m

columnas y calcule la suma de los elementos de cada renglón.
Ejercicio 5.12: Elabore un programa que declare y cargue en forma aleatoria una matriz
de 5 por 5 y obetenga la suma los elementos de la diagonal principal e imprime el
resultado.

x
x
x
x
x

Ejercicio 5.13: Elabore un programa que declare y carga en forma aleatoria una matriz de
6 por 6 y obtienga el producto de la diagonal invertida e imprime el resultado

O
O
O
O
O
O

Ejercicio 5.14: Elabore un programa que lea una matriz de n X m y la escriba poniendo
las columnas como renglones y los renglones como columnas.

Por ejemplo, si la matriz que da el usuario es:

4 7 1 3 5
2 0 6 9 7
3 1 2 6 4

Entonces el programa debe escribir la matriz transpuesta:

4 2 3
7 0 1
1 6 2
3 9 6
5 7 4

Multidimensionales.

Java proporciona la probabilidad de almacenar varias dimensiones, aunque raramente los

problemas del mundo real se manejan más tres dimensiones, esto porque para los seres
humanos es difícil representar gráficamente arreglos con más de tres dimensiones. Para
representar un arreglo de tres dimensiones lo haremos por medio de un cubo.
int cubo [ ][ ][ ] = new int [4][5][3];
 3

y
4
z
x
5

Operaciones.

Las operaciones básicas sobre un arreglo bidimensional son:

 Declaración del arreglo,

 Creación del arreglo,
 Inicialización de los elementos del arreglo, y
 Acceso a los elementos del arreglo.

Declaración de arreglos multidimensional

Para el siguiente ejemplo se tomara un arreglo de tres dimensiones

Tipo [ ] [ ] [ ] identificador ;

Tipo identificador [ ] [ ] [ ] ;

Ejemplo:

int cubo[ ][ ]; cubo en un arreglos de tres dimensiones del tipo int.

String [ ][ ][ ] Edificio1, Edificio2; Edificio1 y Edificio2 son arreglos

multidimensionales de 3 dimensiones.
Creación del arreglo

Como ya se mencionó estas declaraciones son simplemente referencias, para declarar el

número de elementos del arreglo se hace por medio del operador new.
Ejemplo:

int cubo[ ][ ][ ];
cubo = new int [5][4][3];

La primera sentencia declara un arreglo de tres dimensiones llamado cubo que manejara
tipos de datos int. La segunda sentencia crea el arreglo e indica que manejara 5 filas, con
4 columnas y 3 de profundidad. Otra forma de hacer la declaración y creación del arreglo
es:

int [ ][ ] [ ] cubo = new int [5][4][3];

Almacenar datos en el arreglo multidimensional:

Al igual que en los anteriores arreglos, se deben poner los subíndices al cual se quiere
acceder y posteriormente la expresión a asignar.

cubo[2][3][1] = 15;

Clases para el manejo de arreglos.

La clase Arrays proporciona métodos estáticos para manipular arreglos. Esta clase
maneja arreglos a alto nivel, como los métodos: sort para ordenar arreglos, binarySearch
para buscar en un arreglo ordenado, equals para comparar arreglos y fill guardar valores
en todos los elementos de un arreglo.

Métodos Descripción

static int binarySearch(char[ ] a, char bu) Busca en el arreglo a el elemento bus y

static int binarySearch(double[ ] a, double bus)
static int binarySearch(float[ ] a, float bus)
static int binarySearch(int[ ] a, int bus)
static int binarySearch(Object[ ] a, Object bus)
regresa la posición donde lo encontró, si
regresa -1 es que no fue localizado. El
arreglo debe estar ordenado.

static boolean equals(char[ ] a, char[ ] a2)

static boolean equals(double[ ] a, double[ ] a2)
Regresa true si los dos arreglos son
static boolean equals(float[ ] a, float[ ] a2
static boolean equals(int[ ] a, int[ ] a2) iguales uno a uno y false en caso contrario.
static boolean equals(Objeto[ ] a, Object[ ] a2)

static void fill(boolean[ ] a, boolean val)

static void fill(char[ ] a, char val)
static void fill(double[ ] a, double val) A cada elemento del arreglo le asigna el
static void fill(float[ ] a, float val) val.
static void fill(int[ ] a, int val)
static void fill(Object[ ] a, Object val)
 Métodos Descripción

static void sort(char[ ] a)

static void sort(double[ ] a)
Ordena ascendentemente el arreglo
static void sort(float[ ] a)
static void sort(int[ ] a) especificado.
static void sort(Object[ ] a)

static void sort(char[ ] a, int inicio, int fin)

static void sort(double[ ] a, int inicio, int fin)
Ordena ascendentemente de inicio a fin el
static void sort(float[ ] a, int inicio, int fin)
static void sort(int[ ] a, int inicio, int fin) arreglo especificado.
static void sort(Object[ ] a, int inicio, int fin)

Producto de Aprendizaje 5:

1. Elabore un programa en Java que declare y cargue una arreglos con 1000
elementos enteros de forma aleatoria (los valores deben de estar entre 100 y 999),
ordénelo ascendentemente mediante el método de la burbuja y selección,
contabilizando el número de movimientos por cada método y presente los resultados
y determine que método es mejor en base al menor número de movimientos.

Método de la Burbuja: 99999 movimientos

Método Selección: 99999 movimientos
El mejor método de ordenación fue XXXXXX debido a que tuvo menor número de
movimientos.

2. Elabore un programa que lea los nombres y tres calificaciones de los alumnos de la
materia Programación Orientada a Objetos (20 Alumnos). Para cada alumno calcule
el promedio, el promedio general de la materia e imprima en pantalla el nombre,
calificaciones, promedio de todos los alumnos y al final despliegue cuantos
aprobaron, reprobaron y el promedio general.

Nombre Cal 1 Cal 2 Cal 3 Promedio

xxxxxxxx 99 99 99 99
xxxxxxxx 99 99 99 66
xxxxxxxx 99 99 99 77
xxxxxxxx 99 99 99 88
xxxxxxxx 99 99 99 55

Aprobados: 99
Reprobados: 99
Promedio general: 99
3. El “cuadro mágico”.

Un cuadrado mágico es una matriz cuadrada con un número impar de renglones y

columnas. En dicha matriz, los números de cada renglón, de cada columna y de
cada una de las diagonales, suman el mismo valor. Por ejemplo:

6 1 8
7 5 3
2 9 4

Note que los números de todos los renglones, columnas y diagonales suman 15.
Una técnica a través de la cual se puede generar un cuadrado mágico es la
siguiente:

a) Se comienza asignando un valor de 1 al elemento central de la primera fila.

b) A continuación se escriben los valores sucesivos (2,3, etc.) desplazándose
desde la posición actual una fila hacia arriba y una columna hacia la
izquierda. Estos cambios se realizan tratando a la matriz como si fuera
circular, de forma que moverse una posición hacia arriba desde la fila
superior lleva a la inferior, y moverse una posición hacia la izquierda desde
la primera columna conduce a la última.
c) Si la nueva posición ya está ocupada, en lugar de desplazarse hacia arriba
y a la izquierda, se moverá sólo una posición hacia abajo.

Escriba un programa que muestre un cuadro mágico de dimensión n, donde n

puede estar entre los valores 3, 5, 7 y 9.

4. Elabore un programa para controlar los asientos de un teatro el cual consta de tres
niveles, cada nivel tiene 50 filas y cada fila tiene 35 butacas. Debe de controlar si la
butaca está ocupada o disponible.
6. Archivos

El almacenar datos en variables o arreglos es temporal; los datos se pierden cuando una
variable local queda fuera de alance o cuando el programa termina su ejecución. Los
archivos son utilizados para la retención a largo plazo de grandes cantidades de datos.
Los datos almacenados en archivo existen más allá de la duración de un programa. Los
archivos se almacenan en memoria secundaria (discos magnéticos, discos ópticos, USB,
etc.).

Un flujo (stream) es una abstracción que se refiere a un flujo o corriente de datos que
fluye entre un origen o fuente hacia un destino. Entre el origen y el destino debe de existir
una conexión o canal por donde circulen los datos. Al abrir un archivo se crean
automáticamente tres objetos flujo o canales. Estos objetos están definidos en la clase
System y son:

System.in Objeto de entrada estándar; permite la entrada desde teclado.

System.out Objeto de salida estándar, permite la salida de datos a pantalla.
System.err Objeto de salida a errores estándar, envía los errores a pantalla.

Estos tres objetos se crean al comenzar la ejecución de un programa y sirven para

administrar la secuencia de caracteres en modo texto.

En Java, un archivo es, un flujo externo o secuencia de bytes almacenada en un

dispositivo externo (generalmente disco). Si el archivo se abre de lectura o escritura el
flujo será de entrada o salida, respectivamente. El paquete java.io agrupa el conjunto de
clases para el manejo de entrada y salida; siempre que vaya a procesar un archivo se
tiene que utilizar este paquete, por lo que debe importarlo.

Los flujos de datos se clasificar en flujos de entrada (InputStream) y flujos de salida

(OutputStream). Por ello Java declara dos clases que derivan directamente de la clase
Object: InputStream y OutputStream. Ambas son clases abstractas que declaran métodos
que deben redefinirse en sus clases derivadas. Además InputStream es la clase base de
todas las clases definidas para stream de entrada, y OutputStream es la clase base de
todas las clases de stream de salida.

InputStream OutputStream
FileInputStream FileOutputStream
ByteArrayInputStream ByteArrayOutputStream
PipeInputStream PipeOutputStream
SequenceInputStream FilterOutputStream
StringBufferInputStream
FilterInputStream

6.1. Definición de Archivos de texto y archivos binarios.

El elemento más pequeño de almacenamiento es un bit (binary digit/dígito binario), que

está representado por un 0 (cero) o un 1 (uno). Las computadoras procesan los datos en
forma binaria y al formar conjunto de bit representa un carácter, los caracteres de Java
son caracteres Unicode, compuestos por dos bytes, cada byte está compuesto por ocho
bits. Así como los caracteres están formados por bits, los campos están formados por un
conjunto de caracteres y por lo general un conjunto de campos forman un registro.

Sandra Ruíz Roma # 100

Tomas Pérez Sol # 120
Archivo
Julia Ramos Nayarit # 320
Ramiro Esparza Pera # 240

Julia Ramos Nayarit # 320 Registro

Julia Campo

01001010 Byte (Carácter ASCII de la J)

1 Bit

Ejemplo: Establezca el registro de una empresa para sus empleados.

Archivo de texto: Un archivo de texto o archivo de texto simple es un archivo

informático compuesto únicamente por texto sin formato, sólo caracteres, lo que lo hace
también legible por humanos. En texto que contienen estos archivos carecen de
propiedades es decir no tienen negritas, subrayado, cursiva, tamaño, tipo de letra, etc.,
también es llamada archivo de texto plano, este término proviene de la traducción literal
en ingles de Plain Text.

Archivo binario: Un archivo binario es un archivo informático que contiene

información de cualquier tipo codificada en binario para el propósito de almacenamiento y
procesamiento mediante una computadora. Por ejemplo los archivos informáticos que
almacenan texto formateado o fotografías, así como los archivos ejecutables que
contienen programas.

Operaciones básicas en archivos texto y binario.

Las operaciones básicas con archivos son:

 Creación
 Apertura
 Lectura
 Escritura
 Recorrido
 Cierre
Con la clase FileOutputStream se pueden escribir bytes en un flujo de salida asociado a
un archivo.

Métodos Descripción

Crea un Objeto FileOutputStream que

FileOutputStream(String nombre) throws
escribe el archivo con el nombre
IOException
especificado.

Crea un Objeto FileOutputStream que

FileOutputStream(File nombre) throws
escribe el archivo administrado por el
IOException
Objeto File especificado.

Crea un Objeto FileOutputStream que

FileOutputStream(String nombre, boolean escribe el archivo con el nombre
sw) throws IOException especificado. En caso de que sw = true los
bytes se agregan al final del archivo.

Crea un Objeto FileOutputStream que

escribe el archivo administrado por el
FileOutputStream(File nombre, boolean sw)
Objeto File especificado. En caso de que
throws IOException
sw = true los bytes se agregan al final del
archivo.

Crea un Objeto FileOutputStream que

FileOutputStream(FileDescriptor nombre)
escribe el archivo referido por el objeto
throws IOException
FileDescriptor especificado.

void close() throws IOException Cierra el archivo.

void write() throws IOException Escribe un solo byte en el flujo del archivo.

Escribe todos los bytes de b en el flujo del

void write(byte b[]) throws IOException
archivo.

Escribe len bytes en el flujo del archivo

void write(byte b[], int pos, int len) throws
comenzando de la posición pos dentro de
IOException
b.

Ejercicio 6.1: El siguiente programa solicita el nombre de un archivo, posteriormente se

teclean varias líneas, las cuales se agregan a el archivo y hasta que se teclea la palabra
“fin” termina la ejecución.
import java.io.*;
import javax.swing.JOptionPane;

public class Ejercicio_6_1 {

public static void main( String args[] ) {
String nombreArchivo, linea;
nombreArchivo = JOptionPane.showInputDialog(
"Dame el nombre del archivo:" );
try {
FileOutputStream archivoLogico = archivoLogico =
new FileOutputStream(nombreArchivo);
linea = JOptionPane.showInputDialog(
"Tecleea una Linea o \"fin\" para salir" );
while (!linea.equals("fin")) {
archivoLogico.write(linea.getBytes());
archivoLogico.write( (byte) '\n');
linea = JOptionPane.showInputDialog(
"Tecleea una Linea o \"fin\" para salir"
);
}
archivoLogico.close();
}
catch (IOException e) {
JOptionPane.showMessageDialog( null,"Error en el flujo" +
e );
}
System.exit( 0 );
}

}
Abrir.

La clase FileInputStream se utiliza para leer bytes desde un archivo. Proporciona

operaciones básicas para leer una byte o una secuencia de bytes.

Métodos Descripción

FileInputStream(String nombre) throws Crea un Objeto FileInputStream que lee el

FileNotFoundException archivo con el nombre especificado.

Métodos Descripción

Crea un Objeto FileInputStream que lee el

FileInputStream(File nombre) throws
archivo físico administrado por el objeto
FileNotFoundException
File especificado.

Crea un Objeto FileInputStream que lee el

FileInputStream(FileDescriptor nombre)
archivo referido por el objeto FileDescriptor
throws FileNotFoundException
especificado.

Regresa el número de bytes que pueden

int available() throws IOException
ser leídos en el archivo.

void close() throws IOException Cierra el archivo.

Lee y regresa un solo byte del flujo.

int read() throws IOException Regresa el valor -1 si llega al final del
archivo.

Lee una secuencia de bytes y los almacena

int read(byte b[]) throws IOException en el arreglo b. Regresa -1 si llega al final
del archivo.

Lee como máximo len bytes y los coloca en

int read(byte b[], int pos, int len) throws
la posición pos dentro de b. Regresa -1 si
IOException
llega al final del archivo.

long skip(long n) throws IOException Salta n bytes del flujo.

Ejercicio 6.2: El siguiente programa solicita el nombre de un archivo texto y despliega en

pantalla su contenido.
import java.io.*;
import javax.swing.JOptionPane;

public class Ejercicio_6_2 {

public static void main( String args[]) {
int c;
String nombreArchivo, salida = "";
nombreArchivo = JOptionPane.showInputDialog(
"Dame el nombre del archivo:");
try {
FileInputStream archivoLogico =
new FileInputStream(nombreArchivo);
while ((c = archivoLogico.read()) != -1)
salida += (char) c;
JOptionPane.showMessageDialog( null, salida,
"Contenido del archivo:" +
nombreArchivo, JOptionPane.PLAIN_MESSAGE);
archivoLogico.close();
}
catch (IOException e) {
JOptionPane.showMessageDialog( null,"Error en el flujo"
+ e );
}
System.exit( 0 );
}

Cerrar.

Cada vez que habrá un archivo tendrá que cerrarlo por medio del método close() de la
siguiente forma:

nombreDeArchivo.close();

Lectura y escritura.

Ejercicio 6.3: Ahora modificaremos el Ejercicio 8.1 para que añada texto al final del
archivo y muestre su contenido.
import java.io.*;
import javax.swing.JOptionPane;

public class Ejercicio_6_3 {

public static void main( String args[]) {
String nombreArchivo, linea, salida = "";
int c;
nombreArchivo = JOptionPane.showInputDialog(
"Dame el nombre del archivo:");
try {
FileOutputStream archivoSalida =
new FileOutputStream(nombreArchivo, true);
linea = JOptionPane.showInputDialog(
"Tecleea una Linea o \"fin\" para salir");
while (!linea.equals("fin")) {
linea += "\n";
archivoSalida.write(linea.getBytes());
linea = JOptionPane.showInputDialog(
"Tecleea una Linea o \"fin\" para salir");
}
archivoSalida.close();
FileInputStream archivoEntrada =
new FileInputStream(nombreArchivo);
while ((c = archivoEntrada.read()) != -1)
salida += (char) c;
JOptionPane.showMessageDialog( null, salida,
"Contenido del archivo:" + nombreArchivo,
JOptionPane.PLAIN_MESSAGE);
archivoEntrada.close();
}
catch (IOException e) {
JOptionPane.showMessageDialog( null,"Error en el flujo"
+ e );
}
System.exit( 0 );
}
}
 6.2. Operaciones básicas en archivos texto y binario.

Archivo binario

Ejercicio 6.4: El siguiente programa creará un archivo binario, el cual almacenara

registros de Estudiantes, para ello se declara una clase llamada Registro la cual contiene
los campos de Número de control, Nombre del estudiante, tres calificaciones y el
promedio. En la clase principal solicita el nombre del archivo, instanciando una variable
tipo FileOutputStream y posteriormente instancia un objeto tipo DataOutputStream para
crear un flujo de salida de datos. Utiliza dos métodos uno para leer los datos y otro para
escribir los datos en el archivos.

import java.io.*;
import javax.swing.JOptionPane;

class Registro {
public String nControl;
public String nombre;
public byte cal1;
public byte cal2;
public byte cal3;
public byte promedio;
}
public class Ejercicio_6_4 {

public static void main( String args[] ) {

int opcion = 0;
Object[] options = { "Si", "No" };
Registro reg = new Registro();
String nombreArchivo;
nombreArchivo = JOptionPane.showInputDialog
("Dame el nombre del archivo:");

try {
FileOutputStream archivo =
new FileOutputStream(nombreArchivo);
DataOutputStream salida = new DataOutputStream(archivo);
while (opcion == 0) {
leerDatos(reg);
escribirDatos(salida, reg);
opcion = JOptionPane.showOptionDialog(null,
"Dar de alta otro Alumno", "Otra alta",
 JOptionPane.DEFAULT_OPTION,
JOptionPane.QUESTION_MESSAGE,
null, options, options[0]);
}
archivo.close();
}
catch (IOException e) {
JOptionPane.showMessageDialog( null,"Error en el flujo" +
e );
}
System.exit( 0 );
}
static void leerDatos(Registro r) {
r.nControl = JOptionPane.showInputDialog("No. de
control:");
r.nombre = JOptionPane.showInputDialog("Nombre:");
r.cal1 =
Byte.parseByte(JOptionPane.showInputDialog("Calificación 1:"));
r.cal2 =
Byte.parseByte(JOptionPane.showInputDialog("Calificación 2:"));
r.cal3 =
Byte.parseByte(JOptionPane.showInputDialog("Calificación 3:"));
r.promedio = (byte) ((r.cal1 + r.cal2 + r.cal3)/3);
}

static void escribirDatos(DataOutputStream f, Registro r) {

try {
f.writeUTF(r.nControl);
f.writeUTF(r.nombre);
f.writeByte(r.cal1);
f.writeByte(r.cal2);
f.writeByte(r.cal3);
f.writeByte(r.promedio);
}
catch (IOException io) {
JOptionPane.showMessageDialog( null,"Error de
escritura" + io );
}
}
}
Recorrer.

Al recorrer un archivo tipo texto, la salida se establece cuando se lee un dato -1. En el
caso de los archivos binarios se establece por medio de una excepción, al ocurrir la
excepción se establece un falso para dejar de realizar el recorrido, como se muestra en el
siguiente ejercicio.

Ejercicio 6.5: El siguiente programa muestra el contenido del archivo binario creado por
medio del Ejercicio 6.4. Dado que el archivo es binario, se tiene que declarar la estructura
del Registro. En la clase principal solicita el nombre del archivo, instanciando una variable
tipo FileInputStream y posteriormente instancia un objeto tipo DataInputStream para crear
un flujo de entrada de datos.
import java.io.*;
import javax.swing.JOptionPane;

class Registro {
public String nControl;
public String nombre;
public byte cal1;
public byte cal2;
public byte cal3;
public byte promedio;
}

public class Ejercicio_6_5 {

public static void main( String args[] ) {
String salida = new String("");
Registro reg = new Registro();
String nombreArchivo;
boolean otro = true;
nombreArchivo = JOptionPane.showInputDialog
("Dame el nombre del archivo:");
try {
FileInputStream archivo =
new FileInputStream(nombreArchivo);
DataInputStream entrada = new DataInputStream(archivo);
while (otro) {
try {
reg.nControl = entrada.readUTF();
reg.nombre = entrada.readUTF();
reg.cal1 = entrada.readByte();
reg.cal2 = entrada.readByte();
reg.cal3 = entrada.readByte();
reg.promedio = entrada.readByte();
salida += "No. Control:" + reg.nControl + "
" +
"Nombre:" + reg.nombre + "
" +
"Cal 1:" + reg.cal1 + "
" +
"Cal 2:" + reg.cal2 + "
" +
"Cal 3:" + reg.cal3 + "
" +
"Promedio:" + reg.promedio +
"\n";
}
catch (IOException io) {
JOptionPane.showMessageDialog( null,salida );
otro = false;
}
}
archivo.close();
}
 catch (IOException e) {
JOptionPane.showMessageDialog( null,"Error al abrir el
archivo: "
+ nombreArchivo );
}
System.exit( 0 );

}
}

Aplicaciones

Encriptación/Cifrado.- Una manera de codificar la información de un Archivo.

El cifrado es un método que permite aumentar la seguridad de un mensaje o de un

archivo mediante la codificación del contenido, de manera que sólo pueda leerlo la
persona que cuente con la clave de cifrado adecuada para descodificarlo.

Métodos y Técnicas de Cifrado.

Cifrado de sustitución

El cifrado de sustitución consiste en reemplazar una o más entidades (generalmente

letras) de un mensaje por una o más entidades diferentes.

Por ejemplo: Existe un juego llamado encriptación del murciélago. La palabra murciélago
es una palabra que contiene las 5 vocales y la técnica de encriptación consiste en
enumerar las vocales de esta palabra por lo que la vocal “u” le corresponde el número 1,
la vocal “i” el 2, la vocal “e” el 3, la letra “a” el 4 y la vocal “o” el 5. Para encriptar el texto o
archivo se sustituye cada vocal por el valor numérico que le corresponde:

Ejemplo de encriptación del murciélago.

3j3mpl5 d3 3ncr2pt4c25n d3l m1rc23l4g5.

Otra técnica de encriptación se llama Sucesor, la cual consiste en cambiar cada letra del
texto o archivo por la letra que le sucede, es decir si se tiene la letra “a” se cambiará por la
letra “b” que es la que le sigue, así sucesivamente hasta que se termine el texto:
 Este es un ejemplo de encriptación en base a sucesor.
Ftuf!ft!vo!fkfnqmp!ef!fodsjqubdjôo!fo!cbtf!b!tvdftps/

Existen también su contraparte llamada técnica de encriptado predecesor, la cual consiste

en cambiar cada letra del texto o archivo por la letra que le precede, es decir si se tiene la
letra “b” se cambia por la letra “a”, así sucesivamente hasta que se termina el texto:

Este es un ejemplo de encriptación en base a predecesor.

Drsddrtmdidlokncddmbqhos`bhòmdma`rd`oqdcdbdrnq-

De estas dos últimas técnicas se puede hacer una combinación, la cual es llamada
sucesor/predecesor, la cual consiste en cambiar la primer letra en base a suceror y la
siguiente cambiarle por su predecesor, así sucesivamente hasta que se termine el texto:

Este es un ejemplo de encriptación en base a sucesor/predecesor.

Dtsffr!tofiflqkped!dobshqsbbjòofm!abrfbttddtns.qqfcfbfrpq/

6.3. Manejo de excepciones en archivos.

Producto de Aprendizaje 6:

1. Elabore un programa que lea de teclado oraciones las encripte en base a

sucesor/predecesor y las guarde en un archivo.

2. Elabore un programa que lea de un archivo las oraciones encriptadas en base a

sucesor/predecesor y las muestre en pantalla desencriptadas.

3. Elabore un programa que se le manden dos nombres de archivo y el contenido del

primero archivo lo agregue al final del segundo archivo.

4. Del programa del Ejercicio 6.4, elabore un programa en java que solicite el No de
Control y busque el registro en el archivo indicado y si lo encuentra despliegue la
información en caso contrario mostrar “Registro no localizado”.