JAVA

(2ª. Parte)
sbm/UTFSM Sede Concepción
 Herencia
Organización y sintaxis
class Padre{
Contiene sus propias variables y métodos.
}
class Hijo extends Padre{
Hereda las variables y métodos de Padre
Incorpora sus propias variables y métodos
}
class miAplicac{
public static main(String[ ] args ) {
Crea objetos de la clase Hijos, Padre, usa sus métodos y
define sus variables.
}
}
 Creación de una jerarquía multinivel.
Ejemplo: Clases Caja, PesoCaja, PrecioCaja

class Caja {
Define dimensiones de la caja con sus variables y métodos.
}
class PesoCaja extends Caja {
Hereda variables y métodos de la clase Caja
Define variables y métodos propios para el cálculo de volumen y peso de las cajas.
}
class PrecioCaja extends PesoCaja {
Hereda de la clase PesoCaja (y de Caja)
Define variables y métodos propios para el cálculo del precio de las cajas.
}
 El árbol de la jerarquía
Destacando las clases Caja, PesoCaja y PrecioCaja
 Los Constructores sin
parámetros
Cuando se crea un objeto de una
clase derivada, se ejecutan todos
los constructores sin parámetros
de las jerarquías superiores, la
base en primer lugar (concepto
de herencia).
Ver LlamaConstruc.java
 super( )
Dos usos posibles:

1.- Llama a la ejecución del Constructor de la

superclase (clase superior), desde la subclase (o
extensión de la clase).
super(lista de parámetros);
2.- Para acceder a un miembro de la superclase que
se ha ocultado por un miembro de la subclase.
En la superclase hay una variable int i al igual
que en la subclase (oculta a la variable i de la
superclase). Entonces, para referirse a la
variable i de la superclase:
super.i = ....
 Aplicación de super( )
Para llamar al Constructor de la superclase.
//Considerando la clase Caja de unas láminas
//anteriores:

Class PesoCaja extends Caja {

double peso;
PesoCaja(double w, double a, double p, peso k) {
super(w, a, p);
peso = k;
}
}
 Aplicación de super.miembro
Cuando los nombres de miembros de una subclase ocultan (se repiten) los
miembros que tienen el mismo nombre en la superclase.
class AAA {
int i;
}
class BBB extends AAA {
int i; //esta i „oculta‟ a la i de AAA
BBB (int a, int b) {
super.i = a; //se refiere a la i de AAA
i = b; //se refiere a la i de BBB
}
 Sobreescritura de métodos
Implementación del polimorfismo en tiempo de ejecución.

La sobre escritura permite que las superclases dispongan de métodos

comunes para todas sus clases derivadas, permitiendo a éstas definir
métodos específicos a sus propósitos. (Ver CalculaAreas.java)

class AAA {
void metodoX { ...... }
}
class BBB extends AAA {
void metodoX { -------------------- }
}
 Clases abstractas
Forma generalizada compartida por todas las subclases.
Superclase que NO implementa completamente sus métodos. Cada subclase asume la tarea
de completar los detalles. No existen objetos creados a partir de una clase abstract.
La superclase determina la naturaleza de los métodos a ser implementados por las subclases.
Un método definido como abstract DEBE ser implementado en las subclases.

abstract class AAA {

abstract void llamar( ); //método abstracto
//puede haber métodos concretos
}
Class BBB extends AAA {
void llamar( ){ //implementa el método llamar() en BBB
System.out.println(” ..........”);
..........................;
}
}
 final
3 usos posibles en Java .... (son las “hojas” del árbol)

Para crear una CONSTANTE con nombre

final double miValor = 45.9086;
Para evitar sobreescritura
Versión definitiva de un método.
final void metodoW( ) { ............. }
Para evitar la herencia
Ultima clase derivada de una rama del árbol.
class WW {
}
final class WWH {
}
 1.- packages (Paquetes)
Se trata de una agrupación (lógica) de clases e
interfaces relacionadas entre si (pueden incluir
además enumerations y annotations).

Java tiene sus clases organizadas en paquetes.

Por ejemplo: java.lang
(clases e interfases fundamentales)
java.io
(clases para leer y escribir …)
 2.- packages
¿Para que se empaquetan las clases e
interfaces?
Para identificar las que están
relacionadas entre si.
Para que se pueda ubicar estos
recursos.
Para hacer el control de acceso.
 3.- Como empaquetar
▪ Se escoge el nombre del paquete (hay convenciones).
Sea el paquete grafmios (paquete lógico).
▪ Se pone
package grafmios;
como primera sentencia de cada clase o interface
(archivo fuente) que se desea empaquetar.

Sólo un nombre de package en cada archivo fuente,

aunque éste incluya varias clases e interfaces a
empaquetar. Sólo una clase debe ser pública y es la que le
da el nombre al archivo fuente. Debe definir el acceso a los
miembros de la clase (public, protected, private, sin def).
 4.- Ejemplo de empaquetado
▪ Ej.: Sea el nombre del archivo (también el de la clase
pública ) MiClaseP (MiClaseP.java)
▪ Primera sentencia de cada clase a empaquetar será,
package grafmios;
▪ Se compila (crea tantos archivos .class como clases o
interfaces existan en la fuente).
▪ Estos archivos .class se depositan en el directorio
grafmios, bajo el directorio de trabajo.
▪ Para importar una o más clases de ese paquete, en la
aplicación debe especificarse:
import grafmios.nomClase; //( o bien *)
 5.- Un ejemplo.-
:

package MiPaquete; //primera sentencia

public class UnaCosa {

.... sus variables y sus métodos ....

con la definición de acceso (public)
}
/* Se compila y deposita en el directorio
MiPaquete, bajo el directorio de trabajo. */
 6.- Usando la clase

import MiPaquete.UnaCosa; //.*

class EmpleaCosa {
public static main( String[ ] args) {
........
sentencias que usan objetos,
variables y métodos de la
clase UnaCosa ........
}
}
 Para evitar ambiguedad de nombres
(de paquetes, cuando se comparten recursos ...)

Existe CONVENCION:

En el ámbito empresarial, si la identificación es

utfsm.com entonces, se genera una estructura de
directorios com.utfsm
De esta manera queda com.utfsm.MiPaquete
Esto sugiere una organización de DIRECTORIOS
(o carpetas) de acuerdo a lo mismo.
Acceso a miembros de una clase
Bajo el punto de vista de los paquetes
 Excepciones
En los lenguajes de programación modernos (C++, Java, otros).

Conceptos:
Una Excepción es una condición anormal que surge
en una secuencia de código durante la ejecución de
un programa.
Una Excepción se produce al producirse un error de
ejecución; las Excepciones aportan formas
elaboradas para tratar los errores.
Una Excepción es un OBJETO que describe una
condición excepcional en la ejecución de un
programa.
 Tipos de excepción
La jerarquía superior es la clase Throwable (lanzable)
Una Excepción lanza un objeto de una subclase de
Throwable, la que puede ser capturada o no por el código.

Los objetos de las subclases Exception y RuntimeException

son las que pueden ser capturadas por los programadores.

Exception es la subclase de partida para la creación de

subclases para excepciones en aplicaciones específicas.

La subclase Error es manejada por el intérprete Java y sus

objetos no son capturados por los programadores
(situaciones de catástrofe computacional).
Clases de Excepciones
java.lang.Throwable
Excepciones del núcleo de Java
Subclases disponibles y conocidas (ver literatura).
 Extendiendo Exception
public class NoTalAtributoException extends Exception{
public String nombreAtrib;
public NoTalAtributoException(String nombre){
super(“El atributo con el nombre “ + nombre +
“ no se encuentra.\n”;
nombreAtrib = nombre;
}
}
//Por convención se extiende Exception. La clase Throwable
//contiene una cadena de texto que se puede usar para describir la
//excepción.
Excepción del Intérprete (no capturada)
El intérprete Java maneja el error, no el programador.

class DivPor0 {
public static void main(String[ ] args) {
int rr = 0;
int cuo = 100 / rr;
System.out.println("Hola, a toda la gallá !");
}
}

Al interpretar ... (la compilación no produce error):

Exception in thread "main" java.lang.ArithmeticException: / by zero
at DivPor0.main(DivPor0.java:4)
Otro ejemplo de una excepción no capturada:
Lo interesante es el mensaje que emite Java.
class BdivPor0 {
static void unMetodo(){
int denom = 0;
int cuo = 125 / denom;
}
public static void main(String[] args) {
BdivPor0.unMetodo();
System.out.println("Un mensaje cualquiera ...");
}
}
Mensaje emitido por Java:
Exception in thread "main" java.lang.ArithmeticException: / by zero
at BdivPor0.unMetodo(BdivPor0.java:4)
at BdivPor0.main(BdivPor0.java:7)
 try-catch
(Intentar y capturar, el programador maneja el error)

class UnaAplic {
public static main(String[ ] args){
int variables; ....
try{
(Código que puede producir errores)
}
catch (TipoExcepción e){
(Instrucciones para manejar los errores)
}
}
}
 Cláusulas catch múltiples
Para capturar más de un tipo de excepción

class UnaAplic1 { //main() no requiere throws

public static main(String[ ] args){ //si las excepciones se manejan
int variables; .... //con try-catch
try{
(Código que puede producir errores)
}catch (ArithmeticException e){
(Instrucciones para manejar esos errores)
}catch(ArrayIndexOutOfBoundsException e){
(Instrucciones para manejar esos errores)
} // … y otros catch …
}
}
//Puede que el segundo catch nunca se alcance si se produce el primero.
 Sentencias try anidadas
try dentro de un bloque de sentencias de otro try

class UnaAplic2 {
public static main(String[ ] args){
int variables; ....
try{
(Código que puede producir errores tipo1)
try{
(Código que puede producir errores tipo2)
}catch (ArithmeticException e){
(Instrucciones para manejar errores tipo2) }
}catch(ArrayIndexOutOfBoundsException e){
(Instrucciones para manejar errores tipo1) }
}
}
 finally
Evita que un método termine de manera prematura.

La clausula finally se ejecuta siempre despues que el

código abandona la cláusula try. Si try se completa
naturalmente, se ejecuta finally. Si ocurre una
excepción y se ejecuta algún catch, se ejecutará
finalmente finally. Si existe return o exit(), antes de
su ejecución se ejecuta finally.
try {
..........
}catch( tipo Excepcion1){ ................
}catch( tipo Excepcion2){ .................
}finally { .....................}
 throw (lanzar, arrojar)
throw InstanciaThrowable;

Anteriormente se mencionó excepciones generadas por el

intérprete Java. Sin embargo, usando throw es posible hacer
que el programa arroje una excepción de manera explícita,
sin realizar un try-catch.
Ejemplo:
int método() throw NullPointerException, ExcepcionTipo2 {
throw new ExcepcionTipo2();
...........
}
La sentencia throws de un método relaciona la lista de
excepciones que pueden lanzarse durante la ejecución del
método.
 Aserciones (assert)
• Es un mecanismo de inclusión relativamente
reciente para la detección de errores,
generando Excepciones. Las aserciones han
sido incorporadas en muchos de los lenguajes
modernos, Java incluido, para facilitar las tareas
de depuración de código.
• Un lenguaje que incorpora assert en forma
intensiva es Groovy, el que funciona sobre una
plataforma Java (pretende simplificar y mejorar
Java).
 Aserciones y asertos.
• Una aserción es la acción o efecto de afirmar o
dar por cierto algo.
• Una aserción es una proposición que se
establece para saber si es verdadero o falso lo
que se afirma. Una aserción es siempre
verdadero o falsa.
• Por ejemplo, la siguiente aserción "El color del
mar es blanco" produce falso.
• Un aserto es la afirmación de la certeza de algo.
 Ejemplo
class Aserc{
public static void main(String[] args){
int xX = 34; int yY = 78;
String Str = "UTFSM Sede Concepción.";
//Podemos evitar la siguiente sentencia.
System.out.println("El valor de xX es: " + xX + " y el de yY es: " + yY);
//Ahora podemos trabajar con los asertos:
assert xX == 34; //Debe ser boolean
//El aserto anterior no produce efecto en pantalla, lo que significa que es
//verdadero.
assert yY == 7779; //boolean, falso y produce Excepción
//Este aserto produce una Excepción, lo que significa que es falsa.
assert Str == "UTFSM"; //boolean, produce falso y genera Excepción
//La ejecución no alcanza a llegar acá, ya que se produce la Excepción anterior
//y termina. Probar con 78 en la línea donde se establece assert yY== ….
}
}
 Comentarios
• Compilar como es usual. Para ejecutar c:...>java –ea Aserc
El resultado en pantalla es:
El valor de xX es: 34 y el de yY es: 78
Exception in thread "main" java.lang.AssertionError at
Aserc.main(Aserc.java:37) (Error de aserción en la línea 37)

• Visitar y estudiar
http://download.oracle.com/javase/1.4.2/docs/guide/lang/assert.html
También,
http://www.adictosaltrabajo.com/tutoriales/tutoriales.php?pagina=asserts
y muchos otros sitios ... (con Google, poner assert)
 La ejecución
Para ejecutar, C:\...>java -ea Aserc

Funciona sobre versiones Java 1.4

Por defecto, al ejecutar, las aserciones son deshabilitadas.
Mediante dos opciones (-ea y -da) podemos habilitar y deshabilitar
el efecto de las aserciones al ejecutar.
Para habilitar las aserciones debe especificarse las opciones -ea
El significado es enableassertions (de allí que es -ea y no -ae)

Para deshabilitar aserciones se puede usar -da (disableassertions),

o ejecutar sin opciones.
 Java
Algunos de sus paquetes de clases
 java.lang
lang, de „language‟, lenguaje.
Clases:
Boolean Integer SecurityManager
Character Long String
Class Math StringBuffer
ClassLoader Number System
Compiler Object Thread
Double Process ThreadGroup
Float Runtime Throwable
Interfaces: Cloneable, Runnable.
 java.util
util, utilidades o útiles.

Clases:
BitSet Properties
Date Random
Dictionary Stack
Hashtable StringTokenizer
Obsevable Vector

Interfaz: Enumeration
 java.net
„net‟, para aplicaciones en red, protocolo TCP/IP.

Clases:
ContentHandler SocketImpl
DatagramPacket URL
DatagramSocket URLConnection
InetAddress URLEncoder
ServerSocket URLStreamHandler
Socket
Interfaces: ContentHandlerFactory,
SocketImplFactory, URLStreamHandlerFactory
 java.awt
„awt‟, abstract windows toolkit

Clases:
Component
Container
Window
Frame
Panel

Canvas
Interface: MenuContainer
 java.applet
„applet‟, application ...., sin traducción feliz.

Deben importar además java.awt

Un applet se construye como extensión de Applet
public class UnApplet extends Applet { }
Interfaces: AppletContext, AppletStub, AudioClip
Más de 20 métodos.
Inicio de un applet:
init( ), start( ), paint( )
Finalización de un applet:
stop( ), destroy( )
 Sigue en Java 3
Otras clase ...

La clase String, StringBuffer

Las clases de java.lang.io

sbm/UTFSM Sede Concepción.