0% encontró este documento útil (0 votos)
92 vistas

Java - Modulo 2

Este documento describe conceptos de Java relacionados con clases, herencia e interfaces. Explica cómo declarar clases, atributos y métodos, y los modificadores de acceso. También cubre temas como herencia, interfaces, paquetes, clases abstractas, arrays unidimensionales y multidimensionales. Finalmente, introduce conceptos de modelado orientado a objetos como diagramas de clases UML.

Cargado por

Milton Serrano
Derechos de autor
© © All Rights Reserved
Formatos disponibles
Descarga como PPT, PDF, TXT o lee en línea desde Scribd
0% encontró este documento útil (0 votos)
92 vistas

Java - Modulo 2

Este documento describe conceptos de Java relacionados con clases, herencia e interfaces. Explica cómo declarar clases, atributos y métodos, y los modificadores de acceso. También cubre temas como herencia, interfaces, paquetes, clases abstractas, arrays unidimensionales y multidimensionales. Finalmente, introduce conceptos de modelado orientado a objetos como diagramas de clases UML.

Cargado por

Milton Serrano
Derechos de autor
© © All Rights Reserved
Formatos disponibles
Descarga como PPT, PDF, TXT o lee en línea desde Scribd
Está en la página 1/ 97

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 (*)

También podría gustarte