Post on 28-Jan-2016
transcript
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)