Clases abstractas

Clases cuya descripción es incompleta. Una

clase abstracta declara métodos, pero no
Clases abstractas e interfaces tiene que implementarlos.
n No proporcionan la implementación de todos sus
métodos
w Los métodos no implementados se declaran
como abstract
n Una clase con un método abstracto debe
declararse como clase abstracta
w Pero una clase puede declararse como
abstracta aunque no tenga ningún método
abstracto

Java Arrays y Cadenas 1 Java Arrays y Cadenas 2

Clases abstractas Clases abstractas

Forma
{abstract} public abstract class Forma {
private int xpos, ypos; los métodos
xpos
ypos
private Color color; abstactos no
color // ... tienen
... public abstract void dibuja();
dibuja public void setColor(Color c){ /*...*/ }; cuerpo
setColor }
... dibuja un
public class Circle extends Forma{
private int radio; círculo
// ...
Otras public void dibuja(){ /*...*/ };
public void setRadio(int){/*...*/};
Circulo Rectangulo
}
radio altura dibuja un
... anchura public class Rectangle extends Forma{
... rectángulo
setRadio private int altura, anchura;
... setAltura // ...
...
public void dibuja(){ /*...*/ };
public void setAltura(int){/*...*/};
}
Java Arrays y Cadenas 3 Java Arrays y Cadenas 4

Clases abstractas Ejemplo clase abstracta

n Las subclases de una clase abstracta deben:
w Sobreescribir todos los métodos abstractos de
la superclase, o bien
w Ser declaradas como clases abstractas
n Una clase abstracta no puede instanciarse
w No se pueden crear objetos de una clase
abstracta
n Una clase abstracta puede incluir variables y
métodos no abstractos.
n No se pueden definir constructores abstractos o
métodos estáticos abstractos.
Java Arrays y Cadenas
public abstract class Figura {
Figura int x, y;
public void mostrarOrigen () {
System.out.println("x= "+x+" y= "+y);}
public abstract double area(); // No tiene implementación
Triangulo
public abstract double mostrarNombre ();
Cuadrado }
public class Triangulo extends Figura {
protected int base, altura;
public Triangulo (int ba, int al) { base=ba; altura=al; }
public double area() { return base* altura/2; }
public void mostrarNombre () { System.out.println(“triangulo”); }
}
public class Cuadrado extends Figura {
protected int lado ;
public Cuadrado (int lado) { this.lado =lado; }
public double area() { return lado*lado; }
public void mostrarNombre () { System.out.println(“cuadrado”);}}
5 Java Arrays y Cadenas 6

1
Prueba clase abstracta Interfaces
public class
public class PruebaClaseAbstracta
PruebaClaseAbstracta {{
public static
public static void
Figura fig;
Figura
void main(String
fig;
main(String args[])
args[]) {{
Sólo declaran comportamiento
Triangulo tri;
Triangulo tri;
Cuadrado cua;
Cuadrado cua; n Se utiliza la palabra clave interface
fig == new
new Figura();
Figura(); //
// error
error no
no se
se puede
puede
n Por defecto todos sus métodos son
públicos y abstractos
fig
//instanciar una
//instanciar una clase
clase abstracta
abstracta

w No implementan el comportamiento
tri == new
tri new Triangulo(4,3);
Triangulo(4,3);
tri.mostrarOrigen();
tri.mostrarOrigen ();
tri.mostrarNombre();
tri.mostrarNombre ();
n Por defecto todos sus atributos son
fig == tri
fig tri;; públicos, constantes y de clase
fig.mostrarNombre();
();
w Por legibilidad normalmente los declaramos
fig.mostrarNombre
System.out.println("Area triangulo:
System.out.println("Area triangulo: "+fig
"+fig.area());
.area());
static y final
cua == new
cua new Cuadrado(5);
Cuadrado(5);
fig == cua
fig cua;;
System.out.println("Area cuadrado:
System.out.println("Area cuadrado: "+fig.area());
"+fig.area());
}} Java Arrays y Cadenas 7 Java Arrays y Cadenas 8
}}

Interfaces Declaración de interfaces

Permite simular algunos aspectos de la Sintaxis

herencia múltiple interface NombreInterfaz
interface NombreInterfaz {{
n Define un tipo de datos tipo static
tipo static final
final NOMBRECONSTANTE1
NOMBRECONSTANTE1 == valor;
valor;
…….….….
Posibilita el enlace dinámico …….….….
n public tipoDevuelto
tipoDevuelto nombreMetodo1(
nombreMetodo1(listaParámetros)
listaParámetros);;
public
Otras clases pueden implementar un interfaz …….….….
…….….….
}}
n Cualquier clase que implemente un interfaz debe
definir todos los métodos de dicho interfaz Implementación
class
class del
NombreClase implements
NombreClase implementsinterfaz en una
NombreInterfaz1
NombreInterfaz1 clase
w Debe proporcionar la implementación de dichos métodos [, NombreInterfaz2
[, NombreInterfaz2 ..]
..] {{
n Una clase puedeatributos
implementar variosdeinterfaces
Si la clase no proporciona la implementación para // declaración
// declaración atributos yy métodos
métodos de la clase
la clase
n …….….….
todos los métodos del interfaz debe ser declarada …….….….
}}
como abstracta
Java Arrays y Cadenas 9 Java Arrays y Cadenas 10

interfaces Ejemplo de interfaz

Programador es un Asalariado public interface
public interface Nombrable
Nombrable {{
static final
static final boolean
boolean CIERTO CIERTO == true;
true;
Asalariado
public void
public void mostrarNombre();
mostrarNombre();
implements }}
ite public class
public class Elemento
Elemento implements
implements NombrableNombrable {{
rm
Empelado pe String nombre;
String nombre;
se
public Elemento(String
public Elemento(String nom) nom) {{
extends nombre == nom;
nombre nom; }}
// obligatorio
// obligatorio implementar
implementar método método mostrarNombre
mostrarNombre
Programador Payable p = new Programmer();
public void
public void mostrarNombre(){
mostrarNombre(){
System.out.println("Nombre: "+nombre);
System.out.println("Nombre: "+nombre);
if (CIERTO)
if (CIERTO)
System.out.println("Constante CIERTO
System.out.println("Constante CIERTO ");
");
Java Arrays y Cadenas 11 }} Java Arrays y Cadenas 12
}}

2
Uso del interfaz con enlace
dinámico Ejemplo de interfaces
{interface}
public class
public class PruebaInterfaz
PruebaInterfaz {{ Humano Actor Canino

public static
public static void
void main(String
main(String args[])
args[]) {{
Elemento elem;
Elemento elem;
Nombrable inter;
Nombrable inter;

elem == new
elem new Elemento(“Luis");
Elemento(“Luis");
elem.mostrarNombre();
elem.mostrarNombre();

// una
// una referencia
referencia aa interfaz
interfaz puede
puede Persona
Person Perro

... ...
//utilizarse con
//utilizarse con una
una instancia
instancia de
de
actua()
act() actua()
// una
// una clase
clase que
que lo
lo implemente
implemente ... ...

inter == elem;
inter elem;
inter.mostrarNombre();
inter.mostrarNombre(); }}
Java Arrays y Cadenas 13 Java Arrays y Cadenas 14
}}

Ejemplo de interfaces Extensión de interfaces

interface Actor
{
void actua(); Se puede definir un interface que
}
sin cuerpo especialice a otro interface mediante
extends
public class Persona extends Humaon implements
Actor { n Es similar a la herencia de clases
public void actua(){ /*...*/};
//...
}

public class Perro extends Canino implements

Actor {
public void actua(){ /*...*/};
//...
}
Java Arrays y Cadenas 15 Java Arrays y Cadenas 16

Extensión de interfaces Résumen de interfaces

No obstante un interface puede Las interfaces sirven para:
n Declarar métodos que serán implementados por
extender a varios interfaces a la vez una o más clases.
n Aquí la herencia múltiple no plantea n Determinar la interfacede programación de un
problemas porque no se hereda código objeto, sin mostrar el cuerpo de la clase.
interface ElementoOrdenado
interface ElementoOrdenado extends
extends n Capturar similitudes entre clases no relacionadas,
Comparable, Cloneable,
Comparable, Cloneable, java.io.Serializable
java.io.Serializable {{ sin forzar una relación entre ellas.
// miembros
// miembros yy métodos
métodos propios
propios del
del interfaz
interfaz n Describir objetos "tipo-función", que podrán ser
//ElementoOrdenado
//ElementoOrdenado utilizados como argumentos al invocar métodos
.....
..... sobre objetos.
}}
Java Arrays y Cadenas 17 Java Arrays y Cadenas 18

3
 Résumen de interfaces

Class Abstract Interface

Tipo
Class
extends extends implements
herencia
(simple) (simple) (multiple)
instanciable yes no no
implementa metodos algún método nada
datos Se Se no se
permiten permiten permiten

Java Arrays y Cadenas 19