JAVA
ORIENTACIÓN A OBJETOS
1
Arquitecturas Orientadas a Servicios para la Gestión de Contenidos – Universidad de Alicante
ORIENTACIÓN A OBJETOS
Conceptos de la OO:
•Clase
•Objeto
•Propiedad
•Método
•Herencia
•Polimorfismo
ORIENTACIÓN A OBJETOS
Java:
•Diseñado desde el principio como un lenguaje orientado a
objetos.
•Integración en el ámbito de las telecomunicaciones, en
concreto, internet.
•Lenguaje de gran actualidad e interés.
CLASES Y OBJETOS
Clase: Tipo de datos definido por el usuario.
Objeto: Es un dato del tipo definido por su clase, es decir, es
una instancia específica de su clase.
CLASES Y OBJETOS
Fases de la vida de un objeto:
Creación del Objeto: declaración + instanciación
Objeto instanciado
Destrucción del Objeto
Creación del Objeto: Destrucción del Objeto:
Objeto instanciado
Constructor Destructor
CLASES Y OBJETOS
Declaración de una clase en Java:
Class <nombre_de_la_clase> { }
Declaración de un Objeto:
<nombre_de_la_clase> <nombre_del_objeto>
Instanciación de un Objeto: mediante la palabra clave new
Ejemplo:
Class Vehiculo{ }
Vehiculo miVehiculo = new Vehiculo();
PROPIEDADES Y MÉTODOS
Campos de datos dentro de una clase: variables miembros o
propiedades de la clase.
Operaciones con los datos de una clase: funciones miembros o
métodos de la clase.
Los miembros de una clase (propiedades y métodos) pueden
ser:
Públicos; se puede acceder a ellos desde fuera de la clase
Privados; sólo se puede acceder a ellos desde dentro de la
clase
Para acceder a propiedades privadas de la clase se definen
métodos de acceso.
Un miembro puede ser estático, si pertenece a la clase en sí y
no a los objetos de la clase.
PROPIEDADES Y MÉTODOS
Definición en Java de una clase con sus propiedades y métodos:
<modificador> class <nombre_de_la_clase> {
private <tipo_de_dato> <nombre_del_dato>;
public <nombre_de_la_clase> (<lista_de_argumentos>) {
<codigo_del_metodo_constructor>
}
public <tipo_de_dato_devuelto> <nombre_del_metodo>
(<lista_de_argumentos>) {
<codigo_del_metodo>
}
}
PROPIEDADES Y MÉTODOS
Palabras clave para restringir el acceso a los miembros de una
clase:
public
private
protected
Miembro estático: static
PROPIEDADES Y MÉTODOS
public class Vehiculo {
private int numeroRuedas;
private double velocidadMaxima;
public String nombrePropietario;
static private String nombreFabrica = "SEAT";
public Vehiculo(int nRuedas) {
if (nRuedas<0) numeroRuedas=0;
else numeroRuedas = nRuedas;
}
public void estableceVelocidadMaxima(double vMaxima) {
if (vMaxima<0) velocidadMaxima=0.0;
else velocidadMaxima = vMaxima;
}
PROPIEDADES Y MÉTODOS
public double recuperaVelocidadMaxima() {
return velocidadMaxima;
}
static public String recuperaNombreFabrica() {
return nombreFabrica;
}
}//Fin de la declaración de clase
PROPIEDADES Y MÉTODOS
Declaración e instanciación de un objeto:
Vehiculo miVehiculo = new Vehiculo(4);
Acceso a un dato publico:
[Link] = “Cipriano López”;
String nombre = [Link];
Acceso a un dato privado:
[Link](200.0);
Double velocidad = [Link]();
Acceso a un dato estático:
String nombre = [Link]();
PAUTAS BÁSICAS EN DISEÑO ORIENTADO A
OBJETOS
• Hacer una lista de todas las propiedades y métodos que
requiera el programa.
• Clasificar dichas propiedades y métodos dentro de clases.
Realizar un buen diseño supone:
• Ahorro e tiempo y esfuerzo en la fase de programar
• Código resultante de mayor calidad: más fácil de depurar y
mantener
USO CORRECTO DE OBJETOS
Privacidad de los objetos
Prevención de efectos laterales
Comparación de objetos
Tratamiento de excepciones
PRIVACIDAD DE LOS OBJETOS
//Declarar los campos de los objetos como privados
//Ofrecer métodos públicos para su acceso
public class Elemento {
private int dato;
public Elemento(int valor) {
dato = valor;
}
public int valor() {
return dato;
}
} // fin class Elemento
Elemento elemento = new Elemento(10);
int n = [Link]();
PREVINIENDO EFECTOS LATERALES
//Utilización del método clone
public class Elemento implements Cloneable {
private int dato;
public Elemento(int valor) {
dato = valor;
}
public Object clone() {
return new Elemento(dato);
}
} // fin class Elemento
elemento1 = (Elemento)[Link]();
COMPARACIÓN DE OBJETOS
//Utilización del método equals
public class Elemento {
private int dato;
public Elemento(int valor) {
dato = valor;
}
public Object clone() {
return new Elemento(dato);
}
public boolean equals(Object elemento) {
if (elemento==null) return false;
Elemento e = (Elemento)elemento;
return (dato==[Link]);
}
} // fin class Elemento
if ([Link](elemento2)) {
// cuerpo de la sentencia condicional
}
COMPARACIÓN DE OBJETOS
//Utilización del método toString
public class Elemento {
private int dato;
public Elemento(int valor) {
dato = valor;
}
public Object clone() {
return new Elemento(dato);
}
public boolean equals(Object elemento) {
if (elemento==null) return false;
Elemento e = (Elemento)elemento;
return (dato==[Link]);
}
public toString(){
return ""+dato;
}
} // fin class Elemento
[Link](elemento);
TRATAMIENTO DE EXCEPCIONES
Java posee un mecanismo propio para el manejo de errores
mediante excepciones
Cuando va a producirse una situación de error, ésta se traduce una
excepción.
Por ejemplo, para la segunda definición de la clase Estructura vista en la
sección anterior, el acceso a los datos del array debe hacerse mediante
métodos de interface, y dentro de estos métodos, el acceso a una posicion
no correcta puede traducirse en una excepción
public class Estructura {
private Object dato[];
private int longitud;
public Estructura(int n) throws LongitudNoValidaException {
if (n<0) throw new LongitudNoValidaException("Longitud
no válida. Debe ser positiva");
longitud = n;
dato = new Object[n];
}
TRATAMIENTO DE EXCEPCIONES
public Object recuperaDato(int i) throws IndiceNoValidoException {
if ((i<0)||(i>=longitud)) throw new IndiceNoValidoException("Indice
no válido. Debe estar entre 0 y "+longitud-1);
return dato[i];
}
public void estableceDato(int i, Object valor)
throws IndiceNoValidoException {
if ((i<0)||(i>=longitud)) throw new IndiceNoValidoException("Indice
no válido. Debe estar entre 0 y "+longitud-1);
dato[i] = valor;
}
} // fin class Estructura
TRATAMIENTO DE EXCEPCIONES
Podemos crear nuevas excepciones como clases que
heredan de la clase Exception
public class LongitudNoValidaException extends Exception {
public LongitudNoValidaException() { super(); };
public LongitudNoValidaException(String s) { super(s); };
}
public class IndiceNoValidoException extends Exception {
public IndiceNoValidoException() { super(); };
public IndiceNoValidoException(String s) { super(s); };
}
TRATAMIENTO DE EXCEPCIONES
Para utilizar las llamadas a métodos con excepciones, se deben
manejar dichas excepciones mediante bloques try catch
try {
Estructura estructura = new Estructura(10);
[Link](0,elemento);
elemento = [Link](0);
} catch (LongitudNoValidaException e) {
[Link](e);
} catch (IndiceNoValidoException e) {
[Link](e);
}