MétodosObjetoClase

Tema 5. Métodos
Introducción a la Informática y a la Programación (IIP)
Curso 2011/12
Departamento de Sistemas Informáticos y Computación

Contenidos
1. Métodos de objeto y métodos de clase
2. Características de los métodos de objeto o
dinámicos
3. Características de los métodos de clase o
estáticos
4. La pila de llamadas
5. Sobrescritura de los métodos de Object
6. Documentación de los métodos
20/10/2011 IIP - Curso 2011/12 2

Estructura básica de una clase:
atributos y métodos
public class Circulo {
private double radio;
private String color;
private int centroX;
private int centroY;
public Circulo() {
radio = 50;color = "negro";
centroX = 100; centroY = 100;
}
public double area(){
return 3.14 * radio * radio;
}
...
}
20/10/2011 IIP - Curso 2011/12 3
Atributos: Estructura de
los objetos de la clase
Métodos: Operaciones
que se pueden hacer
cuando los objetos de la
clase

Ejemplo de clase-programa
public class ProgramaTri {
public static void main(String[] args) {
Punto p1 = new Punto(); p1.x = 2.5; p1.y = 3;
Punto p2 = new Punto(); p2.x = 2.5; p2.y = -1.2;
Punto p3 = new Punto(); p3.x = -1.5; p1.y = 1.4;
System.out.println("Triángulo de vértices: ");
System.out.println("(" + p1.x + "," + p1.y + ")");
double dx = p1.x - p2.x;
double dy = p1.y - p2.y;
double lado12 = Math.sqrt(dx*dx + dy*dy);
dx = p2.x - p3.x;
dy = p2.y - p3.y;
dx = p1.x - p3.x;
dy = p1.y - p3.y;
double perimetro = lado12 + lado23 + lado13;
System.out.println("Perímetro: " + perimetro);
}
}
20/10/2011 IIP - Curso 2011/12 4
Instrucciones repetidas
con distintos datos:
p1 y p2
p2 y p3
p1 y p3

Subprograma
public class ProgramaTri {
Punto p1 = new Punto(); p1.x = 2.5; p1.y = 3;
Punto p2 = new Punto(); p2.x = 2.5; p2.y = -1.2;
Punto p3 = new Punto(); p3.x = -1.5; p1.y = 1.4;
System.out.println("Triángulo de vértices: ");
double lado12 = distancia(p1,p2);
double lado23 = distancia(p2,p3);
double lado13 = distancia(p1,p3),
double perimetro = lado12 + lado23 + lado13;
System.out.print("Perímetro: " + perimetro);
}
/** Calcula la distancia entre dos puntos. */
static double distancia(Punto p, Punto q) {
double dx = p.x - q.x; double dy = p.y - q.y;
return Math.sqrt(dx*dx + dy*dy);
}
}
20/10/2011 IIP - Curso 2011/12 5
+ LEGIBILIDAD
+ SEGURIDAD

Métodos de objeto (dinámicos) y de clase
(estáticos)
• Los métodos de objeto o dinámicos se definen en una clase para
crear (constructores) y manipular la información de los objetos
de la clase (de instancia).
– Punto p = new Punto(); p1.x =2.5; p1.y = 3;
– double d = p.distOrigen();
Se denomina objeto en curso al objeto concreto que se crea o manipula.
• Los métodos de clase no se aplican sobre objetos, actúan
únicamente sobre sus parámetros y se pueden definir en
cualquier clase. Se deben declarar como static.
– Math.sqrt(x) es una llamada al método estático sqrt de la clase
Math
– distancia es un método de la clase ProgramaTri
20/10/2011 IIP - Curso 2011/12 6

Características de los métodos de instancia
• Definición:
[modificadores] TipoRetorno nombreMetodo ([ListaParametros]){
// instrucciones del cuerpo del método
}
20/10/2011 IIP - Curso 2011/12 7
public double distancia(Punto p)
{ double x = p.x – this.x;
double y = p.y – this.y;
return Math.sqrt(x*x + y*y);
}
parámetronombrevisibilidad tipo
cabecera
cuerpo
valor de retorno
objeto en curso

Métodos de instancia: modificadores de
visibilidad o acceso
20/10/2011 IIP - Curso 2011/12 8
Al igual que para los atributos, existen las siguientes modalidades de
acceso a los métodos de una clase:
1. private: accesible sólo dentro de la clase.
2. public: accesible en cualquier parte donde la clase sea
accesible (incluso desde fuera del paquete).
3. Sin modificador de acceso (friendly): público pero accesible
sólo dentro del paquete.
class subclass package world
private sí no no no
public sí sí sí sí
sin especificar sí no sí no

¿public o private?
20/10/2011 IIP - Curso 2011/12 9
public class Punto {
private double x; // atributo que representa la abscisa
private double y; // atributo que representa la ordenada
/** Método que permite mover un punto en el plano, cambiando
* sus coordenadas a partir de dos valores dados. */
public void mover(double px, double py) { x += px; y += py; }
/** Método privado que devuelve un valor entero aleatorio en
* el rango [0,2*Math.sqrt(x*x+y*y)]. */
private int aleatorio() {return
(int)(Math.random()*(2*distOrigen()+1)); }
/** Método que permite mover un punto en el plano, cambiando
* sus coordenadas a partir de dos valores aleatorios. */
public void moverAleat() { x += aleatorio(); y += aleatorio(); }
/** Método que calcula la distancia de un punto al origen (0,0) */
public double distOrigen() { return Math.sqrt(x*x + y*y); }
/** Método que calcula la distancia de un punto a otro punto dado */
public double distancia(Punto p) {
double x = p.x - this.x; double y = p.y - this.y;
}
}

¿public o private?
20/10/2011 IIP - Curso 2011/12 10
moverAleat
distOrigen
x y
aleatorio
PRIVADO
PÚBLICO
distancia
mover

Métodos de instancia: tipo de retorno
20/10/2011 IIP - Curso 2011/12 11
• Mediante el tipo de retorno se especifica el tipo del valor que el método
devuelve o se usa la palabra reservada void para indicar que el método no
devuelve ningún valor
• El tipo de cualquier valor de retorno de un método debe ser el mismo que el
tipo de retorno del método -único y definido en su cabecera
• El tipo de retorno de un método puede ser cualquier tipo de datos Java,
primitivo o referencia
• Para devolver un valor de retorno de un método se usa la instrucción
return expresión ;
• La ejecución de un método finaliza tras la ejecución una instrucción return
• Si un método no devuelve explícitamente nigún valor vía return entonces
el tipo de su resultado es void –implícitamente, se ejecuta "return ;"
como última instrucción de su cuerpo.

Métodos de instancia: parámetros
20/10/2011 IIP - Curso 2011/12 12
• Los parámetros definidos en la cabecera de un método, al
declararlo, se denominan parámetros formales pues no tienen
asociado un valor real
Sintaxis : tipo1 nomParam1, tipo2 nomParam2, ..., tipok nomParamk
¡Atención! No confundir esta sintaxis con la de declaración de variables:
tipo1 nomParam1, nomParam2, ..., nomParamk es una declaración
de parámetros ¡¡¡ incorrecta !!!!
Uso en el cuerpo del método: (sus identificadores) pueden
usarse como variables en el cuerpo del método, sin volver a
declararse. ¡Atención! su inicialización se realiza única y
exclusivamente al invocar la ejecución del método
• Se puede declarar métodos sin parámetros (nomMetodo()), i.e.
con una lista de parámetros vacía

1320/10/2011 IIP - Curso 2011/12 13
private double x;
private double y;
…
public void mover(double px, double py) {
x += px; y += py;
}
public double distancia (Punto p) {
double px = p.x – x;
double py = p.x –y;
return Math.sqrt(px*px + py*py);
}
…
}
Métodos de instancia: parámetros

private double x, y;
…
public void mover(double x, double y) {
this.x += x; this.y += y;
}
}
Métodos de instancia: cuerpo
20/10/2011 IIP - Curso 2011/12 14
• Bloque de código. Si el tipo de retorno no es void debe incluir
instrucción return.
• Son variables locales a un método las que se declaran en su
cuerpo, sus parámetros y el objeto en curso (this).
• Desde cualquier método se puede acceder además a los
atributos de clase y de instancia definidos en su clase (variables
globales)
• Si una variable local y una global tienen el mismo nombre
siempre se asocia a la local (principio de máxima proximidad)

1520/10/2011 IIP - Curso 2011/12 15
private double x;
private double y;
…
public void mover(double px, double py) {
x += px; y += py;
}
…
}
Otro ejemplo de principio de máx.
proximidad
double x = p.x – x;
double y = p.x –y;
}
double x = p.x – this.x;
double y = p.x – this.y;
}
¡ ERROR
DE
COMPILACIÓN !
¡ OK !

Uso de métodos: llamada a un método de
instancia
[objetoReal.]nombreMetodo ( arg1, arg2, … , argn)
20/10/2011 IIP - Curso 2011/12 16
donde:
1. objetoReal: es el objeto al que se le aplica el método; es
opcional si la llamada se hace dentro de un método de la propia
clase y se aplica a this.
2. nombreMetodo: es el identificador del método.
3. arg1, arg2, … , argn: lista de argumentos o datos de entrada (n
es el número de parámetros formales); se llaman parámetros
reales o argumentos y deben tener un valor concreto.
Debe existir concordancia en cuanto a número, tipo y orden
de aparición entre los parámetros formales y los argumentos

17
Ejemplos de llamadas a métodos
20/10/2011 IIP - Curso 2011/12 17
Punto p = new Punto(); int x = 3;
// p es (0,0)
p.mover(x, x+1); // p es (3.0, 4.0)
double d = 3 * p.distOrigen(); // d = 15.0
Punto q = new Punto().mover(d, p.distOrigen());
// q es (15.0, 5.0)
private double x;
private double y;
public void mover(double px, double py) { x += px; y += py; }
private int aleatorio() {
return (int)(Math.random()*(2*distOrigen()+1));
}
public void moverAleat() { x += aleatorio(); y += aleatorio(); }
public double distOrigen() { return Math.sqrt(x*x + y*y); }
public double distancia(Punto p) {
double x = p.x - this.x; double y = p.y - this.y;
}
}

18
Uso de métodos
• Un parámetro real o argumento es cualquier expresión que se
evalúe a un tipo de datos compatible con el del correspondiente
parámetro formal de la cabecera del método.
• Al evaluar un argumento el correspondiente parámetro formal
se inicializa al valor resultante (toma dicho valor).
• La llamada a un método se evalúa al resultado que éste
devuelve
• Se puede realizar la invocación a un método en cualquier
expresión que tenga un tipo compatible con el de retorno del
método
20/10/2011 IIP - Curso 2011/12 18

19
Uso de métodos: ejecución de una
llamada
• Java asocia una zona de memoria exclusiva para los datos y
cálculos del método: registro de activación.
• Si se está ejecutando el método A y se llega a una instrucción que
es una llamada a un método B:
– Se evalúan en A las expresiones que aparecen como argumentos en la
llamada
– Se reserva espacio en memoria para el registro de activación de B
– Los parámetros de B se inician (en el registro) a los valores calculados (paso
de parámetros por valor). La variable this del nuevo registro se inicia también
–Se ejecutan las instrucciones de B; el método acaba con la instrucción return
– Acabada la llamada a B, la ejecución de A prosigue desde el punto en que se
llamó a B
–El registro de activación de B se libera
20/10/2011 IIP - Curso 2011/12 19

20
Ejecución de una llamada
20/10/2011 IIP - Curso 2011/12 20
Registro de activación
de la llamada a mover
p
0.0
x 0.0
y
montículo
this
x
3
px
3.0
py
4.0
Registro de activación
de la llamada a mover
p
4.0
x 3.0
y
montículo
this
x
3
px
3.0
py
4.0
Punto p = new Punto(); int x = 3;
// p es (0,0)
p.mover(x, x+1); // p es (3.0, 4.0)
double d = 3 * p.distOrigen(); // d = 15.0
Punto q = new Punto().mover(d, p.distOrigen());
// q es (15.0, 5.0)

21
Paso de parámetros por valor: variables de
tipo primitivo y referencia
20/10/2011 IIP - Curso 2011/12 21
public void intercambio(int a, int b){
int aux = a;
a = b; b = aux;
}
…
int i = 5, j = 7;
intercambio(i,j); // i = 5 y j = 7
public void intercambio(Punto a, Punto b){
Punto aux = a; a = b; b = aux;
}
public void intercambiox(Punto a, Punto b){
double aux = a.x; a.x = b.x; b.x = aux;
}
…
//creados p=(3.0,5.0) y q=(6.0,2.0)
intercambio(p,q); // p=(3.0,5.0) y q=(6.0,2.0)
intercambiox(p,q); // p=(6.0,5.0) y q=(3.0,2.0)

Métodos constructores
• No tienen tipo de retorno
• Su nombre es el de la clase
• Se invocan con el operador new: new NombreClase(arg1, arg2, .., argn)
• Su resultado es el objeto creado
20/10/2011 IIP - Curs 2011/12 22
public NombreClase ([ListaParametros]){
// instrucciones del cuerpo del método
}
…
public Punto() { x=0; y=0; }
public Punto(double abs,double ord){
x = abs; y = ord;
}
…
}
Punto p = new Punto();
Punto q = new Punto(5,10);
double dist = q.distancia(new Punto(2,6));

Llamada un método constructor
• Igual que en los métodos de instancia, una vez evaluados los
parámetros reales se crea un registro de activación y se pasa su
valor a los parámetros formales.
• Se obtiene un bloque de memoria no utilizada en el montículo, lo
suficientemente grande como para contener un objeto del tipo
especificado, que pasará a ser el objeto en curso con el que se
inicia this.
• Se inicializan las variables de instancia del objeto, con el valor que
se especifica o con el valor por defecto.
• Si hay instrucciones en el cuerpo del constructor se ejecutan.
• Se devuelve this como resultado de la llamada al constructor.
20/10/2011 IIP - Curso 2011/12 23

Métodos constructores: uso de this
private double x;
private double y;
this.x = abs; this.y = ord;
}
public Punto() {
this(0,0);
}
public Punto(Punto p) {
this(p.x,p.y);
}
…
}
20/10/2011 IIP - Curso 2011/12 24

Sobrecarga de métodos
private double x;
private double y;
this.x = abs; this.y = ord;
}
public Punto() { this(0,0); }
public Punto(Punto p) { this(p.x,p.y); }
…
}
20/10/2011 IIP - Curso 2011/12 25
Los métodos Java se pueden sobrecargar: pueden tener el mismo
nombre y declararse en el mismo ámbito siempre que tengan el
mismo resultado pero distintas listas de parámetros.

Métodos de clase o estáticos
• Un método de clase o método estático es un método propio de
la clase (no es un método de objeto) que da funcionalidades a
nivel de toda la clase, es decir, del conjunto de objetos creados
para dicha clase.
• Un ejemplo de método de clase es el método main y los métodos
definidos en la clase Math, clase predefinida en Java para realizar
operaciones aritméticas con expresiones numéricas.
20/10/2011 IIP - Curso 2011/12 26
// x es una variable de tipo double y positiva
double rx = Math.sqrt(x);
static double sqrt(double a)
Returns the correctly rounded positive square root of a double value.

Métodos estáticos: definición y uso
• Se definen como los métodos de instancia añadiendo en la
cabecera el modificador static.
• En el cuerpo del método no puede usarse this porque no hay
objeto en curso.
• La sintaxis para llamar a un método estático:
20/10/2011 IIP - Curso 2011/12 27
[NombreClase.]nombreMetodo ( arg1, arg2, … , argn)

Métodos estáticos: ejemplos
public class TestPunto {
/** Método principal que prueba la clase Punto. */
Punto p = new Punto(2.5,3.0);
Punto q = new Punto(4.0,5.0);
System.out.print("Dist. entre("+p.getX()+","+p.getY()+")");
System.out.print(" y ("+q.getX()+","+q.getY()+"): ");
System.out.println( distancia(p,q) );
}
/** Calcula la distancia entre dos puntos dados */
public static double distancia(Punto a, Punto b) {
double x = b.x - a.x; double y = b.y - a.y;
}
} 20/10/2011 IIP - Curso 2011/12 28

• Clases de utilidades: clases que no definen nuevos tipos
datos. Agrupan métodos estáticos de utilidad general sobre
tipos previamente definidos.
• No se definen atributos el constructor por defecto crea
objetos vacíos (por ello, se suele hacerlo private).
• No incluyen un método main: no se ejecutan, dan servicio a
otras clases.
• Es habitual agrupar en paquetes clases de utilidades que
presten funcionalidades relacionadas de alguna manera.
• Entre las predefinidas de Java destaca Math, del paquete
java.lang: repertorio de operaciones sobre datos numéricos
(raíz cuadrada, redondeo, funciones trigonométricas, …)
20/10/2011 IIP - Curso 2011/12 29
Métodos estáticos: clases de utilidades

Pila de llamadas
• Java sólo ejecuta un método a la vez: método activo.
• Cuando un método A invoca a un método B:
– la ejecución de A queda en suspenso,
– el estado de A estado se preserva en su registro de
activación, que no se destruye hasta que se reanude y
acabe su ejecución.
• En memoria pueden coexistir varios registros:
– el registro del método activo o registro activo,
– un registro por cada método que permanezca suspendido.
20/10/2011 IIP - Curso 2011/12 30

Pila de llamadas
• Pila de llamadas (stack): Java gestiona los registros ordenándolos por
antigüedad. Cuando A invoca a B, su registro se dispone en la cima
de la pila (1); al terminar, su registro se desapila (3).
• El método activo sólo puede acceder a las variables de la cima (2).
• Las variables de clase están aparte, y son accesibles por cualquier
método activo (siempre que sean públicas para el método).
20/10/2011 IIP - Curso 2011/12 31
main
A
B
main
A
B
main
A
B
(2)(1) (3)
Datos accesibles por
la ejecución de B
… Información estática
de las clases
pública
privada
clase B ... otras clases

Pila de llamadas
• Java usa unas variables en cada registro para facilitar sus propios cálculos
intermedios y el control de la ejecución. Entre otras, destacan:
– VR (valor de retorno): Del tipo de retorno. Es en donde se guarda el valor a
devolver por la llamada (excepto si es void).
– DR (dirección de retorno): Se guarda el punto del código en donde A invoca a B.
• Ejemplo (1). El método main de una clase Prueba invoca al método
distancia de Punto:
20/10/2011 IIP - Curso 2011/12 32
0.0x q1
nullargs q2
DR
0.0x
0.0y
3.0x
4.0y
pila montículo
public double distancia(Punto p){
double x = p.x - this.x;
double y = p.y - this.y;
}
public static void main(String[] args){
double x = 0.0;
Punto q1 = new Punto(3.0,4.0);
Punto q2 = new Punto();
x = q2.distancia(q1);
System.out.println(x);
}
Prueba.main

Pila de llamadas
• Ejemplo (2): El método distancia ha calculado el resultado
en la variable VR de su registro, y Java está a punto de
reanudar main por donde indica DR:
20/10/2011 IIP - Curso 2011/12 33
4.0y p
3.0xVR 5.0 this
DR
0.0x q1
nullargs q2
DR
0.0x
0.0y
3.0x
4.0y
pila montículo
Punto.distanciapublic double distancia(Punto p){
}
double x = 0.0;
}
Prueba.main

Pila de llamadas
• Ejemplo (3). El método main ha recibido en x el resultado de
la llamada a distancia y está a punto de terminar:
20/10/2011 IIP - Curso 2011/12 34
5.0x q1
nullargs q2
DR
0.0x
0.0y
3.0x
4.0y
pila montículo
public double distancia(Punto p){
}
double x = 0.0;
}
Prueba.main

Sobrescritura de los métodos de Object
• Object es una clase predefinida de Java que define el comportamiento
común de todos los objetos del lenguaje: tras ser creados residen en el
heap y son accesibles por referencias.
• Un Object no tiene estructura interna, es un objeto vacío.
• Cualquier objeto de Java es un caso particular de Object, de quien
heredan sus métodos, entre los que destacan:
Comprueba si el objeto y o son el mismo objeto del heap.
Devuelve una String que indica la clase del objeto y un código numérico.
20/10/2011 IIP - Curso 2011/12 35
public boolean equals(Object o)
public String toString()

IIP - Curso 2011/12 36
• Una característica primordial de los métodos heredados es que en cada
clase se pueden sobreescribir a conveniencia.
• Ejemplo. En la clase Punto:
/** Comprueba si o es un Punto y sus
* coordenadas coinciden con las del punto
*/
public boolean equals(Object o){
return o instanceof Punto
&& this.x==((Punto)o).x
&& this.y==((Punto)o).y ;
}
/** Devuelve la información del punto
* en el formato "(x,y)"
*/
public String toString(){
return "("+this.x+","+this.y+")" ;
}
El estándar recomienda
que equals compruebe
si o es de la clase
(operador instanceof),
y la coincidencia
atributo a atributo.

20/10/2011 IIP - Curso 2011/12 37
• Si Java encuentra el método sobreescrito en la clase, usa el
código interno de la clase,
• sino, usaría el código del método en Object.

Documentación de los métodos
20/10/2011 IIP - Curso 2011/12 38
La documentación de los métodos de una clase sirve para dos
fines diferentes:
• Previamente a la implementación. Especifica todas las características
del método, respecto a los datos (incluyendo casos especiales), y
cuál es el resultado deseado; la implementación debe hacerse de
acuerdo con esta especificación.
• Posterior e independientemente de la implementación. Indica cómo
usar los métodos, es decir, cuál es su perfil, qué condiciones
especiales deben cumplir los parámetros y cuál es el resultado que
se puede esperar en cada caso.
• Se debe evitar, en lo posible, incluir referencias a cómo se han
implementado. Es en el cuerpo de los métodos donde deben
comentarse los detalles de implementación.

20/10/2011 IIP - Curso 2011/12 39
Java tiene definido un estándar de documentación, en forma de
comentarios a incluir en el código fuente.
• Si se sigue el estándar, la herramienta de Java javadoc genera
automáticamente el documento html con un estilo definido.
• Básicamente:
/** Decripción del método, incluyendo condiciones de
* de los datos y casos especiales.
* @param parámetro1 tipo1
…… ……
* @param parámetroN tipoN
* @return tipoRetorno valor devuelto
*/
Descripción del valor devuelto (para métodos no void)
Descripción de los parámetros

20/10/2011 IIP - Curso 2011/12 40
En BlueJ javadoc se ejecuta
al pasar de la vista de código
a la vista de documentación

MétodosObjetoClase

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (19)

Destacado

Destacado (12)

Similar a MétodosObjetoClase

Similar a MétodosObjetoClase (20)

Último

Último (20)

MétodosObjetoClase