R 130978

Código:
Dirección Académica CPE-FO-02-03

Revisión: 1
MANUAL DE PRÁCTICAS Página:

1 de 72
MANUAL DE PRÁCTICAS DE PROGRAMACIÓN ORIENTADA A OBJETOS
PROGRAMA EDUCATIVO:
INGENIERIA INFORMATICA
Calkiní, Campeche, Enero 2016
Revisó Aprobó Autorizó
DR. GONZALO MIGUEL QUETZ

DR. MIGUEL ANGEL COHUO
AGUIRRE DR. JOSE LUIS LIRA TURRIZA
ÁVILA
Presidente de Academia Coordinador del PE
Dirección Académica
Código:
Revisión: 1

2 de 72
ÍNDICE
PRESENTACIÓN.................................................................................................................................... 3
OBJETIVO GENERAL ............................................................................................................................. 4
SEGURIDAD ......................................................................................................................................... 5
PRACTICA 1. INSTALACION DEL ENTORNO DE DESARROLLO .............................................................. 6
PRACTICA 2. CONOCIMIENTO DEL LENGUAJE................................................................................... 11
-ANEXOSPRACTICA 3. CLASES Y OBJETOS ......................................................................................... 15
PRACTICA 4. CLASES Y OBJETOS ........................................................................................................ 21
PRACTICA 5. MANEJO DE EXCEPCIONES ........................................................................................... 28
PRACTICA 6. HERENCIA .................................................................................................................... 34
PRACTICA 7. HERENCIA: CONSTRUCTORES Y DESTRUCTORES.......................................................... 45
PRACTICA 8. POLIMORFISMO............................................................................................................ 50
PRACTICA 9. ARREGLOS..................................................................................................................... 55
PRACTICA 10. ARCHIVOS ................................................................................................................... 61

Código:
Revisión: 1

3 de 72
PRESENTACIÓN
La programación orientada a objetos es una “filosofía”, un modelo de programación, un

lenguaje orientado a objetos es un lenguaje de programación que permite el diseño de
aplicaciones orientadas a objetos. Dicho esto, lo normal es que toda persona que vaya a
desarrollar aplicaciones orientadas a objetos aprenda primero la “filosofía” (o adquiera la
forma de pensar) y después el lenguaje, porque “filosofía” sólo hay una y lenguajes
muchos.
La filosofía de la programación orientada a objetos ve a un programa como un conjunto de

objetos que cooperan entre sí para resolver un problema. El modelo orientado a objetos
sirve para desarrollar sistemas de software con un alto grado de complejidad. Este
modelo es tan importante y esta soportado por el OMG (Object Management Group,
Grupo de Administración de Objetos, una agrupación no lucrativa) que establece las
normas que rigen el desarrollo de software orientado a objetos.
Para desarrollar las destrezas se requiere de conocimientos bien cimentados sobre los
temas básicos de ésta área. La destreza de temas de programación a través de prácticas
permite que los participantes se involucren, vivan y ejerciten las competencias adquiridas;
generando resultados que serán evaluados y enriquecidos.
Las prácticas que se presentan en este manual han sido desarrolladas tomando en
cuenta las competencias previas: Analizar, diseñar y desarrollar soluciones de problemas
reales utilizando algoritmos computacionales para implementarlos en un lenguaje de
programación orientado a objetos y el objetivo general de la Asignatura: Diseñar e
implementar objetos de programación que permitan resolver situaciones reales y de
ingeniería.
Código:
Revisión: 1

4 de 72
El presente manual presenta las prácticas necesarias para que el alumno adquiera las
habilidades del desarrollo orientado a objetos empleando los conocimientos teóricos
adquiridos en el aula.
OBJETIVO GENERAL
En este manual de prácticas se estudiarán los objetos, clases, herencia, polimorfismo,

excepciones, flujos y archivos como parte del desarrollo de software para la solución a
problemas reales.
Las prácticas que corresponden a la primera unidad ayudan a cubrir las competencias de
instalar y conocer la sintaxis de un lenguaje de programación orientado a objetos,
conociendo los identificadores, palabras reservadas, tipos de datos, operadores del
lenguaje, tipos de datos y estructuras de control.
Las prácticas que corresponden a la segunda unidad permiten al alumno aprender utilizar
arreglos para solucionar problemas.
Las unidades tres y cuatro ayudan al alumno a codificar clases y métodos; constructores,
destructores y a sobrecargar métodos. Estos conceptos en especial, potencializan la
modularidad como característica importante de la programación orientada a objetos,
manejar los métodos dentro de las clases como parte de la funcionalidad.
Las prácticas relacionadas a herencia y polimorfismo permiten la reutilización de código

sobre bloques bien definidos y programando clases base y derivadas así como la
implementación de interfaces y métodos abstractos y del polimorfismo.
Las prácticas relacionadas a flujos y archivos tienen como objetivo que el alumno aprenda
como lograr la persistencia de datos a través del almacenamiento permanente de datos
en un archivo y las diferentes fuentes de donde puede provenir la información.
Código:
Revisión: 1

5 de 72
SEGURIDAD
Para la utilización del Centro de Cómputo el alumno deberá leer el reglamento para el uso
de las salas del centro de cómputo publicado en el portal (www.itescam.edu.mx).
Queda prohibido introducir a la Sala de Computo alimentos y bebidas.
El personal que labora en la Sala de Computo así como los usuarios, deberán abstenerse
de fumar.
Se prohíbe realizar trabajos con fines de lucro o propaganda política, así como la
utilización de cualquier tipo de juego, consultar páginas Pornográficas por Internet y el uso
de los programas Chat.
Código:
Revisión: 1

6 de 72
PRACTICA 1. INSTALACION DEL ENTORNO DE DESARROLLO
-INTRODUCCIÓN
Java es un lenguaje de programación creado por Sun Microsystems para poder funcionar en
distintos tipos de procesadores. Su sintaxis es muy parecida a la de C o C++, e incorpora como
propias algunas características que en otros lenguajes son extensiones: gestión de hilos, ejecución
remota, etc.
El código Java, una vez compilado, puede llevarse sin modificación alguna sobre cualquier
máquina, y ejecutarlo. Esto se debe a que el código se ejecuta sobre una máquina hipotética o
virtual, la Java Virtual Machine, que se encarga de interpretar el código (ficheros compilados .class)
y convertirlo a código particular de la CPU que se esté utilizando (siempre que se soporte dicha
máquina virtual).
Cuando se programa con Java, se dispone de antemano de un conjunto de clases ya

implementadas. Estas clases (aparte de las que pueda hacer el usuario) forman parte del propio
lenguaje (lo que se conoce como API (Application Programming Interface) de Java).
Variables de entorno
Para su correcto funcionamiento, Java necesita tener establecidas algunas variables de entorno:
las variables PATH y CLASSPATH.
La variable de entorno del sistema PATH deberá contener la ruta donde se encuentren los
programas para compilar y ejecutar (comandos javac y java de la distribución JDK
Por ejemplo:
set PATH=%PATH%;C:\jdk<version>\bin
(Windows)
export PATH=$PATH:/jdk<versión>/bin
(Linux)
Con la variable CLASSPATH indicamos dónde están las clases externas a las de la API que
necesitemos para compilar o ejecutar nuestro programa. Cualquier clase necesaria que no
pertenezca a la API debe estar incluida en el CLASSPATH para poder compilar o ejecutar (aunque
se encuentre en el mismo directorio que la que compilamos). Podemos incluir todas las clases que
hay en un directorio (sin contar los subdirectorios) poniendo la ruta (absoluta o relativa al directorio
actual) del directorio. Por ejemplo, si están en \misclases :
set CLASSPATH=%CLASSPATH%;C:\misclases
(Windows)
Código:
Revisión: 1

7 de 72
export CLASSPATH=$CLASSPATH:/misclases
(Linux)
Compilar clases
Si queremos compilar una clase, se compila con el comando javac (deberemos asegurarnos de
que dicho comando está accesible en el PATH), seguido del nombre de fichero a compilar:
javac NombreFichero.java
Tras haber compilado el ejemplo se tendrá un fichero NombreFichero.class, y se habrán compilado
y actualizado (si no lo estaban ya) todas las clases que necesitara la clase compilada.
Una vez compilada la clase, para ejecutarla utilizamos el comando java seguido del nombre de la
clase (sin extensión):
java NombreClase
Si se quisieran pasar parámetros al programa, se pasan después de la clase:
java NombreClase param1 param2 param3
A la hora de compilar y ejecutar, es importante respetar las mayúsculas y minúsculas de los
nombres de archivos y clases, y asegurarnos antes de compilar o ejecutar que el CLASSPATH
está correctamente establecido para encontrar todas las clases necesarias
-OBJETIVO
Instalar el compilador de JAVA en dos sistemas operativos (windows y Linux) y probar con un
programa de ejemplo su funcionalidad.
Instalar un IDE para desarrollo de código JAVA.
-LUGAR
Aula
-SEMANA DE EJECUCIÓN
Semana 1
Código:
Revisión: 1

8 de 72
- MATERIAL Y EQUIPO
Computadora
Manual de instalación de JDK y del eclipse
- DESARROLLO DE LA PRÁCTICA
Paso 1. Descargar de la página oficial el instalador de JDK para WINDOWS

Paso 2. Instalar el jdk
Paso 3. Configurar el PATH para definir la ruta donde se encuentra el archivo bin del jdk
Paso 4. Configurar el CLASPATH indicando la ruta donde se encontrarán las clases
Paso 5. Probar desde la consola con java –version que el compilador está ejecutando de forma
correcta.
Paso 6. Realizar un pequeño programa hola mundo para imprimir tu nombre de acuerdo a lo
siguiente:
public class MiHolaMundo{

public static void main(String args[])
{
System.out.print(“Hola Mundo <nombre>”);
}
}
Sustituyendo tu nombre, guárdalo con el nombre MiHolaMundo.java
Paso 7. Compilar y ejecutar el programa desde consola con las palabras
javac MiHolaMundo.java (compilar)
java MiHolaMundo (ejecutar)
Paso 8. Instalar un IDE (eclipse o netbeans), probarlo con el programa MiHolaMundo

Paso 9. Repetir los pasos anteriores el sistema Operativo LINUX.
Código:
Revisión: 1

9 de 72
- EVALUACIÓN Y RESULTADOS
El alumno entregara un informe con la instalación del JDK y del IDE de acuerdo a los lineamientos
de informe técnico y sobre este se evaluará:
Criterio Puntaje Puntaje Obtenido
Indica la página oficial donde realizó la descarga así como la 0.5

versión del JDK y del IDE
Indica los pasos que siguió para la instalación del JDK así como 2
los errores que tuvo y como los solucionó (esto aplica en caso
de que hubiera tenido errores la instalación)
Muestra evidencia de la configuración realizada al PATH y 1.5

CLASPATH, muestra la versión del jdk instalado
Muestra evidencia de la Compilación y ejecución del programa 2.5

descrito en el paso 6
Indica los pasos que siguió para la instalación del IDE así como 2
los errores que tuvo y como los solucionó (esto aplica en caso
de que hubiera tenido errores la instalación)
Prueba el IDE ejecutando el programa descrito en el paso 6 1.5
TOTAL 10
El puntaje será divido de cada criterio equivale a la realización en ambos sistemas operativos
(LINUX y WINDOWS), en caso de solo presentar evidencia en un solo sistema operativo éste será
dividido entre dos. El alumno deberá presentar los códigos escritos.
Código:
Revisión: 1

10 de 72
-REFERENCIAS
Bonaparte, U. J. (2012). Proyectos UML Diagramas de clases y aplicaciones JAV en NetBeans 6.9.1.
Tucumán Argentina: Editorial de la Universidad Tecnológica Nacional.
objetos, I. a. (1999). Juan Manuel Cueva Lovelle. España: Universidad de Oviedo.
Schemuller, J. (s.f.). UML en 24 Horas. Prentice Hall.
-ANEXOS
Código:
Revisión: 1

11 de 72
PRACTICA 2. CONOCIMIENTO DEL LENGUAJE
-INTRODUCCIÓN
Un proyecto Java podemos considerarlo como una serie de carpetas ordenadas y organizadas de
acuerdo con una lógica para mantener organizado el código. Un proyecto suele constar de
archivos .java, archivos .class y documentación.
Los archivos .java contienen el código fuente (entendible por humanos) que en un momento dado
podemos modificar con un editor de textos y suelen encontrarse en carpetas de nombre src
(source). Los archivos .class contienen el bytecode (no entendible por humanos pero sí por la
máquina virtual Java) y suelen encontrarse en carpetas de nombre bin (binary).
La organización de los archivos en carpetas y la presencia de otros adicionales dependen del

entorno de desarrollo que utilicemos. Además, Java introduce un esquema organizativo a través de
paquetes (packages)
El concepto de paquete viene siendo similar al de carpeta en Windows: un contenedor donde

mantenemos cosas relacionadas entre sí.
La organización del proyecto será por tanto similar a la organización de archivos: en un paquete
podremos tener por ejemplo clases de tipo A, en otras clases de tipo B y así sucesivamente. A su
vez, un paquete puede contener subpaquetes: por ejemplo el paquete A puede contener a los
subpaquetes A.1, A.2 y A.3. Un package es una agrupación de clases afines. Recuerda el
concepto de librería existente en otros lenguajes o sistemas. Una clase puede definirse como
perteneciente a un package y puede usar otras clases definidas en ese o en otros packages.
Los packages delimitan el espacio de nombres (space name). El nombre de una clase debe ser
único dentro del package donde se define. Dos clases con el mismo nombre en dos packages
Código:
Revisión: 1

12 de 72
distintos pueden coexistir e incluso pueden ser usadas en el mismo programa. Una clase se
declara perteneciente a un package con la cláusula package incluida como una línea de código,
cuya sintaxis es: package nombrePackage;. La cláusula package debe ser la primera sentencia del
código fuente. Por ejemplo, una clase puede comenzar así:
package miPackage;
. . . public class miClase { . . .
Este código implica que la clase miClase pertenece al package miPackage. La cláusula package
es opcional. Si no se utiliza, las clases declaradas en el archivo fuente no pertenecen a ningún
package concreto, sino que pertenecen a un package por defecto (sin nombre). La agrupación de
clases en packages es conveniente desde el punto de vista organizativo, para mantener bajo una
ubicación común clases relacionadas que cooperan desde algún punto de vista. También resulta
importante por la implicación que los packages tienen en la visibilidad y acceso del código entre
distintas partes de un programa.
Al finalizar la se espera que el alumno logre las siguientes competencias:
Específica(s):
Conoce y aplica la estructura de proyectos en un entorno de desarrollo para la solución de

problemas.
Genéricas:
 Comunicación oral y escrita
 Habilidades del manejo de la computadora
 Capacidad de aplicar los conocimientos en la práctica
 Habilidad para trabajar en forma autónoma

Código:
Revisión: 1

13 de 72
-OBJETIVO
Aplicar las fases del proceso de desarrollo de aplicaciones en la resolución de ejercicios.
Identificar los archivos que se generan en los proyectos creados y presentar un cuadro sinóptico.
Utilizar la herramienta de depuración del entorno de programación para identificar y corregir errores
lógicos y registrarlo en una bitácora.
-LUGAR
Aula
Semana 2
- MATERIAL Y EQUIPO
Computadora
Planteamiento de la problemática.
Un turista Mexicano que viaja al menos 20 veces al año siempre tiene el problema de saber el
valor del dinero que tiene actualmente en la moneda del país que visita. Normalmente el visita
Estados Unidos, países de la región europea, Brasil y china. Te pide que le desarrolles una
solución para que dados la cantidad de pesos mexicanos que posee realice la conversión
correspondiente y le indique su valor en la moneda de cambio.
Código:
Revisión: 1

14 de 72
Paso 1. Plantea una solución escrita para la problemática planteada.
Paso 2. Diseña una solución identificando variables y constantes y especifica el algoritmo para su
solución.
Paso 3. Crea la carpeta donde se va a almacenar el proyecto de solución con el nombre practicas
Paso 4. Crea un nuevo proyecto en el IDE instalado en la práctica 1 y selecciona la carpeta que
creaste.
Paso 5. Crea una nueva clase con el nombre Practica2.
Paso 6. Crea el método main e incluye dentro del mismo la solución planteada y una instrucción
para mostrar el resultado de acuerdo a lo siguiente:
22 pesos mexicanos equivalen a 1.20 dólares
Paso 7. Compile e identifique los errores sintácticos, anote en la bitácora de errores.
Paso 8. Ejecute y valide el resultado e identifique errores lógicos anote en la bitácora
El alumno realizará la práctica de manera individual y entregará un informe con los pasos para la
solución de la problemática, el código correspondiente, la bitácora de errores y su solución de
acuerdo al formato de informe publicado en el portal de calidad del Itescam.
Plantea la solución escrita a la problemática 2
Escribe el algoritmo correspondiente con las variables y 2

constantes correspondientes
Crea el proyecto en la carpeta especificada por el usuario así 0.5

como la clase correspondiente
El método main contiene la solución a la problemática 3

planteada, solicita los valores y realiza la conversión
Código:
Revisión: 1

15 de 72
correspondiente mostrando los resultados de acuerdo a lo

indicado en el paso 6
Presenta la bitácora de errores sintácticos y lógicos 1
Se muestran los resultados esperados 1.5
TOTAL 10
-REFERENCIAS
-ANEXOS
Código:
Revisión: 1

16 de 72
PRACTICA 3. CLASES Y OBJETOS
-INTRODUCCIÓN
UML respaldado por el OMG (Object Management Group), es un lenguaje de modelado de

sistemas de software. Diseñado como una herramienta gráfica donde se puede construir,
especificar, visualizar y documentar sistemas.
Permite representar el modelo de un escenario, donde se describen las entidades intervinientes y

sus relaciones. También podemos al describir cada entidad, especificar las propiedades y el
comportamientos de las mismas.
UML está compuesto por diversos elementos gráficas que se combinan para formar diagramas.
Éstos ayudan a presentar diversas perspectivas de un sistema a los cuales se les conoce como
modelo. Uno de los elementos gráficos son los diagramas de clase los cuales son categorías de
objetos o grupos de cosas que tienen atributos y acciones similares (Schemuller).
Para la diagramación UML una clase es representada con un rectángulo, donde el nombre de la
clase es, por convención, una Palabra escrita con la primera letra en Mayúscula, si consta de dos
palabras cada palabra inicia con la primera letra en Mayúscula, este normalmente se coloca en la
parte superior de rectángulo.
Una clase contiene atributos que corresponden a una propiedad o característica de ésta y describe
un rango de valores que la propiedad podrá contener en los objetos (esto es llamado instancia de
la clase), por convención los atributos constan de una o más palabras escritas en minúsculas, se
puede especificar el tipo de dato que contendrá el atributo (int, doublé,float,String, char, etc).
Los objetos realizan acciones u operaciones que describen sus comportamientos, normamente son
verbos, se escriben con minúsculas y si son más de dos palabras cada una de ellas iniciará con
mayúsculas exceptuando la primera.
Esta práctica le permitirá al alumno realizar diagramas de clases en un lenguaje especializado en

diagramas, el alumno deberá identificar las clases, los atributos y las acciones que realiza.
Código:
Revisión: 1

17 de 72
-OBJETIVO
Diseñar diagramas de clases aplicando los conocimientos del paradigma orientado a objetos para
resolver una situación de la vida real.
-LUGAR
Centro de Cómputo
Semana 6
- MATERIAL Y EQUIPO
Computadora
Software para diagramar UML
Descripción de la problemática.
El juego de la lotería, es un juego de azar que consta de un

mazo conformado por 54 cartas y un número de cartillas N
que contienen 16 de dichas cartas escogidas aleatoriamente
cada una.
El juego inicia cuando los jugadores eligen una

cartilla de forma aleatoria, uno de los jugadores
es designado juez y debe barajear el mazo y
extrae una carta la cuál anuncia a los demás
jugadores, cada jugador anota con una ficha en
Código:
Revisión: 1

18 de 72
su cartilla cuando la carta anunciada coincide con alguna de las que posee. El ganador es el
primero que llene su tabla de manera completa y que grite lotería.
Tu trabajo es modela esta situación.
Paso 1.
Termine de rellenar la tabla con las clases de objetos, sus atributos y las acciones que pueden
realizar de acuerdo a la situación planteada como se muestra.
Clases de objetos Atributos Verbos

1. Carta número
nombre
figura
2. Mazo Cartas barajear
ordenar
extraercarta
3.
4.
5.
Paso 2. Realiza los diagramas de clase correspondientes cada clase de objetos indicando el
nombre de la clase, sus atributos y los métodos de cada una como se muestra para la primera
clase
class System
Carta Mazo
- figura: String - Cartas []: Carta

- nombre: String
- numero: int + barajear() : boolean
+ extraer() : Carta
+ ordenar() : boolean
Paso 3. Anexar al diagrama de clases
las relaciones que existen entre ellas
Código:
Revisión: 1

19 de 72
(Asociación, Agregación, Herencia) y la cardinalidad correspondiente por ejemplo el mazo es uno

pero contiene 54 cartas.
Como se muestra en el ejemplo.
class System
Carta Mazo
- figura: String - Cartas []: Carta

Contiene
- nombre: String
- numero: int 54 1 + barajear() : boolean
+ extraer() : Carta
+ ordenar() : boolean
Paso 4. Por último se debe generar el código del diagrama correspondiente en la opción del menú
Project / source code engineering / Generate source code y almacenar los códigos
correspondientes.
El diagrama presenta todas las clases definidas en la tabla 2
EL diagrama de cada clase especifica los atributos y sus tipos 1

de acuerdo a la tabla
Cada clase contiene los métodos identificados 1
Cada método contiene la lista de parámetros esperados 0.5
Cada método contiene el valor de retorno 1
Los nombres de la clase, atributos y métodos siguen la 1

convención de nombrado
Las clases presenta las relaciones existentes entre ellas 1
Las clases presentan la cardinalidad correspondiente 0.5

Código:
Revisión: 1

20 de 72
Se maneja una relación de jerarquía 1
Se presenta el código generado acorde al diagrama 1
TOTAL 10
El alumno deberá presentar el modelo de clases realizado en el programa, así como los códigos
generados por el programa, éstos deben corresponder a lo presentado en el paso 5 y los códigos
deben acordes con lo diagramado.
-REFERENCIAS
-ANEXOS
Código:
Revisión: 1

21 de 72
PRACTICA 4. CLASES Y OBJETOS
-INTRODUCCIÓN
Un objeto no es más que un conjunto de variables (o datos) y métodos (o funciones) relacionados

entre sí. Los objetos en programación se usan para modelar objetos o entidades del mundo real (el
objeto hijo, madre, o farmacéutica, por ejemplo). Un objeto es, por tanto, la representación en un
programa de un concepto, y contiene toda la información necesaria para abstraerlo: datos que
describen sus atributos y operaciones que pueden realizarse sobre los mismos. Los atributos del
objeto (estado) y lo que el objeto puede hacer (comportamiento) están expresados por las
variables y los métodos que componen el objeto respectivamente.
Si nos detenemos a pensar sobre cómo se nos plantea un problema cualquiera en la realidad
podremos ver que lo que hay en la realidad son entidades (otros nombres que podríamos usar
para describir lo que aquí llamo entidades son “agentes” u “objetos”). Estas entidades poseen un
conjunto de propiedades o atributos, y un conjunto de métodos mediante los cuales muestran su
comportamiento. Y no sólo eso, también podremos descubrir, a poco que nos fijemos, todo un
conjunto de interrelaciones entre las entidades, guiadas por el intercambio de mensajes; las
entidades del problema responden a estos mensajes mediante la ejecución de ciertas acciones.
Normalmente en el mundo real existen varios objetos de un mismo tipo, o como diremos
enseguida, de una misma clase. Una clase es una plantilla que define las variables y los métodos
que son comunes para todos los objetos de un cierto tipo.
Normalmente un único objeto por sí solo no es muy útil. En general, un objeto aparece como un
componente más de un programa o una aplicación que contiene otros muchos objetos. Es
precisamente haciendo uso de esta interacción como los programadores consiguen una
funcionalidad de mayor orden y modelar comportamientos mucho más complejos.
Cada clase requiere especificar la forma en como los objetos serán construidos y los valores por
default que tendrán. El objetivo de un constructor es el de inicializar un objeto cuando éste es
creado. En java es un método especial dentro de una clase, que se llama automáticamente cada
vez que se crea un objeto de esa clase.
Código:
Revisión: 1

22 de 72
Posee el mismo nombre de la clase a la cual pertenece y no puede regresar ningún valor (ni
siquiera se puede especificar la palabra reservada void).
Existen 2 tipos de constructores, los constructores por defecto es un constructor que hace nada y
que es invocado cada vez que se construye un objeto sin especificar ningún argumento asignando
valores predefinidos para los atributos; el constructor con parámetros debe especificar algún
argumento que servirán para iniciar los atributos con los valores especificados por el usuario y
realizará las acciones preestablecidas al ejecutarse.
En java no existen los destructores, esto se realiza de manera automática cada vez que los objetos
se dejan de usar.
Un método sobrecargado se utiliza para reutilizar el nombre de un método pero con diferentes
argumentos. Las reglas para sobrecargar un método son las siguientes:
Los métodos sobrecargados deben de cambiar la lista de argumentos.
Pueden cambiar el tipo de retorno.
Un método puede ser sobrecargado en la misma clase o en una subclase.

Código:
Revisión: 1

23 de 72
-OBJETIVO
Programar clases con atributos y métodos que utilicen distintos modificadores de acceso
empleando constructores y métodos sobrecargados con la finalidad comprender la
-LUGAR
Sala de Cómputo
Semana 7.
- MATERIAL Y EQUIPO
Editor de texto (Bloc de notas,vi, gedit)
Equipo de cómputo
Software Enterprise Architect o software libre para diagramas UML (BoUML, ArgoUML u otra)
-DESARROLLO DE LA PRÁCTICA
Descripción de la problemática
Un termómetro es un instrumento utilizado para medir la temperatura con un alto nivel de exactitud,
son capaces de medir medidas extremas (frio o calor). Las temperaturas son medidas en una
escala siendo las más usadas a nivel internacional los Grados Celsius (°C) o los Grados
Fahrenheit (°F) y Grados Kelvin (°K). Los termómetros actuales permiten mostrar en un
Código:
Revisión: 1

24 de 72
visualizador la temperatura medida, almacenando de manera temporal para poder identificar las
temperaturas extremas (máxima y mínima) registradas y el promedio, igualmente el termómetro es
capaz de convertir las temperaturas de una escala a otra permitiendo su uso en cualquier lugar.
Paso 1. De acuerdo a la problemática identifique atributos y comportamientos del termómetro

digital y llene la tabla siguiente:
Atributos Comportamientos
1. 1.
2. 2.
3. 3.
4. 4.
5. 5.
Paso 2. De acuerdo a los atributos y comportamientos detectados escriba el diagrama de clase

utilizando un lenguaje para diagramas UML. El diagrama deberá contener el tipo de dato asociado
a cada atributo y cada método deberá contener el tipo de valor devuelto junto con los parámetros
requeridos.
Paso 3. El alumno escribirá la clase de acuerdo al diagrama como se muestra a continuación:
a) Definir la clase con el nombre TermómetroDigital
b) Definir los atributos para la clase indicados en el diagrama por ejemplo: marca, color, valor,
botonOnOff, etc; de acuerdo a lo siguiente:
tipo nombre;
Ejemplo: String marca;
c) Escribir el constructor de la clase recibiendo al menos un parámetro para asignar valor a un

atributo del termómetro.
d) Escribir los métodos set y get para asignar y devolver los valores a los atributos declarados
en las variables.
Código:
Revisión: 1

25 de 72
El programa debe quedar de acuerdo a la siguiente estructura:

public class NombreDeMiClase{
// Definición de atributos
String marca;
boolean encenderapagar;
// Definición de métodos
//Constructor
public NombreDeMiClase(String m) // lista de parametros
{
marca = (m.equals(“”))? “Steren”: m;
encenderapagar = false;
}
// declaración de métodos para asignar u obtener los valores de los atributos
public void setMarca(String m) // asignar un valor al atributo
{
Marca = (m.equals(“”))? “Steren”: m;
}
public String getMarca() //devolver el valor del atributo
{
return marca;
}
// otros métodos de la clase
El alumno debe cuidar las tabulaciones del programa para marcar con claridad el ámbito de cada
segmento en la clase.
Paso 2. Escribir los métodos para dar funcionalidad al termométro (comportamientos descritos en
el diagrama) por ejemplo: prender o Apagar, medirTemperatura.
Nota: en el caso de la medición de la temperatura esta se realizará utilizando valores aleatorios
entre un rango definido.
public void encenderApargar()

{
if(!encenderapagar)
encenderapagar=true;
else
encenderapagar=false;
}
Código:
Revisión: 1

26 de 72
Paso 3. Sobrecargar métodos.

a) Agregar otro constructor por defecto que construya el termómetro con la marca
“Samsumg” y en modo apagado.
b) Sobrecargar uno de los métodos de la clase.
Paso 4. Escribir la funcionalidad de los métodos para que pueda implementar los comportamientos
establecidos.
Paso 5. Escribir el método main para crear una instancia de la clase y probar el acceso desde ella
a los atributos y métodos. Mínimo debe probar el cambio de las unidades de medida del
termómetro.
Paso 6. Compilar y ejecutar el programa
Paso 7. Mostrar los resultados en consola.
Paso 8. Realizar los pasos del 1 al 7 para dos clases de objetos concretos (puerta, elevador,
televisor) y abstractos (CuentaBancaria, Prestamo, Viaje, etc.)
Paso 9.
El alumno deberá presenta un programa y los resultados de acuerdo a la siguiente tabla:
Se escribe los nombres de la clase, métodos, atributos de 0.5

acuerdo a la convención establecida
Se escriben al menos 4 atributos para la clase con sus tipos de 0.5

datos definidos de forma correcta.
Se utiliza de forma correcta la declaración de métodos para la 1

clase
Se escriben los métodos necesarios para realizar las acciones 2.5

descritas en la problemática (funcionalidad del método)
Código:
Revisión: 1

27 de 72
Se escriben al menos dos constructores para la clase 1.5
Se utiliza sobrecarga para un método de la clase diferente al 1.5

constructor
Se utilizan los métodos set y get para asignar y devolver valores 1
Se crea al menos 2 instancias de la clase 0.5
Se modifican los valores de los atributos a través de los 0.2

métodos
Se invoca al método para medir diferentes temperaturas y 0.2

almacenarlas
Se llama al método para cambiar de unidad la temperatura 0.2

medida
Se llama al método para visualizar los resultados 0.2
Se muestran las temperaturas extremas y el promedio de ellas 0.2
TOTAL 10
El alumno deberá presentar el modelo de clases realizado en el programa, así como los códigos
generados por el programa.
-REFERENCIAS
Aguilar, L. J. (2014). Programación en c, c++, java y uml. Mc. Graw Hill.
Deitel, p. (2012). Como programar en Java. Pearson.
Javier, C. S. (2012). Java 2 curso de programación. Alfaomega.
-ANEXOS
Código:
Revisión: 1

28 de 72
PRACTICA 5. MANEJO DE EXCEPCIONES
-INTRODUCCIÓN
En Java una excepción es un error o una condición anormal que se ha producido durante la
ejecución de un programa. Java tiene diferentes tipos de excepciones: excepciones de I/O, las
excepciones en tiempo de ejecución y las de su propia creación. Durante la compilación solamente
se detectan los errores de sintaxis, pero el manejo de excepciones de Java permite el manipular
los errores que ocurren en tiempo de ejecución, entre estas podemos mencionar las excepciones
aritméticas (división entre cero), excepciones de puntero (acceso a punteros NULL) y excepciones
de indexación (acceso por encima o debajo de los límites de un vector). Algunas excepciones son
fatales y causan el fin de la ejecución del programa. En este caso conviene terminar
ordenadamente y enviar un mensaje explicando el tipo de error que se ha producido. En otras
situaciones, por ejemplo cuando no se encuentra un archivo sobre el que se desea realizar una
operación, el programa puede dar al usuario la oportunidad de corregir el error. Un buen
programa debe manejar correctamente la mayoría de los errores que se puedan producir, Java
proporciona las siguientes herramientas para el manejo de excepciones: try, catch, throw, throws
y finally.
Código:
Revisión: 1

29 de 72
Thrownable
Clase base que representa todo lo que se puede “lanzar” en java, contiene una el estado de la pila
en el momento en que se genera la excepción (stack trace o call chain), almacena un mensaje de
tipo String que se puede utilizar para detallar que excepción se generó.
Error
Subclase de Thrownable que indica problemas graves de los cuales una aplicación no se puede
recuperar por ejemplo: Memoria Agotada, error de la máquina virtual.
Exception
Situaciones más o menos habituales que impiden completar la ejecución correcta del código.
Generalmente el programador debe proporcionar el código que las trate o gestione.
Predefinidas en el sistema
Se lanzan automáticamente cuando se realiza alguna operación no valida
- Acceso a un objeto que no existe,
- Acceso a una posición de un array que no existe,
- División por cero
Generadas por el programador
El programa explícitamente genera una excepción al detectar una situación de error que no se
puede resolver en ese contexto, útil en situaciones de prueba y depuración.
Elementos para gestionar excepciones

try
- Es el bloque de código donde se prevé que se genere una excepción
- Debe ir seguido por lo menos por una instrucción catch o finally
catch (TipoExcepcion e)
- Es el código que se ejecuta cuando se produce la excepción del tipo indicado
- Pueden aparecer varias instrucciones catch para tratar distintas excepciones
- Cuando se produce una excepción se compara si coincide con la excepción del primer catch.
Si no coincide con la del segundo y sucesivos
finally
Muchas veces, cuando se produce una excepción es necesario un mecanismo que limpie el estado
del método antes de que el control pase a otra parte del programa. Por ejemplo, una excepción
podría causar un error que termine el método actual, pero tal vez antes sea necesario cerrar un
archivo o una conexión a red. En Java esto se puede hacer esto encerrando el código de limpieza
dentro de un bloque finally. El formato general de un try/catch que incluye finally es:
try{
código que produce la (s) excepción (es)...
}
catch( TipoDeExcepcion objeto){
Código:
Revisión: 1

30 de 72
// Código para manejar la excepción

}
finally{
// código de finally
}
throws
- Indica que el código producirá una excepción, que no se tratará dentro de él y se pasará al
método superior, utilizando la cláusula throws.
public void ejemploExcep () throws IOException
- A continuación de la palabra reservada throws aparece una lista de todas las excepciones
que se pueden dar dentro del método que serán lanzadas y no serán gestionadas.
-OBJETIVO
Identificar, manejar, gestionar y crear las condiciones de error que interrumpan el flujo normal de
ejecución de un programa.
-LUGAR
Sala de Cómputo
Semana 8
- MATERIAL Y EQUIPO
Equipo de cómputo
Editor de texto (Bloc de notas,vi, gedit, scite)
Eclipse
Código:
Revisión: 1

31 de 72
Planteamiento del problema
Eduardo se encontraba realizando su tarea de matemáticas, le tocaba realizar divisiones entre

diferentes cantidades y almacenar los resultados en un arreglo. Tu trabajo fue realizar un programa
que permitiera leer dos cantidades y validar que fueran números enteros no mayores de 100. Tu
trabajo es implementar en este programa el manejo de excepciones Aritméticas y definidas por el
usuario.
Paso 1. Crear la clase para realizar las operaciones de división, almacenamiento y visualización de
los datos.
Paso 2. Utilizar las excepciones para tratar desde el método dividir la excepción AritmeticException
Como se muestra acontinuación:
try{
//bloque de código que genera la excepcion
} catch(ArithmeticException excepcion){
System.out.println(" Mensaje de error");}
Paso 2. Genere una excepción propia para controlar que los números no sean mayores de 100
De acuerdo a lo siguiente:
a) Declare una clase que herede de Exception para crear la excepción propia con el
nombre ValorFueraDeRango e incluya código para enviar un mensaje al usuario.
class ValorFueraDeRango extends Exception {
// código del mensaje al usuario}
b) Cree la instrucción para validar el valor proporcionado por el usuario y que se genere la
excepción utilizando la siguiente línea de instrucción.
throw ValorFueraDeRango;
Código:
Revisión: 1

32 de 72
c) Lanza la excepción fuera del método para que sea capturada desde el lugar que fue
invocada utilizando la sentencia throws ValorFueraDeRango al final del nombre del
método
d) Captura la excepción y despliegue el mensaje correspondiente para que se pueda

solicitar de nuevo el valor.
e) Maneje las excepciones que se pueden generar cuando se almacene información en el

arreglo colocando lo mensajes correspondientes.
f) Implemente en uno de los bloques de excepciones la sentencia finally y el método

stackTrace() para mostrar los elementos de la pila.
Se crean la clase con los métodos solicitados 0.5
Se crea el código para manejar la Excepción Aritmética 1.5
Se crea la clase ValorFueraDeRango con el mensaje propio 1.5
Se genera la excepción ValorFueraDeRango 2
Se lanza la excepción fuera del método 0.5
Se trata la excepción en el bloque donde fue invocado 1
Se escribe el código para tratar y manjar excepciones sobre el 1.5

arreglo de almacenamiento
Implementa el bloque finally y el método printStackTrace 1.5
TOTAL 10
El alumno deberá presentar los códigos fuente generados para solucionar el problema y las
pantallas de resultado en un informe.
Código:
Revisión: 1

33 de 72
-REFERENCIAS
-ANEXOS
Código:
Revisión: 1

34 de 72
PRACTICA 6. HERENCIA
-INTRODUCCIÓN
La Herencia es una propiedad esencial de la Programación Orientada a Objetos que consiste en la

creación de nuevas clases a partir de otras ya existentes. Este término ha sido prestado de la
Biología donde afirmamos que un niño tiene la cara de su padre, que ha heredado ciertas facetas
físicas o del comportamiento de sus progenitores.
La herencia es la característica fundamental que distingue un lenguaje orientado a objetos, Java

permite heredar a las clases características y conductas de una o varias clases denominadas
base. Las clases que heredan de clases base se denominan derivadas, estas a su vez pueden ser
clases bases para otras clases derivadas. Se establece así una clasificación jerárquica, similar a la
existente en Biología con los animales y las plantas.
La herencia ofrece una ventaja importante, permite la reutilización del código. Una vez que una
clase ha sido depurada y probada, el código fuente de dicha clase no necesita modificarse. Su
funcionalidad se puede cambiar derivando una nueva clase que herede la funcionalidad de la clase
base y le añada otros comportamientos. Reutilizando el código existente, el programador ahorra
tiempo y dinero, ya que solamente tiene que verificar la nueva conducta que proporciona la clase
derivada.
Los programadores crean clases base:
1. Cuando se dan cuenta que diversos tipos tienen algo en común, por ejemplo en el juego del
ajedrez peones, alfiles, rey, reina, caballos y torres, son piezas del juego. Creamos, por tanto, una
clase base y derivamos cada pieza individual a partir de dicha clase base.
2. Cuando se precisa ampliar la funcionalidad de un programa sin tener que modificar el código
existente.
3. Cuando las clases que se tienen responden a una tercera clase con la frase ES UN. Por ejemplo
un carro ES UN Vehículo, un camión ES UN vehículo, etc.
Clase Base
Vamos a poner un ejemplo del segundo tipo, que simule la utilización de librerías de clases para
crear una interfaz gráfico de usuario
Código:
Revisión: 1

35 de 72
Supongamos que tenemos una clase que describe la conducta de una ventana muy simple,
aquella que no dispone de título en la parte superior, por tanto no puede desplazarse, pero si
cambiar de tamaño actuando con el ratón en los bordes derecho e inferior.
La clase Ventana tendrá los siguientes miembros dato: la posición x e y de la ventana, de su

esquina superior izquierda y las dimensiones de la ventana: ancho y alto.
public class Ventana {
protected int x;
protected int y;
protected int ancho;
protected int alto;
public Ventana(int x, int y, int ancho, int alto) {
this.x=x;
this.y=y;
this.ancho=ancho;
this.alto=alto;
Las funciones miembros, además del constructor serán las siguientes: la función mostrar que
simula una ventana en un entorno gráfico, aquí solamente nos muestra la posición y las
dimensiones de la ventana.
public void mostrar(){
System.out.println("posición : x="+x+", y="+y);
System.out.println("dimensiones : w="+ancho+", h="+alto);
La función cambiarDimensiones que simula el cambio en la anchura y altura de la ventana.
public void cambiarDimensiones(int dw, int dh){
ancho+=dw;
Código:
Revisión: 1

36 de 72
alto+=dh;
El código completo de la clase base Ventana, es el siguiente
package ventana;
public class Ventana {
protected int x;
protected int y;
protected int ancho;
protected int alto;
public Ventana(int x, int y, int ancho, int alto) {
this.x=x;
this.y=y;
this.ancho=ancho;
this.alto=alto;
System.out.println("posición : x="+x+", y="+y);
System.out.println("dimensiones : w="+ancho+", h="+alto);
public void cambiarDimensiones(int dw, int dh){
ancho+=dw;
alto+=dh;
}
Código:
Revisión: 1

37 de 72
La clase derivada
Incrementamos la funcionalidad de la clase Ventana definiendo una clase derivada denominada

VentanaTitulo. Los objetos de dicha clase tendrán todas las características de los objetos de la
clase base, pero además tendrán un título, y se podrán desplazar (se simula el desplazamiento de
una ventana con el ratón).
La clase derivada heredará los miembros dato de la clase base y las funciones miembro, y tendrá
un miembro dato más, el título de la ventana.
public class VentanaTitulo extends Ventana{
protected String titulo;
public VentanaTitulo(int x, int y, int w, int h, String nombre) {
super(x, y, w, h);
titulo=nombre;
extends es la palabra reservada que indica que la clase VentanaTitulo deriva, o es una subclase,
de la clase Ventana.
La primera sentencia del constructor de la clase derivada es una llamada al constructor de la clase
base mediante la palabra reservada super. La llamada
super(x, y, w, h);
Inicializa los cuatro miembros dato de la clase base Ventana: x, y, ancho, alto.
A continuación, se inicializa los miembros dato de la clase derivada, y se realizan las tareas de
inicialización que sean necesarias. Si no se llama explícitamente al constructor de la clase base
Java lo realiza por nosotros, llamando al constructor por defecto si existe.
La función miembro denominada desplazar cambia la posición de la ventana, añadiéndoles el

desplazamiento.
public void desplazar(int dx, int dy){
x+=dx;
y+=dy;
Código:
Revisión: 1

38 de 72
Redefine la función miembro mostrar para mostrar una ventana con un título.
super.mostrar();
System.out.println("titulo : "+titulo);
En la clase derivada se define una función que tiene el mismo nombre y los mismos parámetros
que la de la clase base. Se dice que redefinimos la función mostrar en la clase derivada. La función
miembro mostrar de la clase derivada VentanaTitulo hace una llamada a la función mostrar de la
clase base Ventana, mediante
super.mostrar();
De este modo aprovechamos el código ya escrito, y le añadimos el código que describe la nueva
funcionalidad de la ventana por ejemplo, que muestre el título.
Si nos olvidamos de poner la palabra reservada super llamando a la función mostrar, tendríamos
una función recursiva. La función mostrar llamaría a mostrar indefinidamente.
public void mostrar(){ //¡ojo!, función recursiva
mostrar();
La definición de la clase derivada VentanaTitulo, será la siguiente.
package ventana;
public class VentanaTitulo extends Ventana{
protected String titulo;
public VentanaTitulo(int x, int y, int w, int h, String nombre) {
super(x, y, w, h);
Código:
Revisión: 1

39 de 72
titulo=nombre;
super.mostrar();
public void desplazar(int dx, int dy){
x+=dx;
y+=dy;
package ventana;
public class VentanaApp {
public static void main(String[] args) {
VentanaTitulo ventana=new VentanaTitulo(0, 0, 20, 30, "Principal");
ventana.mostrar();
ventana.cambiarDimensiones(10, -5);
ventana.desplazar(4, 3);
System.out.println("************************");
ventana.mostrar();
Código:
Revisión: 1

40 de 72
try {
//espera la pulsación de una tecla y luego RETORNO
System.in.read();
}catch (Exception e) { }
Objetos de la clase derivada
Creamos un objeto ventana de la clase derivada VentanaTitulo
VentanaTitulo ventana=new VentanaTitulo(0, 0, 20, 30, "Principal");
Mostramos la ventana con su título, llamando a la función mostrar, redefinida en la clase derivada
ventana.mostrar();
Desde el objeto ventana de la clase derivada llamamos a las funciones miembro definidas en dicha
clase
ventana.desplazar(4, 3);
Desde el objeto ventana de la clase derivada podemos llamar a las funciones miembro definidas en
la clase base.
ventana.cambiarDimensiones(10, -5);
Para mostrar la nueva ventana desplazada y cambiada de tamaño escribimos
ventana.mostrar();
-OBJETIVO
Implementar la herencia en clases derivadas para reutilizar los miembros de una clase base.
Código:
Revisión: 1

41 de 72
-LUGAR
Sala de Cómputo
Semana 11
- MATERIAL Y EQUIPO
Equipo de cómputo
Eclipse
Software Enterprise Architect o software libre para diagramas UML (BoUML, ArgoUML u otra)
En la clase de Geometría plana se requiere construir distintos tipos de figuras geométricas

(Triángulo, rectángulo, circulo, trapecio) para calcular su área, perímetro y volumen. Su trabajo es
construir las clases necesarias para crear las figuras geométricas y sus distintos tipos y poder
calcular los valores dependiendo del tipo. La importancia de ejercicio radica en la creación de
instancias de la clase base e instancias de las clases derivadas con el fin de poder identificar los
comportamientos de los distintos miembros heredados.
Código:
Revisión: 1

42 de 72
Paso 1. De acuerdo a la problemática identifique atributos y comportamientos de la clase Base

(Figura Geométrica)
Atributos Comportamientos
1. 1.
2. 2.
3. 3.
4. 4.
5. 5.
Paso 2. Identifique los atributos y métodos para las clases derivadas (Triangulo, Circulo,
Rectángulo, Trapecio, Cuadrado) y llene una tabla similar a la anterior para cada clase derivada.
Paso 3. De acuerdo a los atributos y comportamientos detectados escriba el diagrama de clase

utilizando un lenguaje para diagramas UML. El diagrama deberá contener el tipo de dato asociado
a cada atributo y cada método deberá contener el tipo de valor devuelto junto con los parámetros
requeridos.
Paso 3. El alumno escribirá las clases de acuerdo al diagrama considerando los siguientes puntos:
a) La clase base deberá contener métodos para calcularArea, calcularPerímetro y un
método visible
b) La clase base tendrá al menos un constructor con parámetros
c) Cada clase derivada deberá extender de la clase base y escribir la implementación
propia de los métodos calcularArea, calcularPerimetro
d) Cada clase derivada deberá llamar al constructor de la clase base utilizando la palabra
reservada super
Paso 4. Crear una clase principal que instancie un objeto de la clase base, uno de la clase
derivada y llame a los métodos calcularArea y calcularPerimetro de la clase Base y Derivadas.
Paso 5. Compilar, Ejecutar y probar el programa.

Código:
Revisión: 1

43 de 72
Identifica los atributos y métodos de la clase base y de las 1

clases derivadas y los plasma en la tabla.
Realiza el diagrama de clases correspondiente a la 1

problemática y de acuerdo a los datos de la tabla
Se escribe la clase base con sus atributos y métodos, se 2

especifican los modificadores de acceso para atributos y
métodos que permitan el acceso desde la clase derivada
Se crean las clases derivadas solicitadas conteniendo los 2

atributos y constructores correspondientes
Se sobreescriben los métodos de la clase base en las clases 1

derivadas
Se crean instancias y se llaman a métodos de la clase base y 1

derivadas
Las clases compilan sin errores 1
Se ejecuta y muestra los resultados 1
TOTAL 10
El alumno deberá presentar los códigos generados por el programa y las pantallas con los
resultados en un informe.
Código:
Revisión: 1

44 de 72
-REFERENCIAS
-ANEXOS
Código:
Revisión: 1

45 de 72
PRACTICA 7. HERENCIA: CONSTRUCTORES Y DESTRUCTORES
-INTRODUCCIÓN
Constructores y destructores en clases derivadas.
Constructores en clases derivadas. Al instanciar objetos de clases derivadas se inicia una cadena
de invocaciones a constructores en las cuales el constructor de la clase derivada, antes de realizar
sus propias tareas, invoca (ya sea implícita o explícitamente) al constructor de su clase base.
Similarmente, si la clase base fue derivada de otra clase, el constructor de la clase base debe
invocar al constructor de la clase ubicada en el siguiente nivel superior de la jerarquía, y así
sucesivamente. El último constructor invocado en la cadena es el constructor de la clase Object,
cuyo cuerpo se ejecuta primero. El cuerpo del constructor de la clase derivada se ejecuta al final.
El constructor de cada clase base inicializa las variables de instancia que el objeto de la clase
derivada hereda.
Constructores en clases derivadas
Al instanciar objetos de clases derivadas se inicia una cadena de invocaciones a constructores en

las cuales el constructor de la clase derivada, antes de realizar sus propias tareas, invoca (ya sea
implícita o explícitamente) al constructor de su clase base. Similarmente, si la clase base fue
derivada de otra clase, el constructor de la clase base debe invocar al constructor de la clase
ubicada en el siguiente nivel superior de la jerarquía, y así sucesivamente. El último constructor
invocado en la cadena es el constructor de la clase Object, cuyo cuerpo se ejecuta primero. El
cuerpo del constructor de la clase derivada se ejecuta al final. El constructor de cada clase base
inicializa las variables de instancia que el objeto de la clase derivada hereda.
Código:
Revisión: 1

46 de 72
Destructores en clases derivadas
Cuando remueve de la memoria un objeto de una clase derivada, el recolector de basura invoca al
destructor del objeto. Esto inicia una cadena de invocaciones a destructores, en donde el
destructor de la clase derivada y los destructores de las clases bases directas e indirectas se
ejecutan en orden inverso al que se ejecutaron los constructores, esto es, primero se ejecuta el
destructor de la clase derivada y al final se ejecuta el destructor de la clase base ubicada en el
nivel superior de la jerarquía. La ejecución de los destructores debe liberar todos los recursos que
el objeto adquirió, antes de que el recolector de basura reclame la memoria de ese objeto. Cuando
el recolector de basura invoca al destructor de un objeto de una clase derivada, ese destructor
realiza su tarea y después invoca al destructor de la clase base. El proceso se repite hasta que se
invoca al destructor de la clase Object.
-OBJETIVO
Implementar los constructores de clase Base y clases Derivadas
-LUGAR
Sala de Cómputo
Semana 12
- MATERIAL Y EQUIPO
Equipo de cómputo
Eclipse
Código:
Revisión: 1

47 de 72
Existen distintos instrumentos de medición que ayudan a tener de menar más precisa las mediadas
de la velocidad, las revoluciones por minuto de un motor, la temperatura, cada uno de estos
instrumentos son mostrados en un vehículo y sirven para que el conductor pueda operar de mejor
manera un vehículo. Utilizando la clase termómetro de la práctica 2 cree las clases restantes para
simular el funcionamiento de un tacómetro y un velocímetro, así mismo cree la clase Instrumento
de medición y utilice constructores en clase Base y Derivadas.
Paso 1. De acuerdo a la problemática identifique atributos y comportamientos de la clase Base

(InstrumentoDeMedición) y las clases derivadas (velocímetro, tacómetro, termómetro)
Paso 3. El alumno escribirá las clases considerando los siguientes puntos:

a) La clase base deberá contener métodos abstractos por ejemplo medir.
b) La clase base tendrá constructores con y sin parámetros
c) Cada clase derivada deberá extender de la clase base y escribir la implementación
propia de los métodos abstractos
d) Cada clase derivada deberá llamar al constructor con parámetros de la clase base
utilizando la palabra reservada super
Paso 4. Crear una clase principal que instancie objetos de las clases derivadas y llame a sus
métodos.
Paso 5. Compilar, Ejecutar y probar el programa.

Código:
Revisión: 1

48 de 72
Identifica los atributos y métodos de la clase base y de las 1

clases derivadas y los plasma en la tabla.
Se escribe la clase base con sus atributos y métodos, se 1

especifican los modificadores de acceso para atributos y
métodos que permitan el acceso desde la clase derivada
Se crea la clase base utilizando métodos abstractos o se crea la 2

interfaz correspondiente
Se crean las clases derivadas solicitadas conteniendo los 2

atributos y constructores correspondientes
Se escriben los métodos de la clase base en las clases 1

derivadas o se implementa la interfaz escrita
Se crean instancias y se llaman a métodos de las clases 1

derivadas
TOTAL 10
El alumno deberá los códigos fuente generados para solucionar el problema planteado.
-REFERENCIAS

Código:
Revisión: 1

49 de 72
-ANEXOS
Código:
Revisión: 1

50 de 72
PRACTICA 8. POLIMORFISMO
-INTRODUCCIÓN
Hay ocasiones, cuando se desarrolla una jerarquía de clases en que algún comportamiento
está presente en todas ellas pero se materializa de forma distinta para cada una. Por ejemplo,
pensemos en una estructura de clases para manipular figuras geométricas. Podríamos pensar en
tener una clase genérica, que podría llamarse FiguraGeometrica y una serie de clases que
extienden a la anterior que podrían ser Circulo, Poligono, etc. Podría haber un método dibujar dado
que sobre todas las figuras puede llevarse a cabo esta acción, pero las operaciones concretas para
llevarla a cabo dependen del tipo de figura en concreto (de su clase). Por otra parte la acción
dibujar no tiene sentido para la clase genérica FiguraGeometrica, porque esta clase representa una
abstracción del conjunto de figuras posibles.
Para resolver esta problemática Java proporciona las clases y métodos abstractos. Un método
abstracto es un método declarado en una clase para el cual esa clase no proporciona la
implementación (el código). Una clase abstracta es una clase que tiene al menos un método
abstracto. Una clase que extiende a una clase abstracta debe implementar los métodos abstractos
(escribir el código) o bien volverlos a declarar como abstractos, con lo que ella misma se convierte
también en clase abstracta.
La clase abstracta se declara simplemente con el modificador abstract en su declaración. Los

métodos abstractos se declaran también con el mismo modificador, declarando el método pero sin
implementarlo (sin el bloque de código encerrado entre {}). La clase derivada se declara e
implementa de forma normal, como cualquier otra. Sin embargo si no declara e implementa los
métodos abstractos de la clase base (en el ejemplo el método dibujar) el compilador genera un
error indicando que no se han implementado todos los métodos abstractos y que, o bien, se
implementan, o bien se declara la clase abstracta.
Referencias y objetos abstractos

Se pueden crear referencias a clases abstractas como cualquier otra. No hay ningún problema en
poner:
FiguraGeometrica figura;
Sin embargo una clase abstracta no se puede instanciar, es decir, no se pueden crear objetos de
una clase abstracta. El compilador producirá un error si se intenta:
FiguraGeometrica figura = newFiguraGeometrica();
Esto es coherente dado que una clase abstracta no tiene completa su implementación y encaja
bien con la idea de que algo abstracto no puede materializarse.
Código:
Revisión: 1

51 de 72
Sin embargo utilizando el up-casting visto en el capítulo dedicado a la Herencia si se puede

escribir:
FiguraGeometrica figura = newCirculo(. . .);
figura.dibujar();
La invocación al método dibujarse resolverá en tiempo de ejecución y la JVM llamará al método de
la clase adecuada. En nuestro ejemplo se llamará al método dibujarde la clase Circulo
Clases Abstractas.
Al ser utilizado Herencias ("Inheritance") y/o Polimorfismo es muy común que en la Clase Base
existan métodos diseñados únicamente con el propósito de ofrecer una guia para las Clases
heredadas, en Java existe un vocablo que permite prohibir el uso de métodos en Clases Base, este
calificativo es :abstract.Al ser definido un método como abstract se restringe que éste sea llamado
directamente, cuando una Clase contiene un método de este tipo a ésta se le llama: Clase
Abstracta.
Al ser definida una Clase, además de ser declarados los métodos/campos como abstract también
es necesario utilizar el vocablo abstract en la definición de cada Clase.
Clases Abstractas.
Una de las características de las Clases que Heredan("Inherit") de una Clase abstracta, es que
éstas deben definir los mismos métodos definidos en la Clase Base; en Java existe otro
mecanismo que permite llevar acabo diseños donde se parte de una Estructura o Cápsula.
• Los métodos definidos como abstract no contienen ningún tipo de código dentro de ellos,
inclusive no declaran ni llaves ({ }).
• Cuando es definido más de un método como abstract, es necesario que la Clase como tal sea
definida también como abstract.
La característica de hacer una Clase/Método abstract reside en que no puede ser generada una
instancia de la misma, este comportamiento se demuestra en el método principal (main)
• Aunque dentro del método sea generado un Arreglo de esta Clase abstracta, recuerde que un
arreglo es únicamente un contenedor de Objetos, esto permite que sea generado sin ningún error.
• Dentro de comentarios se encuentra la generación de una instancia del tipo Instrumento la cual
generaría un error al ser compilada la Clase.
-OBJETIVO
Crear una clase abstracta así como sus métodos e implementar sus clases derivadas con su propio
comportamiento.
Código:
Revisión: 1

52 de 72
-LUGAR
Sala de Cómputo
Semana 13
- MATERIAL Y EQUIPO
Equipo de cómputo
Eclipse
Problemática.
Emplee las clases desarrolladas para la solución de la práctica 3 para realizar los ajustes
requeridos para ésta práctica.
Paso 1. Realice los siguientes cambios a la clase Base para declarar e implementar métodos
abstractos
a) Transforme la clase Figura Geométrica colocando la palabra reservada abstrac a la clase y
el método.
abstract class FiguraGeometrica {

...
abstractvoid dibujar();
abstract calcularArea();
abstract calcularPerímetro();
...
Código:
Revisión: 1

53 de 72
Paso 2. Escriba la implementación de los métodos dibujar, calcularÁrea y calcularPerimetro en la

clase derivada.
class Circulo extends FiguraGeometrica {
...
void dibujar() {
// codigo para dibujar Circulo
...
}
Void calcularArea(){
// código para calcular el área correspondiente a la figura
}
Void calcularPerimetro(){
// código para calcular el área correspondiente a la figura
}
}
Paso 3. Cree una clase Main que contenga el método principal main().
Paso 4. Genere una instancia de la clase desde el main de acuerdo a lo siguiente:

FiguraGeometrica figura = new Circulo(5);
figura.dibujar();
figura.calcularArea();
figura.calcularPerimetro();
Paso 5. Compile y pruebe los resultados.
Paso 6. Genere un menú para que se puedan crear los tipos de figura de acuerdo a las solicitudes
del usuario, así mismo que se puedan asignar datos de acuerdo a lo que el usuario asigne, todo
esto se debe hacer manejando la entrada y salida estándar.
Paso 7. Compile y pruebe los resultados.

Código:
Revisión: 1

54 de 72
Se crea la clase base utilizando métodos abstractos 2
Se escriben los métodos abstractos de la clase base en las 2

clases derivadas
Se crean instancias y se llaman a métodos de las clases 2

derivadas
Se crea el menú solicitado 1
TOTAL 10
-REFERENCIAS
-ANEXOS
Código:
Revisión: 1

55 de 72
PRACTICA 9. ARREGLOS
-INTRODUCCIÓN
Los arreglos se pueden definir como objetos en los que podemos guardar más de una variable, es
decir, al tener un único arreglo, este puede guardar múltiples variables de acuerdo a su tamaño o
capacidad, es importante recordar que las variables guardadas deben ser del mismo tipo, por
ejemplo: Si tenemos un arreglo de tipo Numérico que puede almacenar 10 variables, solo podrá
almacenar 10 números diferentes, no otras variables como caracteres o Strings.
Un arreglo (array) es una colección de elementos del mismo tipo, que se almacenan en posiciones
consecutivas de memoria y reciben un nombre común. Para referirse a un determinado elemento
de un array se deberá utilizar un índice, que especifique su posición relativa en el array.
Un arreglo es una colección finita, homogénea y ordenada de elementos.
• Finita: Todo arreglo tiene un límite; es decir, debe determinarse cuál será el número máximo
de elementos que podrán formar parte del arreglo.
• Homogénea: Todos los elementos del arreglo deben ser del mismo tipo.
• Ordenada: Se puede determinar cuál es el primer elemento, el segundo, el tercero,.... y el n-
ésimo elmento.
Existen 2 tipos de arreglos, los unidimensionales, y los multidimensionales (2 o más dimenciones),

en esta práctica escribirás código para declarar y utilizar los arreglos.
Declaración:
La estructura de declaración de un arreglo es la siguiente:
tipo_dedato [] nombre_variable;
tipo_dato [][] nombre_variable2;
Las operaciones en arreglos pueden clasificarse de la siguiente forma:
• Lectura: este proceso consiste en leer un dato de un arreglo y asignar un valor a cada uno
de sus componentes
• Escritura: Consiste en asignarle un valor a cada elemento del arreglo.
Código:
Revisión: 1

56 de 72
• Asignación: No es posible asignar directamente un valor a todo el arreglo

• Actualización: Dentro de esta operación se encuentran las operaciones de eliminar, insertar
y modificar datos. Para realizar este tipo de operaciones se debe tomar en cuenta si el
arreglo está o no ordenado.
• Ordenación.
• Búsqueda.
• Insertar.
• Borrar.
• Modificar.
• Ordenaciones en Arreglos
La importancia de mantener nuestros arreglos ordenados radica en que es mucho más rápido
tener acceso a un dato en un arreglo ordenado que en uno desordenado.
Existen muchos algoritmos para la ordenación de elementos en arreglos, algunos de ellos son:
Selección directa
Este método consiste en seleccionar el elemento más pequeño de nuestra lista para colocarlo al
inicio y así excluirlo de la lista. Para ahorrar espacio, siempre que vayamos a colocar un elemento
en su posición correcta lo intercambiaremos por aquel que la esté ocupando en ese momento.
Ordenación por burbuja
Es el método de ordenación más utilizado por su fácil comprensión y programación, pero es

importante señalar que es el más ineficiente de todos los métodos. Este método consiste en llevar
los elementos menores a la izquierda del arreglo ó los mayores a la derecha del mismo. La idea
básica del algoritmo es comparar pares de elementos adyacentes e intercambiarlos entre sí hasta
que todos se encuentren ordenados.
Ordenación por mezcla
Este algoritmo consiste en partir el arreglo por la mitad, ordenar la mitad izquierda, ordenar la mitad
derecha y mezclar las dos mitades ordenadas en un array ordenado. Este último paso consiste en
ir comparando pares sucesivos de elementos (uno de cada mitad) y poniendo el valor más
pequeño en el siguiente hueco.
Código:
Revisión: 1

57 de 72
Al término de la práctica se busca que el alumno adquiera las competencias:
Específica(s):
Conoce y aplica programas que implementen el uso de arreglos para reconocerlos como una
herramienta para agrupar datos y facilitar la solución de problemas.
Genéricas:
• Capacidad de análisis y síntesis
• Habilidad para buscar y analizar información proveniente de fuentes diversas
• Solución de problemas
• Capacidad de aplicar los conocimientos en la práctica
• Capacidad de aprender.
-OBJETIVO
Crear aplicaciones que usen arreglos de diferentes dimensiones en la solución de problemas
entregando los códigos.
-LUGAR
Sala de cómputo.
Semana 13
- MATERIAL Y EQUIPO
Equipo de cómputo
Eclipse
Código:
Revisión: 1

58 de 72
Planteamiento del problema

a) Crea un programa que pida por pantalla cuatro caricaturas y a continuación los personajes
de cada uno de estos. Los nombres de cada caricatura deben asignarse a la primera
columna dentro de la fila y los personajes a las siguientes posiciones, se busca mostrar cada
caricatura con sus personajes, mostrar cuantos personajes tiene cada caricatura.
b) Realizar una calculadora de Arreglos que permita realizar las siguientes operaciones
1. Dado un arreglo de valores enteros ordenarlo utilizando dos métodos de ordenamiento
(burbuja, quicksort, etc).
2. Dada una matriz permita calcular el determinante
3. Dada una matriz obtener la matriz traspuesta.
4. Dada una matriz y un escalar realizar la multiplicación de ambos
Secuencia de la práctica
Paso 1. Crear la clase Practica9 con los atributos, constructores y métodos necesarios para
resolver la problemática planteada.
Paso 2. Declarar los arreglos y/o pasarlos como parámetros para los métodos que lo requieran
De la siguiente forma:
Declaración del arreglo de la problemática 1.
String caricaturas[][];
Paso 3. Dar valores al arreglo desde el constructor de acuerdo a lo siguiente:

public class Practica9{
// declaración de atributos
public Practica9( int f)
{
caricaturas = new String [v][];
}
Public Practica9()
{
Caricaturas = {{“Scooby Doo”, “Super Sonicos”,}{“vilma”, “Shaggui”, “Scooby”,
“Fred”}{“Super sónico”, “Lucero”, “Cometín”, “Jupiter”, “Robotina”},} // llenar el arreglo con otras
caricaturas y personajes de cada una de ellas.
Código:
Revisión: 1

59 de 72
}
}
Paso 4. Escribir los métodos necesarios para solucionar la problemática
Para la problemática a escribir lo métodos contar y mostrar. El método mostrar debe desplegar el
nombre de la caricatura seguido de sus personajes como se muestra a continuación.
Nombre de la Caricatura: Super Sonicos

Personajes:
1. Super sónico
2. Lucero
3. Cometín
4. Jupiter
5. Robotina
Para la problemática b escribir un método para cada acción solicitada con los parámetros
establecidos.
Paso 7. Escribir el método main que cree una instancia de la clase, llame los métodos escritos y
desplegarlos en pantalla, solicitar los valores al usuario y mandárselo a los métodos.
Paso 8. Compilar y ejecutar el programa.
Paso 9. Documentar los errores.
El alumno entregara un informe con la instalación del JDK y del IDE de acuerdo a los lineamientos
de informe técnico y sobre este se evaluará:

Código:
Revisión: 1

60 de 72
Crea las clases para las problemáticas planteadas con lo

requerido en el paso 1.
El código presenta la declaración y la inicialización de los

arreglos necesarios.
Asignarle valores iniciales a los arreglos.
Para cada problemática escribir los métodos solicitados.
Se escribe el método main instanciando la clase y llamando a

los métodos requeridos.
Se solicitan los valores a los usuarios y se mandan a los

métodos requeridos.
Se compila y ejecuta y se documentan en la bitácora los errores

y la solución implementada.
El programa despliega los valores esperados
TOTAL 10
El puntaje será divido de cada criterio equivale a la realización en ambos sistemas operativos
(LINUX y WINDOWS), en caso de solo presentar evidencia en un solo sistema operativo éste será
dividido entre dos. El alumno deberá presentar los códigos escritos.
-REFERENCIAS
-ANEXOS
Código:
Revisión: 1

61 de 72
PRACTICA 10. ARCHIVOS
-INTRODUCCIÓN
Un Flujo de E/S representa una fuente de entrada y un destino de salida. Un flujo puede
representar muchos tipos diferentes de fuentes y destinos, incluyendo archivos de disco,
dispositivos, otros programas y arreglos de memoria.
Los flujos soportan muchos tipos diferentes de datos, incluyendo bytes simples, tipos primitivos de
datos, caracteres localizados, y objetos. Algunos flujos simplemente pasan datos, otros manipulan
y transforman datos en formas útiles.
No importa cómo trabajan internamente; todos los flujos presentan el mismo modelo simple a los
programas que los usan: un flujo es una secuencia de datos. Un programa usa un flujo de entrada
para leer datos desde una fuente, o artículo a la vez:
Leyendo información hacia un programa.
Un programa usa un flujo de salida para escribir datos a su destino, o artículo a la vez: Escribiendo
información desde un programa.
Código:
Revisión: 1

62 de 72
La fuente y el destino de datos retratado arriba puede ser cualquier cosa que mantenga, genere o
consuma datos. Obviamente esto incluye archivos en disco, pero una fuente o destino puede
también ser otro programa, un dispositivo periférico, un socket de red, o un arreglo.
Normalmente, cuando se codifica un programa, se hace con la intención de que ese programa
pueda interactuar con los usuarios del mismo, es decir, que el usuario pueda pedirle que realice
cosas y pueda suministrarle datos con los que se quiere que haga algo. Una vez introducidos los
datos y las órdenes, se espera que el programa manipule de alguna forma esos datos para
proporcionarnos una respuesta a lo solicitado.
Además, en muchas ocasiones interesa que el programa guarde los datos que se le han
introducido, de forma que si el programa termina los datos no se pierdan y puedan ser recuperados
en una sesión posterior. La forma más normal de hacer esto es mediante la utilización de ficheros
que se guardarán en un dispositivo de memoria no volátil (normalmente un disco).
A todas estas operaciones, que constituyen un flujo de información del programa con el exterior, se
les conoce como Entrada/Salida (E/S).
Existen dos tipos de E/S; la E/S estándar que se realiza con el terminal del usuario y la E/S a
través de fichero, en la que se trabaja con ficheros de disco.
Todas las operaciones de E/S en Java vienen proporcionadas por el paquete estándar de la API de
Java denominado java.io que incorpora interfaces, clases y excepciones para acceder a todo tipo
de ficheros. En este tutorial sólo se van a dar algunas pinceladas de la potencia de este paquete.
B. Entrada/Salida estándar
Aquí sólo trataremos la entrada/salida que se comunica con el usuario a través de la pantalla o de
la ventana del terminal.
Si creamos una applet no se utilizarán normalmente estas funciones, ya que su resultado se
mostrará en la ventana del terminal y no en la ventana de la applet. La ventana de la applet es una
ventana gráfica y para poder realizar una entrada o salida a través de ella será necesario utilizar el
AWT.
El acceso a la entrada y salida estándar es controlado por tres objetos que se crean
automáticamente al iniciar la aplicación: System.in, System.out y System.err
Código:
Revisión: 1

63 de 72
a.) System.in
Este objeto implementa la entrada estándar (normalmente el teclado). Los métodos que nos
proporciona para controlar la entrada son:
• read(): Devuelve el carácter que se ha introducido por el teclado leyéndolo del buffer de
entrada y lo elimina del buffer para que en la siguiente lectura sea leído el siguiente
carácter. Si no se ha introducido ningún carácter por el teclado devuelve el valor -1.
• skip(n): Ignora losn caracteres siguientes de la entrada.
b.) System.out
Este objeto implementa la salida estándar. Los métodos que nos proporciona para controlar la
salida son:
• print(a): Imprime a en la salida, donde a puede ser cualquier tipo básico Java ya que Java
hace su conversión automática a cadena.
• println(a): Es idéntico a print(a) salvo que con println() se imprime un salto de línea al final de
la impresión de a.
c.) System.err
Este objeto implementa la salida en caso de error. Normalmente esta salida es la pantalla o la
ventana del terminal como con System.out, pero puede ser interesante redirigirlo, por ejemplo
hacia un fichero, para diferenciar claramente ambos tipos de salidas.
Las funciones que ofrece este objeto son idénticas a las proporcionadas por System.out.
d.) Ejemplo
A continuación vemos un ejemplo del uso de estas funciones que acepta texto hasta que se pulsa
el retorno de carro e informa del número de caracteres introducidos.
import java.io.*;
class CuentaCaracteres {
public static void main(String args[]) throws IOException {
int contador=0;
while(System.in.read()!='\n')
contador++;
System.out.println(); // Retorno de carro "gratuito"

Código:
Revisión: 1

64 de 72
System.out.println("Tecleados "+contador+" caracteres.");
C. Entrada/Salida por fichero
a.) Tipos de ficheros

En Java es posible utilizar dos tipos de ficheros (de texto o binarios) y dos tipos de acceso a los
ficheros (secuencial o aleatorio).
Los ficheros de texto están compuestos de caracteres legibles, mientras que los binarios pueden
almacenar cualquier tipo de datos (int, float, boolean,...).
Una lectura secuencial implica tener que acceder a un elemento antes de acceder al siguiente, es
decir, de una manera lineal (sin saltos). Sin embargo los ficheros de acceso aleatorio permiten
acceder a sus datos de una forma aleatoria, esto es indicando una determinada posición desde la
que leer/escribir.
b.) Clases a estudiar

En el paquete java.io existen varias clases de las cuales podemos crear instancias de clases para
tratar todo tipo de ficheros.
• FileOutputStream: Fichero de salida de texto. Representa ficheros de texto para escritura a
los que se accede de forma secuencial.
• FileInputStream: Fichero de entrada de texto. Representa ficheros de texto de sólo lectura a
los que se accede de forma secuencial.
• RandomAccessFile: Fichero de entrada o salida binario con acceso aleatorio. Es la base
para crear los objetos de tipo fichero de acceso aleatorio. Estos ficheros permiten
multitud de operaciones; saltar hacia delante y hacia atrás para leer la información que
necesitemos en cada momento, e incluso leer o escribir partes del fichero sin necesidad
de cerrarlo y volverlo a abrir en un modo distinto.
c.) Generalidades
Para tratar con un fichero siempre hay que actuar de la misma manera:
1. Se abre el fichero.
Para ello hay que crear un objeto de la clase correspondiente al tipo de fichero que vamos a
manejar, y el tipo de acceso que vamos a utilizar:
TipoDeFichero obj = new TipoDeFichero( ruta );
Donde ruta es la ruta de disco en que se encuentra el fichero o un descriptor de fichero válido.
Este formato es válido, excepto para los objetos de la clase RandomAccessFile (acceso aleatorio),
para los que se ha de instanciar de la siguiente forma:
RandomAccessFile obj = new RandomAccessFile( ruta, modo );
Código:
Revisión: 1

65 de 72
Donde modo es una cadena de texto que indica el modo en que se desea abrir el fichero; "r" para
sólo lectura o "rw" para lectura y escritura.
2. Se utiliza el fichero.
Para ello cada clase presenta diferentes métodos de acceso para escribir o leer en el fichero.
3. Gestión de excepciones (opcional, pero recomendada)
Se puede observar que todos los métodos que utilicen clases de este paquete deben tener en su
definición una cláusula throws IOException. Los métodos de estas clases pueden lanzar
excepciones de esta clase (o sus hijas) en el transcurso de su ejecución, y dichas excepciones
deben de ser capturadas y debidamente gestionadas para evitar problemas.
4. Se cierra el fichero y se destruye el objeto.
Para cerrar un fichero lo que hay que hacer es destruir el objeto. Esto se puede realizar de dos
formas, dejando que sea el recolector de basura de Java el que lo destruya cuando no lo necesite
(no se recomienda) o destruyendo el objeto explícitamente mediante el uso del procedimiento
close() del objeto:
obj.close()
d.) La clase FileOutputStream

Mediante los objetos de esta clase escribimos en ficheros de texto de forma secuencial.
Presenta el método write() para la escritura en el fichero. Presenta varios formatos:
• int write( int c ): Escribe el carácter en el fichero.
• int write( byte a[] ): Escribe el contenido del vector en el fichero.
• int write( byte a[], int off, int len ): Escribe len caracteres del vector a en el fichero,
comenzando desde la posición off.
El siguiente ejemplo crea el fichero de texto "/carta.txt" a partir de un texto que se le introduce por
teclado:
import java.io.*;
class CreaCarta {
public static void main(String args[]) throws IOException{
int c;
FileOutputStream f=new FileOutputStream("/carta.txt");
while( ( c=System.in.read() ) != -1 )
f.write( (char)c );
f.close();
}
Código:
Revisión: 1

66 de 72
e.) La clase FileInputStream

Mediante los objetos de esta clase leemos de ficheros de texto de forma secuencial.
Presenta el método read() para la lectura del fichero. Este método se puede invocar de varias
formas.
• int read(): Devuelve el siguiente carácter del fichero.
• int read( byte a[] ): Llena el vector a con los caracteres leídos del fichero. Devuelve la
longitud del vector que se ha llenado si se realizó con éxito o –1 si no había suficientes caracteres
en el fichero para llenar el vector.
• int read( byte a[], int off, int len ): Lee len caracteres del fichero, insertándolos en el vector a.
Todos ellos devuelven -1 si se ha llegado al final del fichero (momento de cerrarle).
El siguiente ejemplo muestra el fichero de texto "/carta.txt" en pantalla:
import java.io.*;
class MuestraCarta {
public static void main(String args[]) throws IOException {
int c;
FileInputStream f=new FileInputStream("/carta.txt");
while( ( c=f.read() ) != -1 )
System.out.print( (char)c );
f.close();
f.) La clase RandomAccessFile

Mediante los objetos de esta clase utilizamos ficheros binarios mediante un acceso aleatorio, tanto
para lectura como para escritura. En estos ficheros hay un índice que nos dice en qué posición del
fichero nos encontramos, y con el que se puede trabajar para posicionarse en el fichero.
Métodos de desplazamiento
Cuenta con una serie de funciones para realizar el desplazamiento del puntero del fichero. Hay que
tener en cuenta que cualquier lectura o escritura de datos se realizará a partir de la posición actual
del puntero del fichero.
• long getFilePointer();Devuelve la posición actual del puntero del fichero.
Código:
Revisión: 1

67 de 72
• void seek( long l ); Coloca el puntero del fichero en la posición indicada por l. Un fichero
siempre empieza en la posición 0.
• int skipBytes( int n ); Intenta saltar n bytes desde la posición actual.
• long length(); Devuelve la longitud del fichero.
• void setLength( long l); Establece a l el tamaño de este fichero.
• FileDescriptor getFD(); Devuelve el descriptor de este fichero.
Métodos de escritura
La escritura del fichero se realiza con una función que depende el tipo de datos que se desee
escribir.
• void write( byte b[], int ini, int len ); Escribe len caracteres del vector b.
• void write( int i ); Escribe la parte baja de i (un byte) en el flujo.
• void writeBoolean( boolean b ); Escribe el boolean b como un byte.
• void writeByte( int i ); Escribe i como un byte.
• void writeBytes( String s ); Escribe la cadena s tratada como bytes, no caracteres.
• void writeChar( int i ); Escribe i como 1 byte.
• void writeChars( String s ); Escribe la cadena s.
• void writeDouble( double d ); Convierte d a long y le escribe como 8 bytes.
• void writeFloat( float f ); Convierte f a entero y le escribe como 4 bytes.
• void writeInt( int i ); Escribe i como 4 bytes.
• void writeLong( long v ); Escribe v como 8 bytes.
• void writeShort( int i ); Escribe i como 2 bytes.
• void writeUTF( String s ); Escribe la cadena s utilizando la codificación UTF-8.
Los métodos que escriben números de más de un byte escriben el primero su parte alta.
Métodos de lectura
La lectura del fichero se realiza con una función que depende del tipo de datos que queremos leer.
• boolean readBoolean(); Lee un byte y devuelve false si vale 0 o true sino.
• byte readByte(); Lee y devuelve un byte.
• char readChar(); Lee y devuelve un caracter.
• double readDouble(); Lee 8 bytes, y devuelve un double.
• float readFloat(); Lee 4 bytes, y devuelve un float.
• void readFully( byte b[] ); Lee bytes del fichero y los almacena en un vector b.
• void readFully( byte b[], int ini, int len ); Lee len bytes del fichero y los almacena en un vector
b.
• int readInt(); Lee 4 bytes, y devuelve un int.
• long readLong(); Lee 8 bytes, y devuelve un long.
• short readShort(); Lee 2 bytes, y devuelve un short.
• int readUnsignedByte(); Lee 1 byte, y devuelve un valor de 0 a 255.
• int readUnsignedShort(); Lee 2 bytes, y devuelve un valor de 0 a 65535.
• String readUTF(); Lee una cadena codificada con el formato UTF-8.
• int skipBytes(int n); Salta n bytes del fichero.
Si no es posible la lectura devuelven –1.
Código:
Revisión: 1

68 de 72
-OBJETIVO
Implementar aplicaciones orientadas a objetos que creen y manipulen archivos para guardar y
recuperar información
-LUGAR
Sala de Cómputo
Semana 12 y 13
- MATERIAL Y EQUIPO
Equipo de cómputo
Eclipse
Problemáticas.
Caso 1.
Se sabe que a las 9 de la mañana la temperatura es de 12 grados, y durante la tarde desciende 15
grados hasta las 8 de la noche.
Tu trabajo es realizar un programa para que dados estos 4 valores indiques la temperatura
después de haber descendido.
Código:
Revisión: 1

69 de 72
Entrada:
EL programa recibirá n líneas que contendrán 4 valores enteros A, B, C, D, donde A es la hora
inicial, B es la temperatura inicial,
C es la temperatura de descenso y D es la hora final el programa terminará con 0.
Ejemplo
9 12 15 8
0
Salida:
La salida contendrá el valor de la temperatura al descenso en una línea que diga:
Ejemplo
La temperatura a las 8 de la noche es de -3 grados.
Caso 2.
Pedro es un niño muy inteligente y le gusta adivinar las edades de las personas, pero para poder
tener un margen de éxito pide a dos personas que le digan sus edades y cuál es la diferencia entre
ellas y con esto puede en menos de un minuto acertar la edad de cada uno.
Para hacer una prueba Juan y a Víctor le dicen que sus edades sumadas dan 84 y la diferencia de
edades entre ambos es de 8 inmediatamente Pedro les responde que uno tiene 46 y el otro 38,
asombrados ellos quieren tu ayuda para hacer un programa que permita realizar esto.
Entrada:
Como dato de entrada se proporcionará n líneas, cada una contendrá 2 valores P y Q, p
corresponde a la cantidad en años de dos personas y Q la diferencia en años, y un cero para
terminar el programa.
Ejemplo
45 3
24 2
0
Salida:
A la salida se espera por cada línea de entrada una línea que contenga las edades de las dos
personas.
Ejemplo
21 24
11 13
Ejercicio 3
Código:
Revisión: 1

70 de 72
Realizar un programa para que dado un número, lo divida en tres partes A, B, C que cumplan que
B es el tripe de A y 40 unidades mayor que C.
Entrada:
EL programa recibirá n líneas que contendrán valores enteros, la entrada finalizará con 0.
Ejemplo
65
352
198
0
La salida contendrá los valores de A, B y C separados por espacios en blanco.
Ejemplo
15 45 5
56 168 128
34 102 62
Paso 1. Escriba la clase que contenga 3 métodos:

readCase() que reciba una línea correspondiente a un caso de prueba y asigne los valores a los
atributos, retorne un valor verdadero si no existe problemas en la lectura o en caso contrario falso.
solveCase() este método debe contener la solución a la problemática planteada
print() éste método debe almacenar línea a línea los resultados en un archivo y retornar un String
con los resultados del método solveCase()
Paso 2. Escriba el método main y abra un flujo de entrada para leer de un archivo llamado
entrada.in las líneas de prueba.
Paso 3. Escriba un ciclo para invocar al método readCase, solveCase, print
Paso 4. Escriba el código para hacer funcional el método readCase
Paso 5. Escriba el código para hacer funcional el método solveCase
Paso 6. Escriba el código para hacer funcional el método print almacenando la información en un
archivo llamado “salida.out”
Paso 7. Escriba el código para manejar las excepciones derivadas del manejo de archivos
Paso 8. Compile y pruebe el código.
Paso 9. Realice los mismos pasos para los casos 2 y 3.
Código:
Revisión: 1

71 de 72
Escribe la clase con los 3 métodos solicitados para cada caso. 1
Escriba los flujos para leer el archivo 1
Escriba la funcionalidad de los métodos solicitados 1
Los métodos resuelven las problemáticas planteadas 2
El método print crea un flujo de salida para almacenar los 1

resultados
Escriba el tratamiento de excepciones para la manipulación de 1

flujos
El código funciona y soluciona la problemática planteada 1
Se presenta la solución para los tres casos 2
TOTAL 10
-REFERENCIAS
-ANEXOS
Código:
Revisión: 1

72 de 72

R 130978

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

R 130978

Uploaded by

Copyright:

Available Formats

Código:

Dirección Académica CPE-FO-02-03

MANUAL DE PRÁCTICAS Página:

MANUAL DE PRÁCTICAS DE PROGRAMACIÓN ORIENTADA A OBJETOS

Calkiní, Campeche, Enero 2016

Revisó Aprobó Autorizó

DR. GONZALO MIGUEL QUETZ

MANUAL DE PRÁCTICAS Página:

OBJETIVO GENERAL ............................................................................................................................. 4

PRACTICA 1. INSTALACION DEL ENTORNO DE DESARROLLO .............................................................. 6

PRACTICA 2. CONOCIMIENTO DEL LENGUAJE................................................................................... 11

-ANEXOSPRACTICA 3. CLASES Y OBJETOS ......................................................................................... 15

PRACTICA 4. CLASES Y OBJETOS ........................................................................................................ 21

PRACTICA 5. MANEJO DE EXCEPCIONES ........................................................................................... 28

PRACTICA 6. HERENCIA .................................................................................................................... 34

PRACTICA 7. HERENCIA: CONSTRUCTORES Y DESTRUCTORES.......................................................... 45

PRACTICA 10. ARCHIVOS ................................................................................................................... 61

MANUAL DE PRÁCTICAS Página:

La programación orientada a objetos es una “filosofía”, un modelo de programación, un

La filosofía de la programación orientada a objetos ve a un programa como un conjunto de

MANUAL DE PRÁCTICAS Página:

En este manual de prácticas se estudiarán los objetos, clases, herencia, polimorfismo,

Las prácticas relacionadas a herencia y polimorfismo permiten la reutilización de código

MANUAL DE PRÁCTICAS Página:

Queda prohibido introducir a la Sala de Computo alimentos y bebidas.

MANUAL DE PRÁCTICAS Página:

PRACTICA 1. INSTALACION DEL ENTORNO DE DESARROLLO

Cuando se programa con Java, se dispone de antemano de un conjunto de clases ya

MANUAL DE PRÁCTICAS Página:

Instalar un IDE para desarrollo de código JAVA.

MANUAL DE PRÁCTICAS Página:

Manual de instalación de JDK y del eclipse

Paso 1. Descargar de la página oficial el instalador de JDK para WINDOWS

public class MiHolaMundo{

Paso 8. Instalar un IDE (eclipse o netbeans), probarlo con el programa MiHolaMundo

MANUAL DE PRÁCTICAS Página:

Criterio Puntaje Puntaje Obtenido

Indica la página oficial donde realizó la descarga así como la 0.5

Muestra evidencia de la configuración realizada al PATH y 1.5

Muestra evidencia de la Compilación y ejecución del programa 2.5

Prueba el IDE ejecutando el programa descrito en el paso 6 1.5

MANUAL DE PRÁCTICAS Página:

objetos, I. a. (1999). Juan Manuel Cueva Lovelle. España: Universidad de Oviedo.

Schemuller, J. (s.f.). UML en 24 Horas. Prentice Hall.

MANUAL DE PRÁCTICAS Página:

PRACTICA 2. CONOCIMIENTO DEL LENGUAJE

La organización de los archivos en carpetas y la presencia de otros adicionales dependen del

El concepto de paquete viene siendo similar al de carpeta en Windows: un contenedor donde

MANUAL DE PRÁCTICAS Página:

. . . public class miClase { . . .

Al finalizar la se espera que el alumno logre las siguientes competencias:

Conoce y aplica la estructura de proyectos en un entorno de desarrollo para la solución de

 Comunicación oral y escrita

 Habilidades del manejo de la computadora

 Capacidad de aplicar los conocimientos en la práctica

 Habilidad para trabajar en forma autónoma

MANUAL DE PRÁCTICAS Página:

Aplicar las fases del proceso de desarrollo de aplicaciones en la resolución de ejercicios.

MANUAL DE PRÁCTICAS Página:

Paso 1. Plantea una solución escrita para la problemática planteada.

Paso 5. Crea una nueva clase con el nombre Practica2.

22 pesos mexicanos equivalen a 1.20 dólares