Clasesyobjetos

Java Clases y objetos BFM 1
Java: Clases y Objetos

www.fdi.ucm.es/profesor/balta
Clases
La unidad fundamental de programacin 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 ejecucin crea y manipula (mediante
llamadas a mtodos) objetos concretos (ejemplares o
instancias)
Cada objeto es un ejemplar de una clase
Cuando se invoca un mtodo de un objeto, se mira en el
cdigo de su clase las acciones a ejecutar
Un objeto puede usar otros para realizar su trabajo
Clases
Una definicin de clase comprende:
Cabecera
Campos o atributos:
Variables
Constantes
Mtodos:
Funciones
Constructores
Bloques de inicializacin static
Finalizador
estado del objeto
comportamiento
Definicin de una clase
[Modificadores] class NombreClase [extends SuperClase] {
// definicin de los atributos de la clase
tipo1 identificador1;
tipo2 identificador2;
..
// definicin de los mtodos de la clase
tipoDevuelto nombreMetodo1 (listaParametros) {
//instrucciones del mtodo1
}
tipoDevuelto nombreMetodo2 (listaParametros) {
//instrucciones del mtodo2
}
..
}
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
Slo herencia simple (una sla superclase)
Si no aparece extends la clase definida hereda (es una subclase) de un
objeto general del sistema llamada Object
public class Rectangulo{
int x;
int y;
int ancho;
int alto;
// faltan los mtodos de Rectngulo
}
Object
Rectangulo
int num = 5;
Rectangulo rect;
num 5
rect null
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 mtodos 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
x
y
ancho
alto
Creacin 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;
// crea una referencia
Rectangulo rect;
// reserva la memoria
rect = new Rectangulo();
Rectangulo otroRect;
otroRect = rect;
// otroRect se refiere al mismo
// rectangulo que rect
num 5
rect
otroRect
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.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 ); } }
Declaracin de mtodos
Funciones declaradas en la clase y que determinan su
comportamiento
Sintaxis
tipoDevuelto nombreMetodo (listaParametros) {
//instrucciones del mtodo
}
// calcula la superficie y la devuelve como un nmero 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 );
}
Llamada a los mtodos
La invocacin a los mtodos desde una instancia se hace
mediante el operador de acceso ( . )
Los argumentos de tipos simples se pasan por valor
Los objetos se pasan por referencia
int x; ..
int calcularSuperficie(){ .... }
void mostrarValores(){.}
Rectangulo rect;
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 ); }
}
referenciaObjeto.nombreMetodo(listaArgumentos);
Nueva funcionalidad
int x; ..
int calcularSuperficie(){ .... }
void mostrarValores(){.}
void cambiarValores(int posx, int posy, int lar, int anc) {
x= posx;
y= posy;
alto = lar;
ancho = anc;
}
Rectangulo rect;
rect.x = 5; rect.y = 7; rect.ancho = 4; rect.alto = 3;
rect.cambiarValores(3,5,8,9);
}
Constructores
Mtodo que inicializa el objeto en su creacin
Se llama automticamente 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 parmetros por defecto
que deja de estar disponible cuando se aade algn constructor
int x;
....
// constructor
public Rectangulo(int x1, int y1, int w, int h){
x=x1;
y=y1;
ancho=w;
alto=h; }
.....
Rectangulo rect;
rect = new Rectangulo(5, 7, 4, 3);
.
}
}
Constructores
Pueden sobrecargarse
Una clase puede tener ms 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 parmetros
Pueden llamar al constructor del padre
super(argumentos);
Debe ser la primera instruccin del constructor
o a otros constructores de la misma clase
this(argumentosPorDefecto);
// constructor polimorfico
// sin parmetros
public Rectangulo() {
x=0; y=0;
alto=0; ancho=0;}
Referencia a objeto this
Referencia especial que utilizada dentro de un mtodo de
cualquier clase se refiere a la instancia actual
Permite parmetros con igual nombre que atributos
Posibilita la llamada a otros constructores
class Rectangulo{
int x;
....
// constructor
Rectangulo(int x1, int y1, int w, int h){
x=x1; y=y1; ancho=w; alto=h; }
// otro constructor polimorfico
Rectangulo(int ancho, int alto){
x=0; y=0;
this.ancho= ancho;
this.alto= alto; }
.....
Rectangulo rect;
Rectangulo nuevo;
nuevo = new Rectangulo(6, 9);
.
}
}
Miembros estticos
Slo hay un miembro por clase
Se declaran con la palabra clave static
Variables, constantes y mtodos nicos y comunes a toda la clase
Atributos de clase
Hay exactamente una copia (aunque no exista ningn objeto)
Se inicializan antes de usarse:
Se usan como variables finales para definir constantes de clase
public static final int MAXIMO = 12;
int x; ..
static int numRect=0;
// constructor
public Rectangulo(int x1, int y1,
int w, int h){
numRect++;
x=x1; y=y1; ancho=w; alto=h; }
Rectangulo rect;
System.out.println(Num: + Rectangulo.numRect);
}
Mtodos de clase o estticos
Se invocan en nombre de la clase
Slo pueden acceder a variables de clase
Para realizar funciones de utilidad (que slo actan sobre sus
parmetros o que no necesitan parmetros):
double numero = Math.sqrt(234.0);
public static void main() {/*codigo programa prin. Que debe
crearse antes de que exista ningn objeto*/};
Declaracin de mtodo de clase en Rectngulo:
public static int obtNumRect() { return this.numRect;}
Llamada desde main:
int num= Rectangulo.obtNumRect();
Bloques de inicializacin esttica
Para inicializar campos estticos u otros estados necesarios cuando es
necesario realizar algn tipo de clculo
static {
for (int i = 0; i < primos.length; i++)
primos[i] = i; }
Reutilizacin de cdigo
Composicin
Utilizar objetos como miembros de otros objetos
Herencia
Especializacin o extensin de una clase para crear otra nueva
Composicin: 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);
}
}
Composicin: 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();}}
Composicin: clase Crculo
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);
}
Circulo cir = new Circulo(5, 5, 9);
System.out.println( "visualizar datos del circulo" );
cir.mostrar(); }}
La clase genrica Object
Todas las clases en Java heredan implcitamente de la
clase Object. De esta forma, Object es la raiz de la
jerarqua de herencia (de implementacin) en Java.
Object define un conjunto de mtodos 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 representacin
externa de un objeto. Por defecto es el valor de su referencia,
etiquetada con el nombre de la clase.
Herencia: clase Persona
public class Persona {
String nombre = "";
int edad;
public Persona(String nom, int ed) {
nombre = nom;
edad = ed;
}
System.out.println("Nombre: "+ nombre);
System.out.println("Edad: "+ edad);
}
Persona yo= new Persona("Balta", 99);
yo.mostrar();
}
}
Persona
Trabajador
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; }
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); }
}
Sobrecarga o reescritura de un mtodo y polimorfismo
La signatura de un mtodo viene dada por su nombre y el tipo
y nmero de los parmetros
El tipo devuelto no forma parte de la signatura
Cuando se reescribe un mtodo en una clase derivada
La signatura debe ser la misma que el mtodo de la clase base
El tipo devuelto debe ser el mismo que el del mtodo de la clase base
El atributo de acceso del mtodo de la clase derivada tiene que ser igual
o mas general que el de la clase base (NO puede ser mas restrictivo)
Ejemplo
//En Persona redefinimos el mtodo mostrar()
float sueldoHora;
int numHoras;
sueldoHora = suel;
numHoras = num;}
// sobrecarga completa de mostrar
// nombre y edad son atributos heredados de Persona
System.out.println("Nombre: "+ nombre);
System.out.println("Edad: "+ edad);
System.out.println("Sueldo por hora: "+ sueldoHora);
System.out.println("Horas trabajadas: "+ numHoras);}}
Sobrecarga de mtodo
Sobrecarga parcial ampliando el mtodo heredado
El mtodo de la subclase puede llamar al mtodo de la superclase
float sueldoHora;
int numHoras;
sueldoHora = suel;
numHoras = num;}
// sobrecarga parcial de mostrar
// nombre y edad son atributos heredados de Persona
super.mostrar(); // llamada al mtodo de la clase padre
System.out.println("Sueldo por hora: "+ sueldoHora);
System.out.println("Horas trabajadas: "+ numHoras);}
}
Vinculacin dinmica
El mtodo a ejecutarse se determina en ejecucin en funcin
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 tambin objetos Persona
Persona per;
Trabajador yo= new Trabajador("Balta", 99, 200.5f, 45);
per = yo; // Asignacion legal
// se ejecuta el mtodo mostrar de Trabajador y no el de Persona
per.mostrar(); // per se trata como cualquier 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);
}
Persona
Trabajador
Clases abstractas
Clases cuya descripcin es incompleta
Se definen utilizando la palabra reservada abstract
No proporcionan la implementacin de todos sus mtodos
Los mtodos no implementados se declaran como abstract
Una clase con un mtodo abstracto debe declararse como clase
abstracta
Pero una clase puede declararse como abstracta aunque no tenga ningn
mtodo abstracto
Las subclases de una clase abstracta deben:
Sobreescribir todos los mtodos 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
Ejemplo clase abstracta
public abstract class Figura {
int x, y;
public void mostrarOrigen() {
System.out.println("x= "+x+" y= "+y);}
public abstract double area(); // No tiene implementacin
public abstract double mostrarNombre();
}
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);}}
Figura
Triangulo
Cuadrado
Prueba clase abstracta
public class PruebaClaseAbstracta {
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());
}
}
protected void finalize() throws Throwable {
super.finalize(); // conviene ponerlo siempre
if ( archivo != null ) // si el archivo no se ha cerrado
{ archivo.close(); archivo = null; }
}
Mtodos finalizadores
Java tiene recolector de basura
Un objeto se elimina cuando se deja de hacer referencia a l
No hay que eliminar los objetos explcitamente
Al destruir un objeto se invoca el mtodo finalize
Para hacer limpieza de recursos no Java (recursos externos)
Por ejemplo: cerrar conexiones, cerrar ficheros, registrar algn
tipo de resultado, etc.
Al acabar un programa, se ejecuta finalize para todos los
objetos
Recoleccin automtica de memoria
rect
otroRect
Rectangulo rect = new Rectangulo();
Rectangulo otroRect =new Rectangulo();
// se pierde la referencia al primer rectngulo
otroRect = rect;
// este primer rectngulo pasa a ser candidato a recoleccin automtica
alto
x
y
ancho
alto
x
y
ancho
rect
otroRect
alto
x
y
ancho
alto
x
y
ancho
Memoria que ser recuperada
por el recolector automtico
Interfaces
Slo declaran comportamiento
Se utiliza la palabra clave interface
Por defecto todos sus mtodos son pblicos y abstractos
No implementan el comportamiento
Por defecto todos sus atributos son pblicos, constantes y de clase
Por legibilidad normalmente los declaramos static y final
Permite simular algunos aspectos de la herencia mltiple
Define un tipo de datos
Posibilita la vinculacin dinmica
Otras clases pueden implementar un interfaz
Cualquier clase que implemente un interfaz debe definir todos los mtodos
de dicho interfaz
Debe proporcionar la implementacin de dichos mtodos
Si la clase no proporciona la implementacin para todos los mtodos del
interfaz debe ser declarada como abstracta
Declaracin de interfaces
Sintaxis
Implementacin del interfaz en una clase
Una clase puede implementar varios interfaces
interface NombreInterfaz {
tipo static final NOMBRECONSTANTE1 = valor;
...
public tipoDevuelto nombreMetodo1(listaParmetros);
...
}
class NombreClase implements NombreInterfaz1 [, NombreInterfaz2 ..] {
// declaracin atributos y mtodos de la clase
...
}
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 mtodo mostrarNombre porque se implementa
// la interfaz Nombrable
public void mostrarNombre(){
System.out.println("Nombre: "+nombre);
if (CIERTO)
System.out.println("Constante CIERTO del interfaz");
}
}
Uso del interfaz en vinculacin dinmica
public class PruebaInterfaz {
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();
}
}
Paquetes
Los paquetes permiten agrupar una coleccin de clases e
interfaces funcionalmente relacionadas asignndole 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
explcitamente en un paquete
Definen contextos de denominacin
Para evitar colisin de nombres
Sirven para definir bibliotecas de clases e interfaces
Reutilizacin: no volver a inventar la rueda
Permiten organizar el cdigo de una gran aplicacin
Un paquete determina un subdirectorio del disco
Ejemplo: java.lang.System.out
Paquetes
Los paquetes pueden anidarse
Define una jerarqua:
paquete.subpaquete.subpaquete.clase
Convencin para el nombrado de paquetes
(para conseguir nombres nicos):
dominio.empresa.departamento.proyecto
Autor del paquete
(nombre de dominio Internet al revs)
Ejemplo: es.ucm.sip.cursoJava
Uso de paquetes
Utilizacin de nombres de un paquete:
Usando un nombre completo:
Usando la clusula import:
class ImprimeFecha1 {
public static void main () {
java.util.Date ahora = new java.util.Date();
System.out.println(ahora);
}
}
import java.util.Date;
class ImprimeFecha2 {
public static void main () {
Date ahora = new Date();
System.out.println(ahora);
}
}
Importacin 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 programacin existen funcionalidades que
simplifican la gestin del proyecto. Normalmente se busca dentro de
los ficheros de clases del proyecto
Control de acceso a miembros de una clase
Hay cuatro niveles de proteccin en funcin de los atributos
de acceso y de la organizacin 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 slo 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
// redefinicin de la clase rectngulo con control de acceso
private int x; // accesible slo dentro de la clase
int y; // accesible dentro del paquete (opcin 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 slo dentro de la clase
{ .... }
...
}
Ejemplo control de acceso
El control de acceso se aplica tanto a atributos como a
mtodos

Clasesyobjetos

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Clasesyobjetos

Cargado por

Copyright:

Formatos disponibles

Java Clases y objetos BFM 1

Java: Clases y Objetos

También podría gustarte