Tt 05-cas-x1

60 %
40 %
Information about Tt 05-cas-x1
Education

Published on March 20, 2014

Author: andresgarciagarcia921

Source: slideshare.net

Description

Introduccion a la programación y la informática, Universitat Politècnica de València.

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 + ")"); System.out.println("(" + p2.x + "," + p2.y + ")"); System.out.println("(" + p3.x + "," + p3.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; double lado23 = Math.sqrt(dx*dx + dy*dy); dx = p1.x - p3.x; dy = p1.y - p3.y; double lado13 = Math.sqrt(dx*dx + dy*dy); 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 { 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 + ")"); System.out.println("(" + p2.x + "," + p2.y + ")"); System.out.println("(" + p3.x + "," + p3.y + ")"); 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; return Math.sqrt(x*x + y*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 public class Punto { 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

public class Punto { 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 public class Punto { 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 public double distancia (Punto p) { double x = p.x – x; double y = p.x –y; return Math.sqrt(x*x + y*y); } public double distancia (Punto p) { double x = p.x – this.x; double y = p.x – this.y; return Math.sqrt(x*x + y*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) public class Punto { 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; return Math.sqrt(x*x + y*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 class Punto { … 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 public class Punto { private double x; private double y; public Punto(double abs,double ord){ 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 public class Punto { private double x; private double y; public Punto(double abs,double ord){ 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. */ public static void main(String[] args) { 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; return Math.sqrt(x*x + y*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; return Math.sqrt(x*x + y*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 = p.x - this.x; double y = p.y - this.y; return Math.sqrt(x*x + y*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 (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 = p.x - this.x; double y = p.y - this.y; return Math.sqrt(x*x + y*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

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()

Sobrescritura de los métodos de Object 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.

Sobrescritura de los métodos de Object 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.

Documentación de los métodos 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

Documentación de los métodos 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

Add a comment

Related presentations