Java – Modulo 2

Clases, Herencia, Interfaces

 Contenido

Arreglos 
De Diagramas de Clase a

UML: Diagramas de Java
Clase 
Paquetes

Declarando clases: repaso 
Clases Abstractas
+ detalle 
Interfaces

Atributos y métodos de 
Vector
clase 
Colecciones

Modificadores de Acceso

Herencia
Tipos

Básicos: int, float, etc

Clases: Integer, Float, String, etc

Arrays
 Almacenan multiples valores de cualquier tipo
 Se crean con new
 Se usan [] para declarar y acceder
 Arrays

Declaracion
 int a[]; equivale a int[] a;
 a es un array; b y c son enteros

int a[], b, c;
 a, b y c son arrays:

int[] a, b, c;

Instanciacion
 a = new int[20]; ó int[] a = new int[20];
 a[0] = 15; // desde cero
 System.out.println(a.length); // imprime 20
Arreglos
 Inicializacion de Arrays

Sus elementos se inicializan al valor por defecto del tipo
correspondiente
int[] cuadrados = {0, 1, 4, 9};

que equivale a

int[] cuadrados = new int[4];

cuadrados[0] = 0;
cuadrados[1] = 1;
cuadrados[2] = 4;
cuadrados[3] = 9;
 Ejemplos de Arrays
int[] digitos = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
String[] dias = {"lunes","martes","miércoles","jueves",
"viernes","sábado","domingo"};
Fecha[] festivos = { new Fecha ( 1, 1, 2000),
new Fecha ( 15, 5, 2000),
new Fecha ( 12, 10, 2000),
new Fecha ( 6, 12, 2000),
}

Recorrido:
int[] lista = new lista[10];
for (int i = 0; i < lista.length; i++)
{
System.out.println(lista[i]);
}
 Arrays Multidimensionales

Un array bidimensional es un array de arrays.
Se necesita un conjunto de corchetes por cada dimensión

int[] unAnno = new int[12];

int[][] tresAnnos = new int[3][12];

TresAnnos[0][0] = 2;
tresAnnos[2][11] = 1;
 Arrays Bidimensionales No Rectangulares

Un array de 2 dimensiones se puede crear sin especificar el tamaño de su
segunda dimensión


int[][] tresAnnos = new int[3][];
tresAnnos[0] = new int[12];
tresAnnos[1] = new int[12];
tresAnnos[2] = new int[12];

Si se indica sólo una dimensión, ésta debe ser la primera:

int[][] tresAnnos = new int[][3]; // Error

Esta separación permite crear arrays no rectangulares

tresAnnos[0] = new int[12];

tresAnnos[1] = new int[5];
tresAnnos[2] = new int[9];
 Inicialización de Arrays
Multidimensionales

Se necesita un conjunto de datos 
equivale a
entre llaves para cada dimensión
int[][] matriz = int[][] matriz =
{ new int[2][3];
{1, 2, 3}, matriz[0][0] = 1;
matriz[0][1] = 2;
{4, 5, 6} matriz[0][2] = 3;
}; matriz[1][0] = 4;
matriz[1][1] = 5;
matriz[1][2] = 6;
 Clases para Manejar Cadenas
de Caracteres

Hay dos clases en el paquete java.lang que permiten
la manipulación de cadenas de caracteres:
 La clase String maneja cadenas constantes, es decir, que
no pueden cambiar
 La clase StringBuffer permite cambiar la cadena
insertando, añadiendo o borrando caracteres

La clase String es más eficiente, mientras que la clase
StringBuffer ofrece más posibilidades
 Ejemplo con Strings: Palindromo
protected static String reverse(String
public class Palindrome { string) {
public static boolean isPalindrome(
StringBuffer sb = new
String stringToTest) {
StringBuffer(string);
String workingCopy =
removeJunk(stringToTest);
String reversedCopy = return sb.reverse().toString();
reverse(workingCopy); }

return reversedCopy. public static void main(String[] args) {

equalsIgnoreCase(workingCopy); String string = "Madam, I'm Adam.";
}
System.out.println();
protected static String removeJunk(String System.out.println(
string) "Testing whether the following "
{ + "string is a palindrome:");
int i, len = string.length(); System.out.println(" " + string);
StringBuffer dest = new System.out.println();
StringBuffer(len);
char c;
if (isPalindrome(string)) {
for (i = (len - 1); i >= 0; i--) { System.out.println(
c = string.charAt(i); "It IS a palindrome!");
if (Character.isLetterOrDigit(c)) { } else {
dest.append(c); System.out.println(
} "It is NOT a palindrome!");
} }
System.out.println();
return dest.toString();
}
}
}
Mas Orientacion a Objetos

UML
 Orientación a Objetos

Clases: Patrones que indican como construir objetos

Objetos: Instancias de las clases en tiempo de ejecución.

Miembros de la clase:
 Atributos: Características o propiedades de los objetos (o clases).
Pueden ser variables de tipos simples o referencias a otros objetos
 Métodos: Comportamientos de los objetos. Son funciones que operan
sobre los atributos de los objetos.

Herencia, Relaciones, Agregaciones

UML: Unified Modeling Language
 Lenguaje para varias metodologias
 Presentaremos sólo Diagramas de Clase
Una clase
class Persona {
// Atributos
private String nombre;
private String telefono;
private Persona padre;
private Persona madre;
// Constructores
public Persona(String nombre, String telefono) {
this(nombre,telefono,null,null);
}
public Persona(String nombre, String telefono,
Persona padre, Persona madre) {
this.nombre = nombre;
this.telefono = telefono;
this.padre = padre;
this.madre = madre;
.... }
// Metodos, acceden a atributos privados
public String nombre() {return nombre;}
public String telefono() {return telefono;}
public Persona padre() {return padre;}
public Persona madre() {return madre;}
public boolean hayPadre() {return padre != null;}
public boolean hayMadre() {return madre != null;}
}
 El Lenguaje de Modelación Unificado
(UML)

Es un lenguaje estándar para la

escritura de modelos de software.
UML puede ser utilizado para
visualizar, especificar, construir y
documentar los artefactos de un
sistema de software intensivo.
 Construcción de Bloques UML


Elementos


Relaciones


Diagramas
 Elementos

Elementos Estructurales
 clases, interfaces, colaboraciones, caso de uso, clases
activas, componentes, nodos.

Elementos de Comportamiento
 interacciones, máquinas de estado

Elementos de Agrupación
 Paquetes

Elementos de Anotación
 Notas
Relaciones


Dependencia


Asociación


Generalización


Realización
Diagramas

Diagramas de Clase

Diagramas de Objeto

Diagramas de Caso de Uso

Diagrama de Secuencia

Diagrama de Estado

Diagramas de Actividad

Diagramas de Componente

Diagramas de Desarrollo
 Elementos Estructurales

Los elementos estructurales son los

sustantivos de los modelos UML.
Estos son la mayoría de las partes
estáticas de un modelo, representando
elementos que son conceptuales o
físicos.
Clases en UML
 Diagramas de Clases (UML)

Nodo Cola
Red EnEspera
+ Id: integer + NMedio: integer
+ Creados: integer 1..N Nodos + Procesados: integer + Tamaño: float
+ RetrasoMedio: float + ServicioMedio: float 1..1
+ RestrasoMedio: float + Encola(Paquete)
+ CreaPaquete() 1..1 + Desencola():Paquete
...
...

1..N
Siguiente Origen
Paquetes

Asociación
Paquete
Agregación 1..1 + Id: integer
Destino + tamaño: integer
Herencia 1..1
Más Orientación a Objetos

Volviendo a Java
 Ciclo de vida de un objeto
Persona p1; // Aun no existe, = null

Creacion de objetos: p1 = new Persona(“juan..
 Llama al Constructor.
 Puede dar excepcion: OutOfMemoryError

Uso del objeto
 p1.nombre = “otro” // illegal: privated
 p1.nombre()
 new Persona(“maria”,...).nombre() == “maria”

No hay más referencias: recolector de basura
 Declarando

Clase
 Atributos
 Métodos
 Constructores
 Declarando una clase
Partes de la La cla se...
declara cion
public espﾜblicamente accesible
abstract no puede serinst
anciada
final la l
case no puedeserderivada
class Name ti
enepornom bre �Name�
extends hereda deSuperClass
SuperClass
implements im plementa i
certasInterfaces
Interfaces
{ cuerpo... }

 Por defecto: no public, no abstract, no final, extends

Object
 Sino es publica, solo visible en el mismo paquete.
 Declarando un atributo
Partes de la de claraci ﾗ n Pro pos ito
niveld eacceso private, protected, etc.
static si e
s unavarde l case
final es const ante
transient no serializar
volatile cam bia inespera damente
(thread)
ti
po n om bre
 Declarando un método

Sintaxis:
modificadores tipo nombre(parametrosFormales)
[ throws excepciones]
{
sentencias
}

Tipo a retornar puede ser void

Valor devuelto: return <value>

Se pueden declarar variables locales si son necesarias

Paso de parámetros en Java: por valor. Incluso las referencias,
imitando el pasaje por referencia de otros lenguajes.
 Modificadores para métodos

Modificado r Pro pos ito

niveld eacceso private, protected, etc.
static mﾎtodo d e lcase
abstract sin implem entacion
final no puede sersobre escrito
native otro lenguaje (c/c++)
synchronized requiere monito r
 Constructores

Inicialización de la instancia de una clase: atributos

Tan complejos como se desee (ej: pueden invocarse otros métodos de
la misma clase, o de otras instancias creadas en el constructor).

Los constructores tienen el nombre de la clase + argumentos:
Persona(String ....

Cero o más constructores por clase.

Sino se declara: el constructor por defecto pone los atributos en cero
(false, null).

Pueden levantar excepciones, pero no pueden devolver un resultado.

No se heredan, solo pueden llamarse
 Constructores
class Circulo {
class Punto { private Punto centro;
private double x; private double radio;
private double y; public Circulo() {
public Punto() { this(new Punto(),1);
this(0.0,0.0); }
} public Circulo(double x,
public Punto(double x, double y, double radio) {
double y) { this(new Punto(x,y),radio);
this.x = x; }
this.y = y; public Circulo(Punto centro, double radio) {
} this.centro = centro;
... this.radio = radio;
} } ... }
 Sobrecarga de métodos
(Polimorfismo)


Todo método tiene una firma: su nombre con el número y el tipo de
sus parámetros.

Sobrecargar métodos: mismo nombre, distinta firma

Siempre se resuelve en tiempo de compilación (en base al tipo
estático de los parámetros reales): en base al número y la
especificidad del tipo de los argumentos.
 1. Aplicables: el número correcto de parámetros, y cuyos parámetros
formales son de tipos que incluyen, por orden, los de los parámetros
reales
 2. Si algún método tiene parámetros cuyos tipos incluyen, por orden, a
los tipos de los parámetros del resto de los métodos, dicho método se
elimina del conjunto conflicto (ya que es más genérico)
 3. El paso (2) se repite hasta que no pueden eliminarse más métodos. Si
el conflicto prevalece, se señala un error de compilación

En la práctica: solo paso (1)
 Sobrecarga de métodos
(Polimorfismo)

public class DemoOverloading {

void print(int a, int b) { ... }
void print(int a, char b) { ... }
void print(char a, int b) { ... }
void print(int a, int b, int c) { ... }
}
public class EjemplosManipulacionObjetos {
public static void main(String[] args) {
DemoOverloading dm = new DemoOverloading();
md.print(1, 2);
md.print(1, ’a’);
md.print(’a’, 1);
md.print(1, 2, ‘h’);
}

}
 Destructores

No existen como en C++

Metodo finalize que se ejecuta cuando
va a ser liberado por el recolector de
basura.
 Util para liberar objetos fuera de Java: C/C++
Atributos y metodos de clase

Refieridos a la clase y no a una

instancia particular
 Atributos de clase

De instancia. Cada una tiene un valor particular. Representan
el estado particular de cada objeto.

De clase. Todas las instancias comparten el mismo valor para estos
atributos (como atributo global).

Si se cambia en una instancia, se refleja en todas.

Representan el estado compartido

Se declaran utilizando el modificador static.
class Ficha {
public long id;
public static long idactual = 0;
public Ficha() {
id = idactual++;
}
}
 Métodos de clase

Como atributos: static

Unicamente pueden acceder a atributos de clase

No pueden usar la referencia this

Unicamente pueden invocar a métodos de clase

El acceso a los métodos y atributos de clase se realiza
utilizando el operador y el nombre de la clase:
Math.sqrt(...); Math.PI;

Los métodos de clase son útiles para:
 Modularizar el método main de las aplicaciones
 Bibliotecas de subrutinas (por ejemplo, java.lang.Math)
 Ejemplo de static
public class Error
{
int x ;
public static y ;

public static void main (String args[])

{
y = 15 ;
x = 20 ; ERROR
}
}
 Inicialización de atributos
estáticos

En la declaración (de arriba a abajo)

o con bloques de inicialización

class Primos {
public static int[] primos = new int[4];
static {
primos[0] = 2;
for (int i = 1; i < primos.length; i++)
primos[i] = siguientePrimo();
}
private static int siguientePrimo() {...}
}
 Acceso a atributos y métodos

El operador “.” aplicado a referencias permite el
acceso a atributos y métodos.
public class EjemplosManipulacionObjetos {
public static void main(String[] args) {
Ficha f1 = new Ficha();
System.out.println(f1.id);
f1.id = 34;
Persona juan = new Persona("Juan","5555555");
Persona maria = new Persona("María","5555555");
Persona pedro = new Persona("Pedro","5555555",
juan,maria);
System.out.println(pedro.nombre());
System.out.println(pedro.padre().nombre());
System.out.println(pedro.madre().nombre());
}

}
 Referencias

En los métodos de instancia: disponible una
referencia que refiere a la instancia particular:
this
 Por ejemplo para acceder a los atributos ocultos
por declaraciones locales en el método
null: valor de las referencias que no refieren a
ningún objeto.

Por defecto toda referencia se inicializa a null
 Referencias: Null Pointer

Error muy común: tratar de acceder a referencias
null.
public class EjemplosManipulacionObjetos2 {
public static void main(String[] args) {
Persona juan =
new Persona("Juan", "5555555");
// Levantará nullPointerException
juan.padre.nombre();
}
}
 Ejemplo con referencias
public class RefDemo {
public static void main(String[] args) {
Ficha f1;
Ficha f2;
// 1
f1 = new Ficha();
// 2
f2 = new Ficha();
// 3
f2 = f1;
// 4
f1.id++;
// 5
f2.id;++;
// 6
}
}
 Ejemplo con referencias
public class RefDemo2 {
public static void main(String[] args) {
Persona juan = new Persona("Juan","5555555");
// 1
Persona maria = new Persona("María","5555555");
// 2
Persona pedro = new Persona("María","5555555",
juan,maria);
// 3
juan = maria = null;
// 4
}
}
Modificadores de Acceso
 Modificadores de acceso:
atributos y métodos

El acceso desde otras clases, puede controlarse
mediante modificadores en su declaración:
 public : Accesibles en cualquier lugar desde donde la
clase es accesible. Así mismo, son heredados por las
subclases.
 private: Accesibles únicamente en el interior de la
clase.
 protected: accesibles en las subclases y en el código
del mismo paquete.
 Ninguno (package): Accesible en la clase y el
paquete.
 Métodos privados

En lugar de construir métodos públicos
gigantescos e ininteligibles, mejor utilizar
métodos privados.

Otro caso útil:
class Quicksort implements EstrategiaOrdenacion {
public void ordena(Comparable[] v) {
quicksort(v,0,v.length­
1);
}
private void quicksort(Comparable[] v,
int inf, int sup) {
....}
}
 Métodos para controlar el
acceso al estado

No es buena práctica de programación disponer directamente de
atributos de acceso público, excepto constantes (final)

Permite cambiar la implementación

Mejor métodos que controlen el acceso al estado (lectores, escritores:
setters, getters): encapsulamiento, control de acceso, mantenibilidad.

class Ficha {
private long id;
private static long idactual = 0;
public Ficha() {
id = idactual++;
}
public long id() {return id;}
}
 Partes protegidas (protected)

Se utiliza para aquellos atributos y métodos que pueden
ser únicamente* accedidos a nivel de subclase. De esta
forma, la parte protegida de una clase es aquellas parte
que se publica únicamente a los implementadores que
extienden la clase.

También desde cualquier clase que pertenece al paquete
de la clase que lo declara.

Como una familia y los de confianza.
 Protected: Caso particular
public class A
{
protected int p;
}

// presume class B is in a different package from A

class B extends A
{
void myMethod()
{
p = 1; // ok
A a = new A();
a.p = 1; // not ok, p would have to be
//public for this to work.
}
}
 Modificadores de acceso:
atributos y métodos

Es pe cificad or Clase Su bclase Paque te Mu n d o

private Si No No No

pr otect e d Si Si* Si No

pu blic Si Si Si Si

pa c kage Si No Si No
Herencia
 Herencia

La clase extendida es la superclase. La clase que
se extiende es la subclase

Las subclases heredan características y métodos
de las superclases (excepto los constructores)

Puede heredarse de solo una clase
 Se define una jerarquía de objetos

Pero pueden implementarse varias interfaces

Difiere de C++: herencia multiple
 Object

Todas las clases implícitamente de la clase Object: raiz de
la jerarquía.

Object define un conjunto de métodos redefinibles:
 public boolean equals(Object o): Permite definir el
criterio de igualdad de contenido de una determinada clase
 El operador == únicamente chequea la igualdad de referencias.
 En Object, equals se define directamente como la identidad de
referencias.
 public String toString(): Permite decidir la
representación externa de un objeto. Por defecto es el valor de su
referencia, etiquetada con el nombre de la clase.
 Object
public classFicha {
private long id;
private static long idactual = 0;
public Ficha() {
id = idactual++;
}
public long id() {return id;}
public boolean equals(Object o) {
return (o instanceof Ficha) &&
((Ficha)o).id() == id;
}
public String toString() {
return "Ficha(id="+id+")";
}
}
 Operadores de Comparación
de Objetos
String s1 = new String("Hola");
String s2 = new String("Hola");

if (s1 == s2) // false

...

if (s1.equals(s2)) // true
...

s1.equals(s2) equivale a s2.equals(s1)

 Heredando clases

La herencia de clases se lleva a cabo mediante extends

Establece una relación de especialización --
generalización entre clases.

La subclase puede introducir nuevos métodos y redefinir
métodos de la superclase.
 Heredando clases
public class Persona { // Hereda de Object
private String nombre;
public Persona(String nombre) {
this.nombre = nombre;
}
public String nombre() {return nombre;}
}
public class Empleado extends Persona {
private double salario;
public Empleado(String nombre,double salario) {
super(nombre);
this.salario = salario;
}
public double salario() {return salario;}
}
 Constructores y Subclases
public class Persona {

Los constructores de las private String nombre;
subclases siempre invocan public Persona(String nombre) {
un constructor en la this.nombre = nombre;
}
superclase como primera public String nombre()
acción: {return nombre;}
 El estado establecido }
public class Anonimo
en las superclases se extends Persona {
inicializa siempre antes private String encontradoEn;

Por defecto, este public Anonimo
(String encontradoEn) {
constructor es el que no this.encontradoEn = encontradoEn;
tiene argumentos. }
public String encontradoEn()

¿Qué ocurre en el
{return encontradoEn;}
ejemplo?: }
 Constructores y Subclases
public class Empleado

Los constructores no se extends Persona {
heredan. private double salario;
public Empleado() {

La forma de invocar this("*desconocido*",0);
constructores de la }
superclase desde la subclase public Empleado(double salario) {
this("*desconocido*",salario);
es a través de super(...) }

El uso de this(...) como public Empleado(String nombre,
primera sentencia de un double salario) {
constructor permite super(nombre);
this.salario = salario;
retardar la elección del }
constructor de la superclase pulic double salario()
que se va a ejecutar. {return salario;}
}
 Relación "es-un”
Para saber si la relación de herencia es correcta, se plantea la pregunta
"¿la subclase es-una superclase?". La respuesta debe ser "sí”
 ¿el Jefe es-un Empleado? Sí
 ¿la Secretaria es-un Empleado? Sí
class Bici class Bici
{ {
int numRuedas; int numRuedas;
int numAsientos; int numAsientos;
int velocidadMax; int velocidadMax;
} }
class Avion class Avion extends
Bici
{ {
int numRuedas; int numAlas;
int numAsientos; }
int velocidadMax;
int numAlas; ¿Avion es-una Bici? NO
}
 Relación de Contenido ("tiene-
un")

Una clase puede contener referencias de objetos de otras clases

Se diferencia de la herencia en que es necesario instanciarlos
por separado

Responde afirmativamente a la pregunta: ¿<Contenedor> tiene-
un <Contenido>?
class Motor class Chasis class Coche
{ { {
... ... Motor
m;
} } Chasis ch;
}

¿un Coche tiene-un Motor? Sí

¿un Coche tiene-un Chasis? Sí
 Sobreescritura de Métodos

Métodos virtuales en C++

Una subclase puede modificar los métodos que ha heredado de
la superclase, manteniendo los mismos nombre, tipo de retorno
y lista de argumentos

class Empleado
{
...
int calcularVacaciones(){...}
}

class Jefe extends Empleado

{
int numTrabajadores;
int calcularVacaciones(){...}
}
 Polimorfismo en Herencia

Una clase sólo tiene una forma, pero una variable que
hace referencia a la superclase de una jerarquía puede
tener muchas formas (una por cada subclase)
Empleado e1 = new Empleado();
Empleado e2 = new Jefe();
Empleado e3 = new Secretaria();

e2.numTrabajadores=15; // Error
((Jefe)e2).numTrabajadores=15;

Pueden utilizarse de dos maneras:
 Parámetros polimórficos
 Colecciones heterogéneas
 Parámetros Polimórficos
class Mascota {...}
class Raton extends Mascota {...}
class Gato extends Mascota {...}

class Veterinario
{
void vacunar ( Mascota m )
{...}
}

...
Veterinario doctor = new Veterinario();
Gato tom = new Gato();
Raton jerry = new Raton();
doctor.vacunar(tom);
doctor.vacunar(jerry);
...
 Colecciones Heterogéneas

Hasta ahora un array sólo podía contener elementos del mismo
tipo (colección homogénea)

Utilizando polimorfismo se pueden tener elementos de
distinto tipo en un array (colección heterogénea)

Se crean utilizando arrays definidos con el tipo superclase

Mascota[] listaMascotas = new Mascota[5];

listaMascotas[0] = new Mascota();
listaMascotas[1] = new Gato();
listaMascotas[2] = new Raton();
listaMascotas[3] = new Raton();
listaMascotas[4] = new Gato();
 Ejemplo de Colecciones
Heterogéneas

Se consigue tratar a todos los
...
elementos por igual, aunque Empleado[] lista =
alguno tenga un tratamiento new Empleado[100];
lista[0] = new Empleado();
especial lista[1] = new Empleado();
...
class Empleado lista[56] = new Jefe();
{ ...
... lista[99] = new Empleado();
int salario; for (int i = 0;
int calcularVacaciones(){...} i < lista.length; i++)
{
}
System.out.println(
class Jefe extends Empleado lista[i].
{ calcularVacaciones());
int numTrabajadores; }
int calcularVacaciones(){...}
}
De diagramas de clase (UML)
a Java
 Transformación de clases para
una implementación OO
• Todo atributo y operación en el diagrama de clases se
debe declarar formando parte de su clase correspondiente.

class LíneaVenta {
Línea Venta
int cantidad;
cantidad:entero subtotal( ) {...}
subtotal( ) LíneaVenta() {...}
}
 Transformación de
asociaciones para una
implementación OO
• Una asociación bidireccional es implementada,
normalmente, como un atributo de referencia dentro de
cada objeto asociado.

• Si la asociación es unidireccional sólo se necesita añadir

un atributo de referencia a una de las clases.

• Una asociación también se puede implementar como una

clase.
 Transformación de
asociaciones para una
implementación OO
• Los atributos de referencia de la clase “uno” son
simplemente referencias a un objeto.

• Los atributos de referencia de la clase “muchos”

necesitan un contenedor de objetos.

• Una asociación cualificada se puede implementar en

forma de objeto diccionario.
 Transformación de
asociaciones para una
implementación OO
1..* trabajapara 1
Persona Compañía
empleado empresario

class Persona { class Compañía {

Compañía empresario; Persona[] empleado;
Persona( ) { Compañía( ) {
} }
} }
 Transformación de
asociaciones para una
implementación OO
1..* Edita 1
Libros Editorial

class Libro { class Editorial {

Libro( ) { Libro[] mislibros;
} Editorial( ) {
} }
}
 Transformación de clase
asociación para una
implementación OO
0..* Esta autorizado en 0..*
Usuario Estación de
trabajo
Autorización

class autorización {
class Usuario { class estaciónt {
usuario miusuario;
autorización[] miautori; autorización[] miautori;
estaciónt miestación;
Usuario( ){ estaciónt( ){
autorización( ){
} }
}
} }
}
 Transformación de atributos
de enlace para una
implementación OO

• Asociación uno-a-uno: Los atributos de enlace se pueden

almacenar como atributos de cualquiera de los objetos.

• Asociación uno-a-muchos: Los atributos de enlace se

pueden almacenar como atributos del objeto “muchos”.

• Asociación muchos-a-muchos: Se implementa la

asociación como una clase.
 Transformación de agregación
para una implementación OO
•Se implementa igual que la asociación.

computadora
1..* 1
monitor teclado
class Computadora {
Monitor[] mismonitores; class Monitor { class Teclado {
Teclado miteclado; Monitor( ) { Teclado( ) {
Computadora( ) { } }
} } }
}
 Transformación de herencia
simple para una
implementación OO
Lámpara

Fluorescente Incandescente

class Lámpara { class Fluorescente extends class Incandescente

Lámpara extends Lámpara
Lámpara( ) { { {
} Fluorescente( ) { Incandescente( ) {
} } }
} }
Paquetes
 Paquetes

Un paquete es una agrupación de clases (librería)

El programador puede crear sus propios paquetes con la
sentencia package al principio del fichero fuente
 package <nombre.paquete>;
 Ejemplo: package empresa.finanzas;

La composición de nombres (separados por puntos) está
relacionada con la jerarquía de directorios:
CLASSPATH\empresa\finanzas\

Los nombres de los paquetes se suelen escribir en
minúsculas
 Ejemplo de Paquetes

Fichero fuente Empleado.java:

package empresa.finanzas;
public class Empleado
{
...
}


La clase Empleado realmente se llama empresa.finanzas.Empleado

Si no se indica la sentencia package, la clase Empleado pertenecerá a
un paquete por defecto sin nombre
 Sentencia import

La sentencia import indica al compilador dónde están
ubicadas las clases que estamos utilizando

Para importar sólo una clase de un paquete:
 import <nombre.paquete>.<NombreClase>;

Para importar todas las clases de un paquete:
 import <nombre.paquete>.*;

El compilador añade a todos los ficheros la línea
 import java.lang.*;
 El paquete que contiene las clases fundamentales para programar
en Java (System, String, Object...)
 Ejemplo de import

import empresa.finanzas.*;
public class Jefe extends Empleado
{
String departamento;
Empleado[] subordinados;
}
Si no se pone el import, deberíamos referirnos a
Empleado como empresa.finanzas.Empleado
La clase Jefe pertenece al paquete anónimo por
defecto
String pertenece al paquete java.lang
 Modificadores de acceso:
atributos y métodos

Es pe cificad or Clase Subclase Paque te Mun do

private Si No No No

pr otect e d Si Si* Si No

pu blic Si Si Si Si

pa c kage Si No Si No
Clases Abstractas
 Clases Abstractas

Una clase abstracta es una clase de la que no se pueden
crear objetos

Representa un concepto que no se puede instanciar
Se define anteponiendo el modificador abstract a la
definición de una clase

abstract class Mamifero {...}

class Canino extends Mamifero {...}
class Felino extends Mamifero {...}
class Roedor extends Mamifero {...}
...

Mamifero m = new Mamifero(); // Error

 Métodos Abstractos

Un método es abstracto si se declara 
Todas las subclases de una clase
(dentro de una clase abstracta), pero abstracta deben implementar los
no se implementa métodos abstractos que tenga
definidos, a menos que sea tambien
abstract class Mamifero abstracta
{
... class Canino extends Mamifero
public abstract { ...
void alimentar(); public void alimentar()
} {...}
}
class Felino extends Mamifero
{ ...
public void alimentar()
{...}
}
 Ejemplo
Jerarquía de figuras
geométricas:
class Rectangulo
class Punto
extends Figura
{
{
int x;
Punto ptoFinal;
int y;
void dibujar()
int color;
{...}
}
}
abstract class Figura
class Circulo
{
extends Figura
Punto ptoOrigen;
{
abstract void
int radio;
dibujar();
void dibujar()
}
{...}
}
Interfaces
 Interfaces (I)

Una interface es un conjunto de declaraciones de métodos
Declaración:
interface <NombreInterfaz>
{
<tipo> <nombreMétodo1> ( <args> );
<tipo> <nombreMétodo2> ( <args> );
...
}


Una clase que implemente el código de la interfaz debe
implementar todos sus métodos
class <NombreClase> implements <NombreInterfaz>
{
<tipo> <nombreMétodo1> ( <args> ) { <código> }
<tipo> <nombreMétodo2> ( <args> ) { <código> }
...
}
 Interfaces (II)

Las interfaces sirven para:
 Declarar métodos que serán implementados
por una o más clases
 Definir la interfaz de programación de un
objeto, sin mostrar el cuerpo actual de la clase

Cada interfaz debe escribirse en un fichero
*.java con el mismo nombre de la interfaz
 Equivalencia
Interfaz - Clase Abstracta
interface Interfaz
{
<tipo> <método1>();
<tipo> <método2>();
...
<tipo> <métodoN>();
}

equivale a

abstract class Interfaz

{
abstract <tipo> <método1>();
abstract <tipo> <método2>();
...
abstract <tipo> <métodoN>();
}
Vector
 La Clase Vector (I)

La clase Vector (paquete java.util) representa una colección
heterogénea de objetos (referencias a objetos de tipo Object o a
cualquiera de sus subclases)

El vector al crearse reserva cierta cantidad de memoria, aunque
sus elementos sólo utilicen una parte

El tamaño del vector se incrementa por bloques cuando se
añade y se agota el espacio reservado. El tamaño de incremento
se indica en el atributo capacityIncrement

El vector se mantiene compacto en todo momento

Cada elemento es accesible a través de un índice, pero no con
los corchetes, [ ]
 La Clase Vector (II)

Atributos:
 int capacityIncrement: incremento en la capacidad del vector.
Si vale cero, duplica el tamaño actual del vector.
 int elementCount: número de elementos válidos del vector
 Object[] elementData: array de objetos donde se guardan los
elementos

Constructores:
 Vector(): Crea un vector vacío (capacidad 10, incremento 0)
 Vector(int initialCapacity): Crea un vector vacío con la
capacidad dada (incremento 0)
 Vector(int initialCapacity, int
initialIncrement): Crea un vector vacío con la capacidad y el
incremento dados
 La Clase Vector (III)

Métodos:
int capacity() devuelve la capacidad que tiene el vector
int size() devuelve el número de elementos en el vector

boolean contains(Object elem) devuelve true si el vector contiene el objeto

especificado
int indexOf(Object elem) devuelve la posición de la primera vez que
aparece el objeto que se le pasa
Object get(int index) devuelve el elemento situado en la posición
indicada (*)
void set(Object elem,int reemplaza el objeto que corresponde al índice
index) por el objeto que se le pasa (*)

Los métodos con (*) pueden lanzar la excepción ArrayIndexOutOfBoundsException
 La Clase Vector (III)

Métodos:

void removeElementAt(int borra el objeto situado en la posición indicada

index) (*)
void addElement(Object elem) añade un objeto al final
void insertElementAt(Object inserta el objeto que se le pasa en la posición
elem, indicada, desplazando el resto de elementos
int index) en el vector (*)