Java – Modulo 2

Clases, Herencia, Interfaces

Contenido

Arreglos UML: Diagramas de

Clase Declarando clases: repaso

+ detalle Atributos y métodos de

clase Modificadores de Acceso Herencia

De Diagramas de Clase a Java

Paquetes Clases Abstractas Interfaces Vector Colecciones

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 entre llaves para cada dimensión

int[][] matriz =

{

{1, 2, 3},

{4, 5, 6}

};

equivale a

int[][] matriz =

new int[2][3]; matriz[0][0] = 1; matriz[0][1] = 2; 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

public class Palindrome { public static boolean isPalindrome(

String stringToTest) { String workingCopy = removeJunk(stringToTest); String reversedCopy = reverse(workingCopy);

return reversedCopy.equalsIgnoreCase(workingCopy); }

protected static String removeJunk(String string) { int i, len = string.length(); StringBuffer dest = new StringBuffer(len); char c;

for (i = (len - 1); i >= 0; i--) { c = string.charAt(i); if (Character.isLetterOrDigit(c)) { dest.append(c); } }

return dest.toString(); }

protected static String reverse(String string) { StringBuffer sb = new StringBuffer(string);

return sb.reverse().toString(); }

public static void main(String[] args) { String string = "Madam, I'm Adam.";

System.out.println(); System.out.println("Testing whether the following " + "string is a palindrome:"); System.out.println(" " + string); System.out.println();

if (isPalindrome(string)) { System.out.println(

"It IS a palindrome!"); } else { System.out.println(

"It is NOT a palindrome!"); } System.out.println(); }}

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;

// Constructorespublic 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

1..N

Asociación

Agregación

Herencia

+ Creados: integer+ RetrasoMedio: float

+ CreaPaquete() ...

Red

Nodos

+ Id: integer+ Procesados: integer+ ServicioMedio: float+ RestrasoMedio: float ...

Nodo

1..1

+ NMedio: integer+ Tamaño: float

+ Encola(Paquete)+ Desencola():Paquete

ColaEnEspera

1..N

+ Id: integer+ tamaño: integer

Paquete

PaquetesSiguiente

1..1

Origen

1..1

1..1Destino

Diagramas de Clases (UML)

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

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

Sino es publica, solo visible en el mismo paquete.

Partes de ladeclaracion

La clase. . .

public es pﾜblicamente accesibleabstract no puede ser instanciadafinal la clase no puede ser derivadaclass Name tiene por nom bre Name� �extendsSuperClass

hereda de SuperClass

implementsInterfaces

implementa ciertas Interfaces

{ cuerpo... }

Declarando un atributo

Partes de la declaraci nﾗ Pro pos itoniveld eacceso private, protected, etc.static si es una var de clasefinal es constantetransient no serializarvolatile cambia inesperadamente

(thread)tipo nombre

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 itoniveld eacceso private, protected, etc.static mﾎtodo de claseabstract sin implementacionfinal no puede ser sobreescritonative otro lenguaje (c/c++)synchronized requiere monitor

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

class Punto {

private double x;

private double y;

public Punto() {

this(0.0,0.0);

}

public Punto(double x,

double y) {

this.x = x;

this.y = y;

}

...

}

class Circulo {

private Punto centro;

private double radio;

public Circulo() {

this(new Punto(),1);

}

public Circulo(double x,

double y, double radio) {

this(new Punto(x,y),radio);

}

public Circulo(Punto centro, double radio) {

this.centro = centro;

this.radio = radio;

} ... }

Constructores

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

}

}

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

}

}

Ejemplo con referencias

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 Aclass B extends A{

void myMethod(){

p = 1; // okA 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 cificador Clase Subclase Paque te Mundo

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 class Ficha { 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

Los constructores de las subclases siempre invocan un constructor en la superclase como primera acción:

El estado establecido en las superclases se inicializa siempre antes

Por defecto, este constructor es el que no tiene argumentos.

¿Qué ocurre en el ejemplo?:

public class Persona { private String nombre; public Persona(String nombre) {

this.nombre = nombre; } public String nombre()

{return nombre;} } public class Anonimo

extends Persona { private String encontradoEn; public Anonimo

(String encontradoEn) { this.encontradoEn = encontradoEn; } public String encontradoEn(){return encontradoEn;}

}

Constructores y Subclases

Los constructores no se heredan.

La forma de invocar constructores de la superclase desde la subclase es a través de super(...)

El uso de this(...) como primera sentencia de un constructor permite retardar la elección del constructor de la superclase que se va a ejecutar.

public class Empleado

extends Persona { private double salario; public Empleado() {

this("*desconocido*",0); } public Empleado(double salario) {

this("*desconocido*",salario); } public Empleado(String nombre,

double salario) { super(nombre); this.salario = salario;

} pulic double salario()

{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 alguno tenga un tratamiento especial

class Empleado

{...int salario;int calcularVacaciones(){...}

}

class Jefe extends Empleado

{int numTrabajadores;int calcularVacaciones(){...}

}

...Empleado[] lista = new Empleado[100];lista[0] = new Empleado();lista[1] = new Empleado();...lista[56] = new Jefe();...lista[99] = new Empleado();for (int i = 0; i < lista.length; i++) { System.out.println( lista[i]. calcularVacaciones());}

De diagramas de clase (UML)a Java

• Todo atributo y operación en el diagrama de clases se debe declarar formando parte de su clase correspondiente.

Línea Venta

cantidad:entero

subtotal( )

class LíneaVenta {

int cantidad;

subtotal( ) {...}

LíneaVenta() {...}

}

Transformación de clases para una implementación OO

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.

• 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

Persona Compañía1..* 1trabajapara

empleado empresario

class Compañía {

Persona[] empleado; Compañía( ) {

}

}

class Persona {

Compañía empresario;

Persona( ) {

}

}

Transformación de asociaciones para una implementación OO

Libros Editorial1..* 1Edita

class Editorial {

Libro[] mislibros; Editorial( ) {

}

}

class Libro {

Libro( ) {

}

}

Transformación de asociaciones para una implementación OO

Usuario Estación de trabajo

0..* 0..*Esta autorizado en

Autorización

class Usuario { autorización[] miautori; Usuario( ){ }}

class autorización { usuario miusuario; estaciónt miestación; autorización( ){ }}

class estaciónt { autorización[] miautori; estaciónt( ){ }}

Transformación de clase asociación 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 atributos de enlace para una implementación OO

•Se implementa igual que la asociación.

computadora

tecladomonitor

1..* 1

class Computadora { Monitor[] mismonitores; Teclado miteclado; Computadora( ) { }}

class Monitor { Monitor( ) { }}

class Teclado { Teclado( ) { }}

Transformación de agregación para una implementación OO

Lámpara

IncandescenteFluorescente

class Lámpara { Lámpara( ) { }}

class Fluorescente extends Lámpara { Fluorescente( ) { }}

class Incandescente extends Lámpara

{ Incandescente( ) { }}

Transformación de herencia simple para una implementación OO

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.EmpleadoLa clase Jefe pertenece al paquete anónimo por defectoString pertenece al paquete java.lang

Modificadores de acceso: atributos y métodos

Espe cificador Clase Subclase Paque te Mundo

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 (dentro de una clase abstracta), pero no se implementa

abstract class Mamifero{ ... public abstract

void alimentar();}

Todas las subclases de una clase abstracta deben implementar los métodos abstractos que tenga definidos, a menos que sea tambien abstracta

class Canino extends Mamifero{ ... public void alimentar()

{...}}

class Felino extends Mamifero{ ... public void alimentar()

{...}}

Ejemplo

Jerarquía de figuras geométricas:

class Punto{ int x; int y; int color;}

abstract class Figura { Punto ptoOrigen; abstract void dibujar();}

class Rectangulo extends Figura{ Punto ptoFinal; void dibujar() {...}}

class Circulo extends Figura{ int radio; void dibujar() {...}}

Interfaces

Interfaces (I)

Una interface es un conjunto de declaraciones de métodosDeclaració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:

Los métodos con (*) pueden lanzar la excepción ArrayIndexOutOfBoundsException

reemplaza el objeto que corresponde al índice por el objeto que se le pasa (*)

void set(Object elem,int index)

devuelve el elemento situado en la posición indicada (*)

Object get(int index)

devuelve la posición de la primera vez que aparece el objeto que se le pasa

int indexOf(Object elem)

devuelve true si el vector contiene el objeto especificado

boolean contains(Object elem)

devuelve el número de elementos en el vectorint size()

devuelve la capacidad que tiene el vectorint capacity()

La Clase Vector (III)

Métodos:

inserta el objeto que se le pasa en la posición indicada, desplazando el resto de elementos en el vector (*)

void insertElementAt(Object elem,

int index)

añade un objeto al finalvoid addElement(Object elem)

borra el objeto situado en la posición indicada (*)

void removeElementAt(int index)