Java: Clases y Objetos

Java Clases y objetos BFM 1

 Clases
• La unidad fundamental de programación en Java es la
clase
• Un programa Java está formado por un conjunto de clases
• Una clase es una “plantilla” que describe un conjunto de
objetos con atributos y comportamiento similares
• Un programa Java en ejecución crea y manipula (mediante
llamadas a métodos) objetos concretos (ejemplares o
instancias)
• Cada objeto es un ejemplar de una clase
• Cuando se invoca un método de un objeto, se mira en el
código de su clase las acciones a ejecutar
• Un objeto puede usar otros para realizar su trabajo

Java Clases y objetos BFM 2

 Clases
• Una definición de clase comprende:
• Cabecera
• Campos o atributos:
– Variables
estado del objeto
– Constantes
• Métodos:
– Funciones comportamiento
– Constructores
– Bloques de inicialización static
– Finalizador

Java Clases y objetos BFM 3

 Definición de una clase

[Modificadores] class NombreClase [extends SuperClase] {

// definición de los atributos de la clase
tipo1 identificador1;
tipo2 identificador2;
……….…………….
// definición de los métodos de la clase
tipoDevuelto nombreMetodo1 (listaParametros) {
//instrucciones del método1
}
tipoDevuelto nombreMetodo2 (listaParametros) {
//instrucciones del método2
}
……….…………….
}

Java Clases y objetos BFM 4

 Modificadores de clase
• Modificadores:
• public class NombreClase // visible fuera del paquete
– Normalmente la clase se almacena en un fichero NombreClase.java
– En un fichero .java puede haber como mucho una clase public
• class C extends superclase // la clase hereda de otra
– Sólo herencia simple (una sóla superclase)
– Si no aparece extends la clase definida hereda (es una subclase) de un
objeto general del sistema llamada Object

public class Rectangulo{ Object

int x;
int y;
int ancho;
int alto; Rectangulo
// faltan los métodos de Rectángulo
}

Java Clases y objetos BFM 5

 Variables, objetos y referencias
• Una variable de un determinado tipo simple proporciona
– Capacidad para almacenar un valor simple
– Un conjunto predifinido de operadores
• Un objeto de una determinada clase proporciona
• Capacidad para almacenar diversos valores (atributos)
• Define su propio conjunto de métodos para operar sobre las
instancias o ejemplares de esa clase
• Cuando se declara un objeto de una clase se crea una
referencia a una instancia de dicha clase
– Incialmente toma el valor null porque no existe objeto al que referirse
– No son punteros con los que se pueda trabajar directamente
num 5
int num = 5;
Rectangulo rect;
rect null
Java Clases y objetos BFM 6
 Creación de instancias o ejemplares
• Operador new
• Crea una instancia o ejemplar de la clase indicada y devuelve
una referencia a dicho objeto
• Se reserva espacio de memoria para los datos del objeto
– Un ejemplar es una copia individual de la plantilla de la clase que tiene
su propio conjunto de datos
int num = 5; num 5
// crea una referencia
Rectangulo rect; rect
// reserva la memoria x
rect = new Rectangulo(); y
otroRect
Rectangulo otroRect;
otroRect = rect; ancho
// otroRect se refiere al mismo
alto
// rectangulo que rect
Java Clases y objetos BFM 7
 Acceso a los atributos de un objeto
• Desde un objeto se puede acceder a los atributos o
miembros con la siguiente sintaxis
referenciaObjeto.atributo;

public class Rectangulo {

int x;
int y;
int ancho;
int alto;
//faltan las funciones miembro
public static void main(String args[ ]) {
Rectangulo rect;
rect = new Rectangulo();
rect.x = 5;
rect.y = 7;
rect.ancho = 4;
rect.alto = 3;
System.out.println( "x = " + rect.x + ” y = " + rect.y );
System.out.println( "ancho = " + rect.ancho + ” alto = " + rect.alto ); } }
Java Clases y objetos BFM 8
 Declaración de métodos
• Funciones declaradas en la clase y que determinan su
comportamiento
• Sintaxis tipoDevuelto nombreMetodo (listaParametros) {
//instrucciones del método
}

// calcula la superficie y la devuelve como un número entero

int calcularSuperficie(){
int area;
area = ancho * alto;
return area;
}
// muestra los valores por pantalla pero no devuelve nada
void mostrarValores(){
System.out.println( "x = " + x + " y = " + y );
System.out.println( "ancho = " + ancho + " alto = " + alto );
}
Java Clases y objetos BFM 9
 Llamada a los métodos
• La invocación a los métodos desde una instancia se hace
mediante el operador de acceso ( . )
referenciaObjeto.nombreMetodo(listaArgumentos);
– Los argumentos de tipos simples se pasan por valor
– Los objetos se pasan por referencia
public class Rectangulo {
int x; ………..
int calcularSuperficie(){ .……... }
void mostrarValores(){………….}
public static void main(String args[ ]) {
Rectangulo rect;
rect = new Rectangulo();
rect.x = 5; rect.y = 7; rect.ancho = 4; rect.alto = 3;
int area = rect.calcularSuperficie();
rect.mostrarValores();
System.out.println( "Superficie: " + area );
System.out.println( "x = " + rect.x + ” y = " + rect.y );
System.out.println( "ancho = " + rect.ancho + ” alto = " + rect.alto ); }
}
Java Clases y objetos BFM 10
 Nueva funcionalidad
public class Rectangulo {
int x; ………..
int calcularSuperficie(){ .……... }
void mostrarValores(){………….}
void cambiarValores(int posx, int posy, int lar, int anc) {
x= posx;
y= posy;
alto = lar;
ancho = anc;
}
public static void main(String args[ ]) {
Rectangulo rect;
rect = new Rectangulo();
rect.x = 5; rect.y = 7; rect.ancho = 4; rect.alto = 3;
int area = rect.calcularSuperficie();
rect.mostrarValores();
System.out.println( "Superficie: " + area );
rect.cambiarValores(3,5,8,9);
rect.mostrarValores();
}

Java Clases y objetos BFM 11

 Constructores
• Método que inicializa el objeto en su creación
• Se llama automáticamente cuando se crea un objeto
• Su nombre es igual que el de la clase y no tiene tipo de retorno
• Java proporciona un constructor sin parámetros por defecto
que deja de estar disponible cuando se añade algún constructor
public class Rectangulo{ public static void main(String args[ ]) {
int x; Rectangulo rect;
….….….. rect = new Rectangulo(5, 7, 4, 3);
// constructor
public Rectangulo(int x1, int y1, int w, int h){ int area = rect.calcularSuperficie();
x=x1; rect.mostrarValores();
y=y1; System.out.println( "Superficie: " + area );
ancho=w; ………….
alto=h; } }
….…..….. }

Java Clases y objetos BFM 12

 Constructores
• Pueden sobrecargarse
• Una clase puede tener más de un constructor (polimorfismo)
– Si no se declara ninguno se hereda el de la superclase (o el de Object)
• Se puede crear un objeto con distintos tipos de parámetros
• Pueden llamar al constructor del padre
• super(argumentos);
– Debe ser la primera instrucción del constructor
• o a otros constructores de la misma clase
• this(argumentosPorDefecto); // constructor polimorfico
// sin parámetros
public Rectangulo() {
x=0; y=0;
alto=0; ancho=0;}

Java Clases y objetos BFM 13

 Referencia a objeto this
• Referencia especial que utilizada dentro de un método de
cualquier clase se refiere a la instancia actual
– Permite parámetros con igual nombre que atributos
– Posibilita la llamada a otros constructores

class Rectangulo{ public static void main(String args[ ]) {

int x; Rectangulo rect;
….….….. rect = new Rectangulo(5, 7, 4, 3);
// constructor rect.mostrarValores();
Rectangulo(int x1, int y1, int w, int h){
x=x1; y=y1; ancho=w; alto=h; } Rectangulo nuevo;
// otro constructor polimorfico nuevo = new Rectangulo(6, 9);
Rectangulo(int ancho, int alto){ rect.mostrarValores();
x=0; y=0; ………….
this.ancho= ancho; }
this.alto= alto; } }
….…..…..

Java Clases y objetos BFM 14

 Miembros estáticos
• Sólo hay un miembro por clase
– Se declaran con la palabra clave static
– Variables, constantes y métodos únicos y comunes a toda la clase
• Atributos de clase
• Hay exactamente una copia (aunque no exista ningún objeto)
• Se inicializan antes de usarse:
– Se usan como variables finales para definir constantes de clase
public static final int MAXIMO = 12;

public class Rectangulo{

int x; ……….. public static void main(String args[ ]) {
static int numRect=0; Rectangulo rect;
// constructor rect = new Rectangulo(5, 7, 4, 3);
public Rectangulo(int x1, int y1, rect.mostrarValores();
int w, int h){
numRect++; System.out.println(“Num: “ + Rectangulo.numRect);
x=x1; y=y1; ancho=w; alto=h; } }
Java Clases y objetos BFM 15
 Métodos de clase o estáticos
• Se invocan en nombre de la clase
• Sólo pueden acceder a variables de clase
• Para realizar funciones de utilidad (que sólo actúan sobre sus
parámetros o que no necesitan parámetros):
double numero = Math.sqrt(234.0);
public static void main() {/*codigo programa prin. Que debe
crearse antes de que exista ningún objeto*/};
– Declaración de método de clase en Rectángulo:
public static int obtNumRect() { return this.numRect;}
Llamada desde main:
int num= Rectangulo.obtNumRect();

• Bloques de inicialización estática

– Para inicializar campos estáticos u otros estados necesarios cuando es
necesario realizar algún tipo de cálculo
static {
for (int i = 0; i < primos.length; i++)
primos[i] = i; }
Java Clases y objetos BFM 16
 Reutilización de código
• Composición
• Utilizar objetos como miembros de otros objetos
• Herencia
• Especialización o extensión de una clase para crear otra nueva

Java Clases y objetos BFM 17

 Composición: clase Punto

public class Punto {

int x;
int y;
public Punto(int x, int y) {
this.x = x;
this.y = y;
}
public Punto() {
// llamada al otro constructor
this(-1, -1);
}
public void mostrar(){
System.out.println(“x = “ + x +” y = “ + y);
}
}

Java Clases y objetos BFM 18

 Composición: prueba de la clase Punto
public class Punto {
int x;
int y;
public Punto(int x, int y) {
this.x = x;
this.y = y;
}
public Punto() {
// llamada al otro constructor
this(-1, -1); }
public void mostrar(){
System.out.println(“x = “ + x +” y = “ + y); }
public static void main(String args[]) {
Punto pun1 = new Punto();
Punto pun2 = new Punto(2,3);
System.out.println( "visualizar datos del punto" );
pun1.mostrar();
pun2.mostrar();}}
Java Clases y objetos BFM 19
 Composición: clase Círculo
public class Circulo {
Punto origen;
int radio;

public Circulo(int x, int y, int radio) {

origen = new Punto(x,y);
this.radio = radio;
}

public void mostrar() {

origen.mostrar();
System.out.println("radio = " + radio);
}

public static void main(String args[]) {

Circulo cir = new Circulo(5, 5, 9);
System.out.println( "visualizar datos del circulo" );
cir.mostrar(); }}

Java Clases y objetos BFM 20

 La clase genérica Object
• Todas las clases en Java heredan implícitamente de la
clase Object. De esta forma, Object es la raiz de la
jerarquía de herencia (de implementación) en Java.
• Object define un conjunto de métodos útiles, que pueden
ser redefinidos en cada clase. En particular:
• public boolean equals(Object o): Permite definir el criterio de
igualdad utilizado para los objetos 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.

Java Clases y objetos BFM 21

 Herencia: clase Persona
public class Persona {
String nombre = "";
int edad; Persona
public Persona(String nom, int ed) {
nombre = nom;
edad = ed; Trabajador
}

public void mostrar() {

System.out.println("Nombre: "+ nombre);
System.out.println("Edad: "+ edad);
}
public static void main(String args[]) {
Persona yo= new Persona("Balta", 99);
yo.mostrar();
}
}

Java Clases y objetos BFM 22

 Herencia: clase Trabajador
public class Trabajador extends Persona {
float sueldoHora;
int numHoras;

public Trabajador(String nom, int ed, float suel, int num) {

super(nom, ed); // llamada al constructor de Persona
sueldoHora = suel;
numHoras = num;}

public double sueldo() {

return sueldoHora * numHoras; }

public static void main(String args[]) {

Trabajador yo= new Trabajador("Balta", 99, 200.5f, 45);
yo.mostrar(); // se invoca al metodo heredado mostrar
double pelas = yo.sueldo();
System.out.println("Cobra: " + pelas); }
}

Java Clases y objetos BFM 23

 Sobrecarga o reescritura de un método y polimorfismo
• La signatura de un método viene dada por su nombre y el tipo
y número de los parámetros
– El tipo devuelto no forma parte de la signatura
• Cuando se reescribe un método en una clase derivada
– La signatura debe ser la misma que el método de la clase base
– El tipo devuelto debe ser el mismo que el del método de la clase base
– El atributo de acceso del método de la clase derivada tiene que ser igual
o mas general que el de la clase base (NO puede ser mas restrictivo)

Java Clases y objetos BFM 24

 Ejemplo

//En Persona redefinimos el método mostrar()

public class Trabajador extends Persona {
float sueldoHora;
int numHoras;
public Trabajador(String nom, int ed, float suel, int num) {
super(nom, ed); // llamada al constructor de Persona
sueldoHora = suel;
numHoras = num;}
// sobrecarga completa de mostrar
// nombre y edad son atributos heredados de Persona
public void mostrar() {
System.out.println("Nombre: "+ nombre);
System.out.println("Edad: "+ edad);
System.out.println("Sueldo por hora: "+ sueldoHora);
System.out.println("Horas trabajadas: "+ numHoras);}}

Java Clases y objetos BFM 25

 Sobrecarga de método
• Sobrecarga parcial ampliando el método heredado
– El método de la subclase puede llamar al método de la superclase

public class Trabajador extends Persona {

float sueldoHora;
int numHoras;

public Trabajador(String nom, int ed, float suel, int num) {

super(nom, ed); // llamada al constructor de Persona
sueldoHora = suel;
numHoras = num;}
// sobrecarga parcial de mostrar
// nombre y edad son atributos heredados de Persona
public void mostrar() {
super.mostrar(); // llamada al método de la clase padre
System.out.println("Sueldo por hora: "+ sueldoHora);
System.out.println("Horas trabajadas: "+ numHoras);}
}
Java Clases y objetos BFM 26
 Vinculación dinámica
• El método a ejecutarse se determina en ejecución en función
del objeto concreto (no del tipo de la referencia)
– Una referencia a la superclase puede referir a un objeto de la subclase
– Los objetos Trabajador son también objetos Persona
public static void main(String args[]) {
Persona per;
Trabajador yo= new Trabajador("Balta", 99, 200.5f, 45);
Persona
per = yo; // Asignacion legal
// se ejecuta el método mostrar de Trabajador y no el de Persona
per.mostrar(); // per se trata como cualquier Trabajador
Trabajador pelas = per.sueldo(); // Ilegal (sueldo se define en Trabajador)

boolean b1, b2;

b1 = (per instanceof Persona); // True
b2 = (per instanceof Trabajador); // True
System.out.println("b1: "+ b1 + " b2: "+ b2);
}
Java Clases y objetos BFM 27
 Clases abstractas
• Clases cuya descripción es incompleta
• Se definen utilizando la palabra reservada abstract
• No proporcionan la implementación de todos sus métodos
– Los métodos no implementados se declaran como abstract
• Una clase con un método abstracto debe declararse como clase
abstracta
– Pero una clase puede declararse como abstracta aunque no tenga ningún
método abstracto
• Las subclases de una clase abstracta deben:
– Sobreescribir todos los métodos abstractos de la superclase, o bien
– Ser declaradas como clases abstractas
• Una clase abstracta no puede instanciarse
– No se pueden crear objetos de una clase abstracta

Java Clases y objetos BFM 28

 Ejemplo clase abstracta
public abstract class Figura {
Figura int x, y;
public void mostrarOrigen() {
System.out.println("x= "+x+" y= "+y);}
Triangulo public abstract double area(); // No tiene implementación
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”);}}

Java Clases y objetos BFM 29

 Prueba clase abstracta
public class PruebaClaseAbstracta {
public static void main(String args[]) {
Figura fig;
Triangulo tri;
Cuadrado cua;

fig = new Figura(); // error no se puede instanciar una clase abstracta

tri = new Triangulo(4,3);
tri.mostrarOrigen();
tri.mostrarNombre();

fig = tri;
fig.mostrarNombre();
System.out.println("Area triangulo: "+fig.area());

cua = new Cuadrado(5);

fig = cua;
System.out.println("Area cuadrado: "+fig.area());
}
}

Java Clases y objetos BFM 30

 Métodos finalizadores
• Java tiene recolector de basura
• Un objeto se elimina cuando se deja de hacer referencia a él
• No hay que eliminar los objetos explícitamente
• Al destruir un objeto se invoca el método finalize
• Para hacer limpieza de recursos no Java (recursos externos)
• Por ejemplo: cerrar conexiones, cerrar ficheros, registrar algún
tipo de resultado, etc.
• Al acabar un programa, se ejecuta finalize para todos los
objetos
protected void finalize() throws Throwable {
super.finalize(); // conviene ponerlo siempre
if ( archivo != null ) // si el archivo no se ha cerrado
{ archivo.close(); archivo = null; }
}

Java Clases y objetos BFM 31

 Recolección automática de memoria
Rectangulo rect = new Rectangulo();
Rectangulo otroRect =new Rectangulo();
// se pierde la referencia al primer rectángulo
otroRect = rect;
// este primer rectángulo pasa a ser candidato a recolección automática

Memoria que será recuperada

x x
por el recolector automático
y y

ancho ancho
alto alto
rect rect
x x
y y
otroRect otroRect
ancho ancho
alto alto
Java Clases y objetos BFM 32
 Interfaces
• Sólo declaran comportamiento
• Se utiliza la palabra clave interface
• Por defecto todos sus métodos son públicos y abstractos
– No implementan el comportamiento
• Por defecto todos sus atributos son públicos, constantes y de clase
– Por legibilidad normalmente los declaramos static y final
• Permite simular algunos aspectos de la herencia múltiple
• Define un tipo de datos
• Posibilita la vinculación dinámica
• Otras clases pueden implementar un interfaz
• Cualquier clase que implemente un interfaz debe definir todos los métodos
de dicho interfaz
– Debe proporcionar la implementación de dichos métodos
• Si la clase no proporciona la implementación para todos los métodos del
interfaz debe ser declarada como abstracta

Java Clases y objetos BFM 33

 Declaración de interfaces
• Sintaxis interface NombreInterfaz {
tipo static final NOMBRECONSTANTE1 = valor;
…….….….
public tipoDevuelto nombreMetodo1(listaParámetros);
…….….….
}

• Implementación del interfaz en una clase

• Una clase puede implementar varios interfaces

class NombreClase implements NombreInterfaz1 [, NombreInterfaz2 ..] {

// declaración atributos y métodos de la clase
…….….….
}

Java Clases y objetos BFM 34

 Ejemplo de interfaz

interface Nombrable {
static final boolean CIERTO = true;
public void mostrarNombre();
}

public class Elemento implements Nombrable {

String nombre;
public Elemento(String nom) {
nombre = nom; }
// obligatorio implementar método mostrarNombre porque se implementa
// la interfaz Nombrable
public void mostrarNombre(){
System.out.println("Nombre: "+nombre);
if (CIERTO)
System.out.println("Constante CIERTO del interfaz");
}
}

Java Clases y objetos BFM 35

 Uso del interfaz en vinculación dinámica

public class PruebaInterfaz {

public static void main(String args[]) {

Elemento elem;
Nombrable inter;

elem = new Elemento("Balta");

elem.mostrarNombre();

// una referencia a interfaz puede utilizarse con una instancia de

// una clase que lo implemente
inter = elem;
inter.mostrarNombre();
}
}

Java Clases y objetos BFM 36

 Paquetes
• Los paquetes permiten agrupar una colección de clases e
interfaces funcionalmente relacionadas asignándole un
nombre
• Todo nombre en Java está dentro de un paquete
• package nombrePaquete; // fichero como parte de un paquete
• El paquete default contiene todas las clases no definidas
explícitamente en un paquete
• Definen contextos de denominación
• Para evitar colisión de nombres
• Sirven para definir bibliotecas de clases e interfaces
• Reutilización: no volver a inventar la rueda
• Permiten organizar el código de una gran aplicación
• Un paquete determina un subdirectorio del disco

Java Clases y objetos BFM 37

 Paquetes
• Los paquetes pueden anidarse
• Define una jerarquía:
paquete.subpaquete.subpaquete.clase
Ejemplo: java.lang.System.out
• Convención para el nombrado de paquetes
(para conseguir nombres únicos):
• dominio.empresa.departamento.proyecto

Autor del paquete

(nombre de dominio Internet al revés)

Ejemplo: es.ucm.sip.cursoJava

Java Clases y objetos BFM 38

 Uso de paquetes
• Utilización de nombres de un paquete:
• Usando un nombre completo:
class ImprimeFecha1 {
public static void main () {
java.util.Date ahora = new java.util.Date();
System.out.println(ahora);
}
}
• Usando la cláusula import:

import java.util.Date;
class ImprimeFecha2 {
public static void main () {
Date ahora = new Date();
System.out.println(ahora);
}
}
Java Clases y objetos BFM 39
 Importación de clases
• No es necesario para el paquete java.lang
– Por defecto: import java.lang.*
• * permite referirse a todas las clases e interfaces de un paquete
import java.*; // ERROR: no vale para paquetes

• Ejemplo: Para importar la clase Applet:

– import java.applet.Applet; // directamente la clase
– import java.applet.*; // todos los nombres del paquete

El compilador busca en classes/java/applet/*

En los entornos de programación existen funcionalidades que

simplifican la gestión del proyecto. Normalmente se busca dentro de
los ficheros de clases del proyecto

Java Clases y objetos BFM 40

 Control de acceso a miembros de una clase
• Hay cuatro niveles de protección en función de los atributos
de acceso y de la organización en paquetes
• Publico, paquete, protegido y privado
• Atributos de acceso
• Si no se indica nada un miembro es accesible desde todo el
paquete
• private
– acceso sólo dentro de la clase
• public
– acceso desde cualquier lugar
• protected
– acceso en la clase, las subclases (en cualquier paquete) y desde las clases
del mismo paquete

Java Clases y objetos BFM 41

 Ejemplo control de acceso
• El control de acceso se aplica tanto a atributos como a
métodos

// redefinición de la clase rectángulo con control de acceso

public class Rectangulo {
private int x; // accesible sólo dentro de la clase
int y; // accesible dentro del paquete (opción por defecto)
public int ancho; // accesible desde todos los sitios
protected int alto; // accesible desde el paquete y desde las subclases

private int calcularSuperficie() // accesible sólo dentro de la clase

{ .……... }
……….…….….

Java Clases y objetos BFM 42