Manual de Prácticas V3 Feb 2020

Código: CPE-FO-
02-03
Dirección Académica
Revisión: 1
Página:
MANUAL DE PRÁCTICAS
1 de 58
MANUAL DE PRÁCTICAS DE PROGRAMACIÓN ORIENTADA A OBJETOS
PROGRAMA EDUCATIVO:
INGENIERIA EN SISTEMAS COMPUTACIONALES
Calkiní, Campeche, Enero 2020
Revisó Aprobó Autorizó
DR. GONZALO MIGUEL QUETZ

AGUIRRE DR. JOSE LUIS LIRA TURRIZA DR. MIGUEL ANGEL COHUO
Presidente de Academia Coordinador del PE ÁVILA
Código: CPE-FO-
02-03
Revisión: 1
Página:
2 de 58
ÍNDICE
Contenido
PRESENTACIÓN.....................................................................................................................................................3
OBJETIVO GENERAL..............................................................................................................................................4
SEGURIDAD...........................................................................................................................................................5
PRACTICA 1. DIAGRAMA DE CLASES.....................................................................................................................6
PRACTICA 2. CLASES Y OBJETOS.........................................................................................................................11
PRACTICA 3. CLASES Y METODOS.......................................................................................................................19
PRACTICA 4. HERENCIA......................................................................................................................................27
PRACTICA 5. HERENCIA: CONSTRUCTORES Y DESTRUCTORES...........................................................................37
PRACTICA 6. POLIMORFISMO.............................................................................................................................42
PRACTICA 7. MANEJO DE EXCEPCIONES............................................................................................................47
PRACTICA 8. ARCHIVOS......................................................................................................................................53
Código: CPE-FO-
02-03
Revisión: 1
Página:
3 de 58
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
Código: CPE-FO-
02-03
Revisión: 1
Página:
4 de 58
implementar objetos de programación que permitan resolver situaciones reales y de

ingeniería.
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
comprender, describir y modelar los conceptos principales del paradigma de programación
orientado a objetos y aplicarlos a situaciones de la vida real, por lo que el alumno deberá
realizar en un software de modelado UML diagramas de casos de uso, de clases y de
secuencia
Las prácticas que corresponden a la segunda unidad permiten al alumno aprender 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.
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.
Los problemas suscitados en tiempo de ejecución son tratados en las prácticas de

programación bajo el tema “manejo de excepciones”.
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: CPE-FO-
02-03
Revisión: 1
Página:
5 de 58
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.
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.
PRACTICA 1. DIAGRAMA DE CLASES
-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).
Código: CPE-FO-
02-03
Revisión: 1
Página:
6 de 58
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.
-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 DE EJECUCIÓN
Semana 2
- MATERIAL Y EQUIPO
Computadora
Manual de UML
Software Enterprise Architect o software libre para diagramas UML (BoUML, ArgoUML u otra)
Código: CPE-FO-
02-03
Revisión: 1
Página:
7 de 58
-DESARROLLO DE LA PRÁCTICA
El profesor describirá una problemática relacionada a un juego de mesa y describirá al alumno los
componentes del juego, los participantes y las reglas de operación de este. Como ejemplo se
presenta la siguiente problemática.
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 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 describir y modelar una situación similar a esta propuesta con los datos
proporcionados por el profesor.
Paso 1.
Genere una tabla con las clases de objetos, sus atributos y las acciones que pueden realizar de
acuerdo con la situación planteada como se muestra en el ejemplo.
Clases de objetos Atributos Verbos

1. Carta número
nombre
figura
2. Mazo Cartas barajear ordenar
extraercarta
Código: CPE-FO-
02-03
Revisión: 1
Página:
8 de 58
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 en el ejemplo.
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 (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.
- EVALUACIÓN Y RESULTADOS
Criterio Puntaje Puntaje Obtenido
Análisis: El diagrama presenta todas las clases definidas en la 5

tabla
Análisis: EL diagrama de cada clase especifica los atributos y 10

sus tipos de acuerdo con la tabla
Código: CPE-FO-
02-03
Revisión: 1
Página:
9 de 58
Desarrollo: Cada clase contiene los métodos identificados 10
Desarrollo: Cada método contiene la lista de parámetros 10

esperados
Desarrollo: Cada método contiene el valor de retorno 10
Desarrollo: Los nombres de la clase, atributos y métodos siguen 10

la convención de nombrado
Desarrollo y resultados: Las clases presenta las relaciones 10

existentes entre ellas
Desarrollo y resultados: Las clases presentan la cardinalidad 5
correspondiente
Desarrollo y resultados: Se presenta el código generado acorde 25

al diagrama.
Comunicación oral y escrita con habilidades de investigación 2
Habilidades de Organización con uso de Tics y trabajo en 3

equipo
TOTAL 100
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
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
PRACTICA 2. CLASES Y OBJETOS

Código: CPE-FO-
02-03
Revisión: 1
Página:
10 de 58
-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.
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).
Código: CPE-FO-
02-03
Revisión: 1
Página:
11 de 58
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.
-OBJETIVO
Programar clases con atributos y métodos que utilicen distintos modificadores de acceso
empleando constructores y métodos sobrecargados con la finalidad comprenderla.
Código: CPE-FO-
02-03
Revisión: 1
Página:
12 de 58
-LUGAR
Sala de Cómputo
Semana 3.
- MATERIAL Y EQUIPO
Editor de texto (Bloc de notas,vi, gedit)
Equipo de cómputo
Descripción de la problemática
En una casa se tienen diversos objetos (horno, estufa, refrigerador, licuadora, puerta, ventilador,
elevador, etc)
Paso 1. Elegir uno de los tipos de objetos, abstrayendo y construir con la información la tabla.
Atributos Comportamientos
1. 1.
2. 2.
3. 3.
Código: CPE-FO-
02-03
Revisión: 1
Página:
13 de 58
4. 4.
5. 5.
Paso 2. De acuerdo con 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 con el diagrama como se muestra a continuación:
a) Definir la clase con el nombre
b) Definir los atributos para la clase indicados en el diagrama de acuerdo con 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.
d) Escribir los métodos set y get para asignar y devolver los valores a los atributos declarados
en las variables.
El programa debe quedar de acuerdo a la siguiente estructura:

public class NombreDeMiClase{
// Definición de atributos
String atrib1; boolean
atrib1; // Definición de métodos
//Constructor
public NombreDeMiClase(String m) // lista de parametros
{
atrib1 = (m.equals(“”))? “Steren”: m;
atrib2 = false;
}
// declaración de métodos para asignar u obtener los valores de los atributos
public void setAtrib1(String m) // asignar un valor al atributo
{
atrib1 = (m.equals(“”))? “Steren”: m;
}
public String getAtrib1() //devolver el valor del atributo
{
Código: CPE-FO-
02-03
Revisión: 1
Página:
14 de 58
return atrib1;
}
// 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 4. Escribir los métodos para dar funcionalidad a la clase (comportamientos descritos en el
diagrama) usando tipos de datos simples y objetos como parámetros y valores de retorno, así
como métodos sin valores de retorno.
Paso 5. Escribir la funcionalidad de los métodos para que pueda implementar los comportamientos
establecidos.
Paso 6. 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 que el instrumento realiza la acción.
Paso 7. Compilar y ejecutar el programa anotando en la bitácora los errores de compilación y

ejecución, así como su solución. Mostrar los resultados en consola.
Paso 8. Intercambiar clases con al menos 5 compañeros para usar sus miembros con valores y
situaciones erróneas que evidencien la necesidad de protegerlos con modificadores de acceso.
Paso 9. Modificar el código fuente de la clase original aplicando los distintos niveles de acceso para
experimentar y descubrir el impacto de cada uno de ellos. Registrar los resultados.
Paso 10. Implementar la clase Persona con los atributos nombre y edad, un constructor, un
destructor y al menos un método crecer para mapear el ciclo de vida de una persona con el de un
objeto.
Paso 11. Implementar la clase calculadora que realice al menos cuatro operaciones básicas
sobrecargando métodos para cada tipo de dato numérico.
Documentar todos los pasos en una bitácora.

Código: CPE-FO-
02-03
Revisión: 1
Página:
15 de 58
El alumno deberá presenta un programa y los resultados de acuerdo a la siguiente tabla:

Análisis: Se escribe los nombres de la clase, métodos, atributos de 15

acuerdo con la convención establecida.
Se escriben al menos 4 atributos para la clase con sus tipos de
datos definidos de forma correcta.
Desarrollo y resultados: Escribe la clase de acuerdo con diagrama. 80

Se utiliza de forma correcta la declaración de métodos para la
clase.
Se escriben al menos dos constructores para la clase
Se escriben los métodos necesarios para realizar las acciones
descritas en la problemática (funcionalidad del método)
Se utilizan los métodos set y get para asignar y devolver valores
Se crea al menos 2 instancias de la clase probando el acceso a
sus funcionalidades.
Se utiliza sobrecarga para un método de la clase diferente al
constructor. (paso 11)
Se modifican los valores de los atributos a través de la llamada a
sus métodos
Compilar y ejecutar el programa anotando en la bitácora los
errores de compilación y ejecución Modificaciones al código fuente.
(Paso 9)
Habilidades de Organización con uso de Tics y trabajo en equipo. 3

Intercambia con sus compañeros de equipo sus clases (Paso 8)
TOTAL 100
generados por el programa.
Código: CPE-FO-
02-03
Revisión: 1
Página:
16 de 58
-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: CPE-FO-
02-03
Revisión: 1
Página:
17 de 58
PRACTICA 3. CLASES Y METODOS
-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.
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).
Código: CPE-FO-
02-03
Revisión: 1
Página:
18 de 58
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.
-OBJETIVO
Programar clases con atributos y métodos que utilicen distintos modificadores de acceso
empleando constructores y métodos sobrecargados con la finalidad comprenderla
Código: CPE-FO-
02-03
Revisión: 1
Página:
19 de 58
-LUGAR
Sala de Cómputo
Semana 7.
- MATERIAL Y EQUIPO
Editor de texto (Bloc de notas,vi, gedit)
Equipo de cómputo
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
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 con la problemática identifique atributos y comportamientos del termómetro

digital y llene la tabla siguiente:
Código: CPE-FO-
02-03
Revisión: 1
Página:
20 de 58
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

requeridos.
Paso 3. El alumno escribirá la clase de acuerdo al diagrama como se muestra a continuación:
e) Definir la clase con el nombre TermómetroDigital
f) 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;
g) Escribir el constructor de la clase recibiendo al menos un parámetro para asignar valor a un

atributo del termómetro.
h) Escribir los métodos set y get para asignar y devolver los valores a los atributos declarados
en las variables.
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;
Código: CPE-FO-
02-03
Revisión: 1
Página:
21 de 58
}
// 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;
}
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.
Código: CPE-FO-
02-03
Revisión: 1
Página:
22 de 58
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 con la siguiente tabla:
Análisis: Se escribe los nombres de la clase, métodos, atributos de 15

acuerdo con la convención establecida
Análisis: Se escriben al menos 4 atributos para la clase con sus
tipos de datos definidos de forma correcta.
Desarrollo: Se utiliza de forma correcta la declaración de métodos 30
para la clase (5)
Desarrollo: Se escriben los métodos necesarios para realizar las
acciones descritas en la problemática (funcionalidad del método) (5)
Desarrollo: Se escriben al menos dos constructores para la clase
(5)
Desarrollo: Se utiliza sobrecarga para un método de la clase
diferente al constructor (5)
Desarrollo y resultados: Se utilizan los métodos set y get para
asignar y devolver valores (5)
Desarrollo y resultados: Se crea al menos 2 instancias de la clase
(5)
Resultados: Se modifican los valores de los atributos a través de los 5
métodos
Resultados: Se invoca al método para 10
medir diferentes temperaturas y almacenarlas
Resultados: Se llama al método para cambiar de unidad la 10
temperatura medida
Resultados: Se llama al método para visualizar los resultados 10
Resultados: Se muestran las temperaturas extremas y el promedio 5

de ellas
Código: CPE-FO-
02-03
Revisión: 1
Página:
23 de 58
Resultados : Realiza el paso 8 10
Habilidades de Organización con uso de Tics y trabajo en equipo 3
TOTAL 100
generados por el programa.
-REFERENCIAS
-ANEXOS
Código: CPE-FO-
02-03
Revisión: 1
Página:
24 de 58
PRACTICA 4. 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 un interfaz gráfico de usuario
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.
Código: CPE-FO-
02-03
Revisión: 1
Página:
25 de 58
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;
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;
Código: CPE-FO-
02-03
Revisión: 1
Página:
26 de 58
this.ancho=ancho;
this.alto=alto;
public void mostrar(){
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;
}
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 la función 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.
Código: CPE-FO-
02-03
Revisión: 1
Página:
27 de 58
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;
Redefine la función miembro mostrar para mostrar una ventana con un título.
public void mostrar(){ 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
System.out.println("titulo : "+titulo); mostrar();
La definición de la clase derivada VentanaTitulo, será la siguiente.
package ventana;
Código: CPE-FO-
02-03
Revisión: 1
Página:
28 de 58
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;
public void mostrar()
{ super.mostrar();
System.out.println("titulo : "+titulo);
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();
try {
Código: CPE-FO-
02-03
Revisión: 1
Página:
29 de 58
//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.
-LUGAR
Sala de Cómputo
Código: CPE-FO-
02-03
Revisión: 1
Página:
30 de 58
Semana 6
- MATERIAL Y EQUIPO
Equipo de cómputo
Editor de texto (Bloc de notas,vi, gedit, scite)
Eclipse
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.
Paso 1. De acuerdo a la problemática identifique atributos y comportamientos de la clase Base

(Figura Geométrica)
1. 1.
2. 2.
3. 3.
4. 4.
5. 5.
Código: CPE-FO-
02-03
Revisión: 1
Página:
31 de 58
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

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.
Análisis: Identifica los atributos y métodos de la clase base y de 15

las clases derivadas y los plasma en la tabla.
Código: CPE-FO-
02-03
Revisión: 1
Página:
32 de 58
Desarrollo y ResultadosIdentifica los atributos y métodos de la 80

clase base y de las clases derivadas y los plasma en la tabla.
Realiza el diagrama de clases correspondiente a la

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

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

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

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

derivadas
Las clases compilan sin errores
Se ejecuta y muestra los resultados
2
Comunicación oral y escrita con habilidades de investigación
equipo
TOTAL 100
El alumno deberá presentar los códigos generados por el programa y las pantallas con los
resultados en un informe.
-REFERENCIAS
-ANEXOS
Código: CPE-FO-
02-03
Revisión: 1
Página:
33 de 58
PRACTICA 5. 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.
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
Código: CPE-FO-
02-03
Revisión: 1
Página:
34 de 58
Implementar los constructores de clase Base y clases Derivadas
-LUGAR
Sala de Cómputo
Semana 7
- MATERIAL Y EQUIPO
Equipo de cómputo
Eclipse
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ódigo: CPE-FO-
02-03
Revisión: 1
Página:
35 de 58
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.
Análisis: Identifica los atributos y métodos de la clase base y de 15

las clases derivadas y los plasma en la tabla.
Código: CPE-FO-
02-03
Revisión: 1
Página:
36 de 58
Desarrollo y resultados: Se escribe la clase base con sus 80

atributos y métodos, se 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

interfaz correspondiente
Se crean las clases derivadas solicitadas conteniendo los

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

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

derivadas
2
equipo
TOTAL 100
El alumno deberá los códigos fuente generados para solucionar el problema planteado.
-REFERENCIAS
-ANEXOS
Código: CPE-FO-
02-03
Revisión: 1
Página:
37 de 58
Código: CPE-FO-
02-03
Revisión: 1
Página:
38 de 58
PRACTICA 6. 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.
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
Código: CPE-FO-
02-03
Revisión: 1
Página:
39 de 58
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.
-LUGAR
Sala de Cómputo
Código: CPE-FO-
02-03
Revisión: 1
Página:
40 de 58
Semana 8
- 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();
...
}
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
...
}
Código: CPE-FO-
02-03
Revisión: 1
Página:
41 de 58
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.
Analiza la situación y plantea una solución 15

Código: CPE-FO-
02-03
Revisión: 1
Página:
42 de 58
Se crea la clase base utilizando métodos abstractos 80
Se escriben los métodos abstractos de la clase base en las

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

derivadas
Se crea el menú solicitado
2
equipo
TOTAL 100
El alumno deberá presentar los códigos fuente generados para solucionar el problema y las
pantallas de resultado en un informe.
-REFERENCIAS
-ANEXOS
PRACTICA 7. 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
Código: CPE-FO-
02-03
Revisión: 1
Página:
43 de 58
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.
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.
Código: CPE-FO-
02-03
Revisión: 1
Página:
44 de 58
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 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.
Código: CPE-FO-
02-03
Revisión: 1
Página:
45 de 58
-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 11
- MATERIAL Y EQUIPO
Equipo de cómputo
Eclipse
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{

Código: CPE-FO-
02-03
Revisión: 1
Página:
46 de 58
//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) 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.
Código: CPE-FO-
02-03
Revisión: 1
Página:
47 de 58
Análisis del Problema 15
Se crean la clase con los métodos solicitados 80
Se crea el código para manejar la Excepción Aritmética
Se crea la clase ValorFueraDeRango con el mensaje propio
Se genera la excepción ValorFueraDeRango
Se lanza la excepción fuera del método
Se trata la excepción en el bloque donde fue invocado
Se escribe el código para tratar y manejar excepciones sobre el

arreglo de almacenamiento
Implementa el bloque finally y el método printStackTrace
2
equipo
TOTAL 100
-REFERENCIAS
-ANEXOS
Código: CPE-FO-
02-03
Revisión: 1
Página:
48 de 58
PRACTICA 8. 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: CPE-FO-
02-03
Revisión: 1
Página:
49 de 58
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
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:
Código: CPE-FO-
02-03
Revisión: 1
Página:
50 de 58
• 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"
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
Código: CPE-FO-
02-03
Revisión: 1
Página:
51 de 58
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 );
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:
Código: CPE-FO-
02-03
Revisión: 1
Página:
52 de 58
• 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();
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");
Código: CPE-FO-
02-03
Revisión: 1
Página:
53 de 58
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.
• 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
Código: CPE-FO-
02-03
Revisión: 1
Página:
54 de 58
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.
-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
Código: CPE-FO-
02-03
Revisión: 1
Página:
55 de 58
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.
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.
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.
Caso 2.
Código: CPE-FO-
02-03
Revisión: 1
Página:
56 de 58
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
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
Código: CPE-FO-
02-03
Revisión: 1
Página:
57 de 58
Analiza el problema 15
Escribe la clase con los 3 métodos solicitados para cada caso. 80
Escribe los flujos para leer el archivo
Escribe la funcionalidad de los métodos solicitados
Los métodos resuelven las problemáticas planteadas
El método print crea un flujo de salida para almacenar los

resultados
Escribe el tratamiento de excepciones para la manipulación de

flujos
El código funciona y soluciona la problemática planteada
Se presenta la solución para los tres casos
Tiene comunicación oral y escrita con habilidades de 2

investigación
Tienen habilidades de organización con uso de Tics y trabajo 3
en equipo
TOTAL 100
-REFERENCIAS

Javier, C. S. (2012). Java 2 curso de programación. Alfaomega. Schemuller,
J. (s.f.). UML en 24 Horas. Prentice Hall.
-ANEXOS
Código: CPE-FO-
02-03
Revisión: 1
Página:
58 de 58

Manual de Prácticas V3 Feb 2020

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Manual de Prácticas V3 Feb 2020

Cargado por

Copyright:

Formatos disponibles

Código: CPE-FO-

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

INGENIERIA EN SISTEMAS COMPUTACIONALES

Calkiní, Campeche, Enero 2020

Revisó Aprobó Autorizó

DR. GONZALO MIGUEL QUETZ

PRACTICA 1. DIAGRAMA DE CLASES.....................................................................................................................6

PRACTICA 2. CLASES Y OBJETOS.........................................................................................................................11

PRACTICA 3. CLASES Y METODOS.......................................................................................................................19

PRACTICA 5. HERENCIA: CONSTRUCTORES Y DESTRUCTORES...........................................................................37

PRACTICA 7. MANEJO DE EXCEPCIONES............................................................................................................47

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

implementar objetos de programación que permitan resolver situaciones reales y de

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

Las prácticas que corresponden a la segunda unidad permiten al alumno aprender a

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

Los problemas suscitados en tiempo de ejecución son tratados en las prácticas de

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

PRACTICA 1. DIAGRAMA DE CLASES

UML respaldado por el OMG (Object Management Group), es un lenguaje de modelado de

Permite representar el modelo de un escenario, donde se describen las entidades intervinientes y

Esta práctica le permitirá al alumno realizar diagramas de clases en un lenguaje especializado en

El juego de la lotería, es un juego de azar que consta de un

Clases de objetos Atributos Verbos

- figura: String - Cartas []: Carta

- figura: String - Cartas []: Carta

Criterio Puntaje Puntaje Obtenido

Análisis: El diagrama presenta todas las clases definidas en la 5

Análisis: EL diagrama de cada clase especifica los atributos y 10

Desarrollo: Cada clase contiene los métodos identificados 10

Desarrollo: Cada método contiene la lista de parámetros 10

Desarrollo: Cada método contiene el valor de retorno 10

Desarrollo: Los nombres de la clase, atributos y métodos siguen 10

Desarrollo y resultados: Las clases presenta las relaciones 10

Desarrollo y resultados: Las clases presentan la cardinalidad 5

Desarrollo y resultados: Se presenta el código generado acorde 25

Comunicación oral y escrita con habilidades de investigación 2

Habilidades de Organización con uso de Tics y trabajo en 3

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

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

PRACTICA 2. CLASES Y OBJETOS

Un objeto no es más que un conjunto de variables (o datos) y métodos (o funciones) relacionados

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.

Editor de texto (Bloc de notas,vi, gedit)

a) Definir la clase con el nombre

c) Escribir el constructor de la clase recibiendo al menos un parámetro para asignar valor a un

El programa debe quedar de acuerdo a la siguiente estructura:

Paso 7. Compilar y ejecutar el programa anotando en la bitácora los errores de compilación y

Documentar todos los pasos en una bitácora.

El alumno deberá presenta un programa y los resultados de acuerdo a la siguiente tabla:

Análisis: Se escribe los nombres de la clase, métodos, atributos de 15

Desarrollo y resultados: Escribe la clase de acuerdo con diagrama. 80

Comunicación oral y escrita con habilidades de investigación 2

Habilidades de Organización con uso de Tics y trabajo en equipo. 3

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.

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

PRACTICA 3. CLASES Y METODOS