Semana IV

Taller de Programación I
 Inicio 10 minutos:
Resumen de la semana anterior

Conociste como desarrollar en la POO, codificando clases

simples que permiten entender los fundamentos de ella y
como estas son aplicadas con el lenguaje de Java

Resumen semana anterior

 10 minutos:
Al término de la semana

Aprenderás a desarrollar aplicaciones que permitan la

interacción con el usuario mediante entradas y salidas
por consola, además aprenderemos como los objetos
puede colaborar entre ellas.

Contenido:
Aprendizajes esperados
225 minutos.

Material de apoyo:
2 PPT.
1 Guía Práctica.
1 Actividad Propuesta.
 Clases de java.

Hasta ahora, hemos visto que podemos crear todas las clases que necesitemos
con el fin de instanciar objetos que nos permitan resolver una gran cantidad
de variados problemas, pero el potencial de Java no termina aquí, así como
los usuarios programadores pueden crear sus clases, los programadores de
la plataforma Java han desarrollado para nosotros una gran cantidad de
clases que podrás utilizar, este conjunto de clases creado (conocidos como
paquetes, o packages en inglés), es muy grande y cubre una gran variedad
de funcionalidades orientadas a resolver problemas comunes en el desarrollo
de software, este conjunto de clases ha sido agrupada según el tipo de
Clases de Java / import

proyectos para el que sirven, por ejemplo, existen clases que encapsulan
funcionalidad requerida para trabajar en aplicaciones de escritorio, otras
especializadas en la web y otras que resuelven problemas comunes para
todos los tipos de aplicaciones.

Un package, no es otra cosa que una agrupación de clases. Estos packages,

sirven con el fin de, primero, agrupar clases por su funcionalidad y segundo
limitar el espacio de nombres, de esta forma es posible tener clases con el
mismo nombre en packages distintos. (Así como archivos en carpetas
diferentes).

El nombre del package al que pertenece una clase se encuentra señalado

por la palabra clave package, la cual siempre será la primera línea de código
del archivo, el siguiente ejemplo muestra una clase persona que pertenece
al paquete holamundo:

La sentencia import

Por defecto cuando se escribe el nombre de una clase dentro de otra, Java
asume que dicha clase se encuentra dentro del mismo package, sin embargo
esto no siempre es así, en ese caso import nos servirá para especificar donde
hay que buscar la clase.

Veamos como funciona el import con un ejemplo práctico, si tuviésemos que

construir un sistema para una clínica encontraríamos clases como: doctor,
enfermera, recepcionista, contador y paciente, entre otras, pensando sólo en
las cinco clases descritas, notaríamos que doctor y enfermera pertenecen al
cuerpo médico, contador y recepcionista al administrativo y a su vez las cuatro
a una clínica, el paciente en cambio es propio de la clínica pero no del cuerpo
médico ni de los administrativos.
 Podríamos entonces agrupar las dos primeras dentro de un package llamado
personalmedico (se suelen escribir con minúsculas para diferenciarlos de las
clases) y las otras dos en uno llamado administrativo, ambas estarán
contenidas además dentro del package llamado clínica. La cual además
contiene a la clase paciente.

El siguiente esquema muestra como quedan agrupadas las clases:

Sentencia import

Fíjese que clínica.administrativo significa que el nombre del package es sólo

administrativo y que se encuentra dentro del package clínica (muy similar al
concepto de subcarpeta).
Supongamos ahora que tenemos una clase llamada CentroMedico que se
encuentra dentro del package gestionmedica, como muestra la siguiente
imagen.

Si deseamos declarar un objeto de la clase Doctor desde CentroMedico hay

que realizarla utilizando su espacio de nombres completo como muestra la
figura:

Esta declaración puede ser reducida utilizando la palabra clave import, de

esta forma se especifica a Java con anticipación donde debe buscar las clases
que utilizaremos, el siguiente código muestra un ejemplo de ello:
 De esta forma la declaración no necesita el espacio de nombres completo en
la declaración de la clase doctor, sin embargo, para declarar un objeto de
tipo enfermera aún es necesario ya que el import realizado sólo considera al
doctor, esto se puede evitar importando todas las clases contenidas en el
package personamedico cambiando el import para que luzca de la siguiente
forma:

De esta manera el import realizado nos sirve para ambas clases, además una
clase puede incluir todos los import necesarios.
La biblioteca de packages que ya viene con Java es muy extensa para cubrirla
en este capítulo, sin embargo comenzaremos por algunas de las bibliotecas
Clase String

de uso común para todos los proyectos, realizaremos un recorrido por la clase
String y las destinadas a la entrada y salida de datos con Java, las cuales
serán las encargadas de obtener y presentar datos del usuario, además de
clases que presentan utilidades básicas para todos los tipos software, como
por ejemplo, cálculos matemáticos, trabajos con cadenas de texto, etc.

La clase String

El String en Java es una cadena de caracteres al igual que en lenguajes como

C, sin embargo su principal diferencia es que esta no es sólo una cadena de
caracteres, sino un objeto producto de la instancia de la clase String (esto
quiere decir que String como cualquier otra clase también posee
comportamientos que puede realizar), dichos comportamientos, están todos
asociados al manejo de una cadena, lo que presenta una gran ayuda al
momento de trabajar con ellas, esta clase se encuentra dentro del package
java.lang.
Algunas de las utilidades que presta la clase String permiten contar la cantidad
de caracteres que tiene una cadena, buscar caracteres, juntar y dividir cadenas
de texto, entre muchas otras.
La sintaxis de un String es la siguiente:
 En la declaración anterior, es Java quien se encarga de crear un objeto de
tipo String llamado hola, el cual contiene como atributo una cadena de
caracteres que dice “hola mundo”, es importante saber que una cadena de
caracteres no es más que un arreglo de objetos del tipo char[], afortunadamente,
la clase string es la que se encarga de redimensionar dicho arreglo cuando
es necesario, por ejemplo, si luego de su declaración al String hola se le
asigna “hola mundo otra vez” será Java quien gestione el redimensionamiento
necesario para que el nuevo String quepa en el arreglo creado antes dentro
del objeto.

(Importante)La documentación de todas las clases que vienen en java puede

ser encontrada en: http://download.oracle.com/javase/1.4.2/docs/api/

Prestaremos especial atención en la documentación de la clase String, a la

cual se puede acceder de forma directa desde:
http://download.oracle.com/javase/1.4.2/docs/api/java/lang/String.html

(Importante)Memorizar no lo es todo en la programación, una buena lógica,

un conocimiento de las API´s y saber como leer e interpretar su documentación
es una combinación que no falla para resolver la mayoría de los problemas.
Clase String

La documentación de todas las clases se encuentra estructurada de la siguiente

forma:
• Field Summary: un resumen de los atributos que posee la clase.
• Constructor Summary: un resumen con sus constructores y las sobre
cargas existentes
• Method Summary: un resumen con la descripción de sus métodos, tipos
de datos que reciben y tipo de retorno.

Vamos a aprender como leer la documentación a partir de la aplicación de

algunos de los elementos descritos en ella. Comenzaremos con las formas
de construir un objeto de tipo String que existen, para ello nota que de la lista
de constructores, el primero luce de la siguiente forma:

Esto significa que puede crearse un objeto de tipo String sin pasar parámetros,
vale decir, sólo llamando a su constructor por defecto:

(Importante) en capítulos anteriores habíamos utilizado el objeto String sin

necesidad de crear una instancia, esto se debe a que su uso es tan común
 que se ha realizado una excepción con esta clase y se ha permitido declararla
como un tipo de dato primitivo, sin embargo de forma interna se ejecuta el
constructor como muestra el fragmento de código anterior.

Observe el siguiente constructor, el cual necesita para dar un valor inicial a

la cadena un arreglo de caracteres:

El constructor debe ser llamado de cualquiera de las siguientes formas:

Para cualquiera de los dos casos la impresión de obj da como resultado

“OpenDev”
Como puede ver, la clase tiene varias sobrecargas en su constructor, esto
permite instanciar un String, entregando su valor inicial a través de distintos
Clase String

tipos de origen, vamos a aprender ahora como leer el apartado de los métodos.
Todos los métodos que tiene una clase, contienen una descripción de su
parámetro de retorno, nombre del método, dato de entrada y una descripción,
por ejemplo:

Con esta información la dificultad de utilizar las clases provistas por Java se
desvanece casi en su totalidad, por ejemplo, el comportamiento sabes que
tiene el nombre de charAt, y su descripción dice que nos retornará el carácter
de un índice especificado, que necesita para ejecutarse el número de la
posición del carácter que deseas obtener y a cambio nos retorna un objeto
de tipo char con el carácter que ocupa dicha posición. Dado que el
comportamiento es sólo aplicable a los objetos de tipo String, entonces lo
ejecutamos de la siguiente forma:
 Donde el valor de “letra” es el carácter “d”

Algunos comportamientos se encuentran sobre cargados, por ejemplo, el

método startsWith tiene los siguientes usos:

El cual nos permite conocer si una cadena comienza con la cadena que se
le entrega como parámetro, el resultado es un booleano, veamos su uso:

Para este caso, el resultado de la ejecución de obj.startsWith(“Open”)

representa un booleano verdadero, dado que la cadena comienza con “Open”,
por ello la sentencia if al evaluar dicho resultado permite la impresión.
Analicemos su sobre carga:
Clase String

Este método también permite conocer si una cadena comienza con una cadena
en particular, la diferencia está dada en que además permite especificar de
la cadena original, desde que carácter deseo comenzar a evaluar, por ejemplo:

Para este caso, el if no se cumple, ya que a partir del carácter 2 la cadena

se reduce a “enDev”.
A continuación se listan los métodos más utilizados para su análisis:
• charAt: retorna un objeto de tipo char con el carácter que ocupa dicha
posición
• Concat: permite juntar dos cadenas
• endsWith: evalúa si la cadena comienza con una cadena especificada
• equals: evalúa si la cadena y el parámetro son iguales.
• Length: retorna el largo de la cadena
 Ejercicio 01
Duración: 30 minutos

CONOCIMIENTO: Reproducir.
Niveles de pensamiento:
1._ REPRODUCE los ejemplos dados hasta este
punto.

2.-_ TRANSFORMA estos ejemplos en otros similares

COMPRENSIÓN: Transformar. de manera que puedas darle otra mirada a su uso.
Niveles de pensamiento:
Actividades
 • Replace: permite reemplazar caracteres
• startsWith: evalúa si la cadena termina con una cadena especificada
• subString: permite extraer una porción de la cadena original
• toCharArray: transforma la cadena a un arreglo de caracteres.
• toLowerCase: retorna una copia del String original en minúscula
• toUpperCase: retorna una copia del String original en mayúscula
• trim: retorna una copia del String original sin los espacios al comienzo
y al final.
• valueOf: retorna la representación del parámetro entregado como un
String.
Entradas y Salidas

Entradas y salidas.
Dentro del package Java.IO existen más clases que suelen utilizarse de
manera recurrente, las clases que se encuentran dentro de este package
están orientadas a entradas y salidas entandar.

Los programas que necesiten realizar una operación de entrada o salida lo

hará mediante lo que se conoce como un flujo (stream), este flujo tiene la
característica de ser un objeto al cual no le importa desde donde proviene a
la información o donde debe escribirla, siendo otros los objetos encargados
de recibir o adquirir la información desde los dispositivos de entrada, estas
clases se encuentran dentro del package.io. así que cuando tengas que crear
un programa que utilice entradas y salidas, no debes olvidar realizar el
siguiente import:

Existen cuatro clases fundamentales para las entradas y salidas, las cuales
son: reader, writer, inputStream y outputStream
La clase inputStream posee una de los métodos más comunes read(), este
método realizar una lectura del flujo de entrada leyendo el próximo byte que
se encuentre disponible, el valor es devuelto como un entero, el cual representa
el valor correspondiente al carácter en la tabla de códigos ASCII, por ejemplo,
si la lectura se realiza desde el teclado, no importará si lo que se presiona
es una letra, un número o algún carácter el resultado se podrá almacenar en
un valor de tipo entero sin necesidad de realizar casting.
Existe otra clase que también utiliza la lectura que provee la clase Reader
llamada InputStreamReader, esta clase, se diferencia de inputStream en que
el byte leído es convertido a caracteres, esta clase se recibe como parámetro
un objeto de tipo inputStream, es decir el byte que se desea convertir, el cual
 puedes obtener de la clase System.in, la cual provee una flujo desde el
teclado, sin embargo esto daría como resultado lo siguiente, System.in permite
la entrada desde el teclado, la entrada es leída como un flujo en byte por
inputStreamReader, el resultado que esta clase genera es transformado al
carácter correspondiente, sin embargo la lectura se puede mejorar utilizando
un flujo buferizado, esto permite ingresar un arreglo de bytes para luego ser
leído de una sola vez, el siguiente código de ejemplo muestra la interacción
entre todas las clases mencionadas para lograr una entrada de datos buferizada
por teclado.
Entradas y Salidas

El objeto br, es creado a partir de una clase BufferedReader, la cual leerá

todos los caracteres que leerá inputStreamReader a partir de System.in

Nota que el objeto br si bien contiene el comportamiento read() visto antes,

es mucho más conveniente utilizar readLine(), el cual leerá una entrada
buferizada, es decir todo los bytes que se encuentren disponibles para su
lectura, si ejecutamos este comportamiento veremos que la consola quedará
a la espera de que el usuario escriba algo en la consola y presione Enter,
cuando esto suceda, todos la información será leída y entregada como un
String( recuerda que pueden ser varios caracteres).
El siguiente código muestra una clase de ejemplo de lectura que podrás
utilizar en todos tus programas:
 (Importante) el throws IOException que acompaña la firma del método lectura
será estudiando más adelante en este mismo capítulo.

El único comportamiento de la clase llamado lectura lee una cadena de

caracteres desde el teclado y la retorna, mira ahora como se utilizará esta
clase en nuestro programa:
Excepciones

Con este código podemos crear un objeto de tipo lectura y solicitarle que lea
una cadena de caracteres desde el teclado sin tener que volver a escribir el
código dentro de lectura una y otra vez.

Excepciones

Muchas veces producto de las entradas que digitan los usuarios, problemas
de conexión o una mala lógica del programador llevan a los programas a
 producir errores consecuencia de acciones inesperadas del software, siempre
es mejor evitar un error que buscarle una solución, al igual como es mejor
utilizar la medicina predictiva que correctiva, sin embargo al igual que en la
vida esto no siempre es posible, en Java el control de errores se ha simplificado
bastante gracias a la utilización de excepciones, permíteme explicarte con
un ejemplo en que consiste una excepción, supongamos que tenemos un
pequeño programa que permita el ingreso de dos números de tipo float los
cuales se dividen entre si, cuando el usuario digite 3 y 2, el resultado será
3/2 = 1.5f, ¿pero qué sucederá cuando se digite 0? La división por cero
sabemos que no es posible y por ello, deberíamos antes de realizarla
validar que el número ingresado sea distinto de cero. En una aplicación
de un tamaño tan pequeño como este la predicción de errores es bastante
simple, pero en sistemas que tienen miles de líneas de código el escenario
es bastante más difícil, piensa incluso que existen ocasiones en que es
imposible prevenir un error, supongamos que tenemos un programa que
mediante una red se comunica con otro equipo, ¿Qué sucederá si la red no
se encuentra disponible? Por suerte para nosotros Java cada vez que ocurra
un error que no hayamos prevenido generará una excepción, estas excepciones
portan toda la información de la causa del error y permiten controlarlas y
codificar lo que necesitemos que ocurra en caso de haber un error.
Desarrollemos el programa que muestra la excepción de la división en cero
Excepciones

para que veas como funciona:

Al ejecutar el programa ingresaremos los datos como se muestra a continuación:

 Cuando el usuario ingresa los valores 2 y 0 note la impresión del resultado
no se ejecutó, esto se debe a que el flujo normal del programa se ha visto
interrumpido dado que la división por cero en una división entera no es posible,
lo que provoca que el programa no continúe con su ejecución, si leemos la
descripción del error nos encontraremos con que el tipo de excepción es
ArithmeticException y la razón es: “by zero”, lo que significa que hubo uno
operación aritmética que no se pudo realizar por cero.
Así como existe ArithmeticException Java tiene una gran cantidad de
excepciones que indican el error ocurrido, estas clases, las cuales heredan
todas de la súper clase Exception se puede ver en la siguiente imagen:
Excepciones

Aprendamos ahora como trabajar con errores, ahora que sabemos que el
código puede fallar debemos envolver el código susceptible a fallos dentro
de un bloque llamado try - catch (intentar – capturar) la sintaxis es la siguiente:
 Apliquemos la sintaxis a nuestro caso:

throw / throws

La línea que captura el resultado y el que la imprime están ahora dentro del
bloque try, fijese que tenemos un catch, que capturará todos los errores de
tipo ArithmeticException que ocurra, por ello esta vez, si se intenta dividir por
cero el mensaje de “no es posible realizar el cálculo” será mostrado y el
código continuará ejecutándose de forma normal al finalizar el bloque de try-
catch.

throw y throws

si prestamos atención al código realizado antes:

Notaras que throws IOException se encuentra presente en nuestro código,

la razón de ello es que la llamada a readLine() puede provocar una excepción
 de tipo IOException, cuando produzcas código sensible a lanzar excepciones
dentro de un comportamiento, se tienen dos opciones
1) controlarlo utilizando los bloques try-catch
2) o reportar con throws que el comportamiento lanza este error, en dicho
caso quien debe utilizar try-catch es el código que consume el método.

Si a la clase EntradaSalida vista antes agregamos el siguiente método

leerDouble:
throw / throws

Notaremos dos cambios iniciales, el primero corresponde a que el objeto “br”

que antes sólo pertenecía al método lectura() ahora pertenece a la clase y
por ende a todos sus métodos, el segundo corresponde a que el
comportamiento leerDouble reporta que lanza una IOException en caso de
error, adicionalmente la lectura del usuario provocara que el texto ingresado
sea convertido de String a un double, pero si el usuario no ingresa un valor
con el formato correcto Java no podrá llevar a cabo dicha acción lanzando
una excepción de tipo NumberFormatException.
El problema podemos abordarlo de dos formas:
1) vamos a reportar que el método lanza una excepción, dejando la
responsabilidad de capturarlo a quien invoque el método:

Para este caso el método leerDouble lanza 2 excepciones, nota que un método
puede reportar todas las excepciones que desee, hecho esto el comportamiento
 que consume el método lucirá así:

throw / throws

Esta solución intenta recibir en valor el resultado de leerDouble, en caso de

que esto falle, nuestro catch capturara cualquier error de tipo
NumberFormatException y mostrará el mensaje correspondiente, note además
que sin importar si hubo o no una excepción al final se muestra al usuario un
mensaje con el valor ingresado, que en caso de ocurrir error será cero (el
valor de inicialización).

Fíjate que la excepción de tipo IO no fue necesario controlarla dentro de un

bloque catch, esto se debe a que nuestro método main() reporta que de ocurrir
un error lanzará el error a quien lo haya invocado, de manera adicional, es
importante destacar que si bien el método main(), nunca ejecuta el
comportamiento readLine() de forma directa, lo hace de forma indirecta al
ejecutar el comportamiento leerDouble del objeto myLector, quien lanza
este tipo de excepciones, provocando así una propagación de la excepción.

Las excepciones se pueden propagar para una cantidad N de llamadas, sin

embargo, para este caso en particular mantener la sentencia throws no
presenta mucha utilidad ya que el método main() es el inicio del programa y
el error provocará un error al no tratar la excepción en el flujo del
programa, esto tiene una solución en el try que envuelve las líneas que
 provocan el error, la solución está dada por las características que tienen los
try, la cual les permite agregar una N cantidad de catch:

El flujo del programa será el siguiente, se intentará ejecutar las líneas dentro
del try, en caso de no existir, ninguno de los catch es ejecutado, por otra
parte, si un error ocurre sólo se ejecutara el catch que corresponde a la
excepción ocurrida, en caso de no ser ninguna de las dos, el código fallará
throw / throws

al igual como si no hubiese un control de errores.

(Importante) Todas las excepciones heredan de la clase Exception, la herencia

será un tema tratado más adelante, sin embargo por ahora será suficiente
con que sepas que cualquier excepción que ocurra puede ser tratada como
una excepción genérica.

El siguiente código ejecutará el primer catch en caso de que ocurra un error

con el formato, el segundo en caso de generar una de entrada de entrada o
salida y el tercer catch se ejecutará en caso de que ocurra una excepción
que no sea alguna de las anteriores, esta técnica es genial, ya que aunque
no sepas porque ocurrió, el código no se caerá y a cambio te permitirá mostrar
un mensaje al usuario informando de que un problema ha ocurrido. La siguiente
línea de código muestra un ejemplo de ello:
 throw

Al igual como Java lanza excepciones es posible lanzarlas cuando se estime

conveniente, utilizando la sentencia throws, el siguiente ejemplo lanza un
error de tipo Exception si la cadena ingresada no tiene 3 caracteres.

Fíjese que la palabra reservada throws lanza un nuevo objeto proveniente

de la clase Exception al cual se puede especificar mediante su constructor
con parámetros un mensaje con la causa del error.
El código que invoca al método lucirá de la siguiente forma:
throw / throws

Para este caso la última excepción mediante e.getMessage() mostrará el

mensaje especificado al lanzar la excepción codificada en nuestro método,
ya que, la excepción ocurrida es recibida como parámetro (el objeto e) y
getMessage() es un accesador que permite conocer el valor del mensaje.
Para mayor información sobre los métodos y constructores consulte la
documentación oficial de la clase Exception:
http://download.oracle.com/javase/1.5.0/docs/api/java/lang/Exception.html
 Colaboración entre clases.

Hasta ahora hemos trabajado con clases que manejan sólo tipos de datos
primitivos, sin embargo, los objetos pueden colaborar con otros objetos, esto
permite mantener la encapsulación y la reutilización de los objetos de forma
independiente, por ejemplo, si pensamos en un curso, notaremos que está
compuesto por al menos un profesor y una N cantidad de alumnos, por lo
tanto si pensamos en registrar los datos del profesor, sería ineficiente decir
que los atributos de la clase pudiesen ser el Rut del profesor, nombre o edad,
Colaboración entre clases

debido a que ya estamos hablando de un grupo de atributos que en su conjunto

representan un profesor, por otra parte es mucho más entendible decir que
“la clase tiene un profesor” que decir “la clase tiene el Rut, nombre y edad
del profesor”, esta forma natural de ver las cosas se puede aplicar también
en el software y tiene una lógica no muy difícil de comprender, por ejemplo
si deseásemos construir la clase llamada Curso, pero sabemos que el curso
está compuesto de un profesor ¿Qué debe existir primero? Es lógico que
tengamos que comenzar con la clase profesor, dado que no puedo crear un
curso y decir que contiene algo que no existe, vamos entonces a crear nuestra
clase profesor:
 La clase curso declara un objeto tipo profesor como un atributo de la clase.

En el código anterior la clase curso, contiene la definición de un atributo de

tipo Profesor, los objetos, al igual que los tipos de datos primitivos pueden
ser recibidos y retornados como parámetros, esto permite que puedan ser
utilizados en los comportamientos, permitiendo así su utilización en
accesadores, mutadores y constructores.
Agreguemos ahora el constructor con parámetros y sus respectivos métodos
get y set. Quedando el código como muestra la imagen.
Colaboración entre clases

Observe que la clase curso utiliza su método get y set para establecer u
obtener el valor retornando y recibiendo un objeto de tipo Profesor completo,
de esta forma es posible trasladar entre clases un conjunto de datos que
representen una entidad.
Veamos la utilización de la clase en el método main().
 En el código que muestra la imagen anterior, se observa que en la primera
línea un objeto de tipo curso es instanciado, de forma adicional la instancia
del objeto miCurso incluye la declaración de un segundo objeto de tipo
profesor, en la línea que continua declaramos e instanciamos un objeto de
tipo profesor utilizando su constructor con parámetros, luego, el objeto creado
es pasado como parámetro hacia mi curso, el cual lo hace llegar a su atributo
mediante el comportamiento setObjProfe.
Observe que mediante la colaboración es posible trabajar tanto con los datos
del curso, como del profesor si la clase curso lo permite:
Colaboración entre clases

Además observe que el método getObjProfe() de la clase curso retorna un

objeto de tipo profesor, esto significa que el comportamiento puede ser tratado
como cualquier objeto de tipo profesor, ya que, las acciones que realicemos
sobre él serán en realidad sobre el objeto que retorna.
El siguiente ejemplo muestra como cambiar el Rut del profesor que se
encuentra en el curso.

Nuestra clase curso, tiene 2 constructores, de los cuales sólo el constructor

con parámetros inicializa el valor del objeto profesor, en algunos casos hay
que prestar cuidado al intentar llamar a los comportamientos de un objeto que
no ha sido inicializado, debes recordar que el valor por defecto de un objeto
no inicializado es null, esto significa que cualquier intento de utilizar un objeto
que no existe lanzará una excepción de tipo NullPointerException.
El siguiente código generará una exception de este tipo.
 Ejercicio 02

COMPRENSIÓN: Confeccionar.
Duración: 60 minutos

CONOCIMIENTO: Repetir.
1._ REPITE los ejemplos desde “entradas y salidas” en

Niveles de pensamiento:
adelante.

2._ CONFECCIONA ejemplos propios, basados en lo

aprendido.

3._ REALIZA una APLICACIÓN, en donde incluyas lo

aprendido en la semana.

4._ SEÑALA aplicaciones prácticas para lo aprendido esta

semana.

5._ Haz un RESUMEN de lo aprendido en la semana.

Niveles de pensamiento:
APLICACIÓN: Realizar,
Aplicar.
Actividades
Niveles de pensamiento:

SINTESIS: Resumir.
ANÁLISIS: Señalar.

MA
T
No E R I A
olvi LD
2P de E
P T. s con A P O Y
1V side O:
id rar
1 G eotut tus
u o
1 E ía prá rial.
jerc ctic
icio a
gui .
ado
.
 Síntesis de la semana IV: 10 minutos.

¡ Muy bien!... esta semana aprendiste las clases que

Cierre permiten interactuar con el usuario.
Fin Semana IV