Java - Modulo 2
Java - Modulo 2
que equivale a
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];
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)
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
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... }
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)
}
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
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;
}
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.equals(s2)) // true
...
class Empleado
{
...
int calcularVacaciones(){...}
}
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
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.
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
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
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
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
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