¡Descarga Apuntes sobre la modularización en Java: Definición y uso de métodos y más Apuntes en PDF de Programación Java solo en Docsity!
MétodosMétodos MétodosMétodos
Los métodos definen el comportamiento de los objetos de una clase dada (lo que podemos hacer con los objetos de esa clase)
Los métodos exponen la interfaz de una clase.
Un método define la secuencia de sentencias que se ejecuta para llevar a cabo una operación:
La implementación de la clase se oculta del exterior.
Los métodos…
Nos dicen cómo hemos de usar los objetos de una clase.
Nos permiten cambiar la implementación de una clase sin tener que modificar su interfaz (esto es, sin tener que modificar el código que utiliza objetos de la clase cuya implementación cambiamos)
Ejemplo : Utilizar un algoritmo más eficiente para resolver un problema concreto sin tener que tocar el código del resto del programa.
Definición de métodos
Sintaxis en Java
modificadores tipo nombre ( parámetros ) { cuerpo }
La estructura de un método se divide en:
- Cabecera (determina su interfaz)
modificadores tipo nombre ( parámetros )
- Cuerpo (define su implementación)
{ // Declaraciones de variables ... // Sentencias ejecutables ... // Devolución de un valor (opcional) ... }
En el cuerpo del método se implementa el algoritmo necesario para realizar la tarea de la que el método es responsable.
El cuerpo de un método se puede interpretar como una caja negra que contiene su implementación:
El método oculta los detalles de implementación.
Cuando utilizamos un método, sólo nos interesa su interfaz.
La cabecera de un método
La cabecera de un método determina su interfaz
- Modificadores de acceso (p.ej. public o private) Determinan desde dónde se puede utilizar el método.
- Tipo devuelto (cualquier tipo primitivo, no primitivo o void) Indica de que tipo es la salida del método, el resultado que se obtiene tras llamar al método desde el exterior.
NOTA: void se emplea cuando el método no devuelve ningún valor.
- Nombre del método Identificador válido en Java CONVENCIÓN: En Java, los nombres de métodos comienzan con minúscula.
- Parámetros formales Entradas que necesita el método para realizar la tarea de la que es responsable. MÉTODOS SIN PARÁMETROS: Cuando un método no tiene entradas, hay que poner ()
El cuerpo de un método
El cuerpo de un método define su implementación:
NB: Como cualquier bloque de código en Java, el cuerpo de un método ha de estar delimitado por llaves { }
La signatura de un método
El nombre de un método, los tipos de sus parámetros y el orden de los mismos definen la signatura de un método.
ß Los modificadores y el tipo del valor devuelto por un método no forman parte de la signatura del método.
Sobrecarga
Lenguajes como Java permiten que existan distintos métodos con el mismo nombre siempre y cuando su signatura no sea idéntica (algo que se conoce con el nombre de sobrecarga )
Ejemplo System.out.prinln(…);
- System.out.println()
- System.out.println(boolean)
- System.out.println(char)
- System.out.println(char[])
- System.out.println(double)
- System.out.println(float)
- System.out.println(int)
- System.out.println(long)
- System.out.println(Object)
- System.out.println(String)
No es válido definir dos métodos con el mismo nombre que difieran únicamente por el tipo del valor que devuelven.
De todas formas, no conviene abusar demasiado de esta prestación del lenguaje, porque resulta propensa a errores (en ocasiones, creeremos estar llamando a una “versión” de un método cuando la que se ejecuta en realidad es otra).
NOTA: En la creación de constructores sí es importante disponer de esta característica.
Ejemplo de ejecución paso a paso Cuando se invoca un método, el ordenador pasa a ejecutar las sentencias definidas en el cuerpo del método:
public class Mensajes { public static void main (String[] args) { mostrarMensaje("Bienvenida"); // ... mostrarMensaje("Despedida"); }
private static void mostrarMensaje (String mensaje) { System.out.println("*** " + mensaje + " ***"); } }
Al ejecutar el programa (con java Mensajes):
1. Comienza la ejecución de la aplicación, con la primera sentencia especificada en el cuerpo del método main. 2. Desde main, se invoca mostrarMensaje con “Bienvenida” como parámetro. 3. El método mostrarMensaje muestra el mensaje de bienvenida decorado y termina su ejecución. 4. Se vuelve al punto donde estábamos en main y se continúa la ejecución de este método. 5. Justo antes de terminar, volvemos a llamar a mostrarMensaje para mostrar un mensaje de despedida. 6. mostrarMensaje se vuelve a ejecutar, esta vez con “Despedida” como parámetro, por lo que esta vez se muestra en pantalla un mensaje decorado de despedida. 7. Se termina la ejecución de mostrarMensaje y se vuelve al método desde donde se hizo la llamada (main). 8. Se termina la ejecución del método main y finaliza la ejecución de nuestra aplicación.
Los parámetros de un subprograma
Un método puede tener parámetros:
A través de los parámetros se especifican los datos de entrada que requiere el método para realizar su tarea.
Los parámetros definidos en la cabecera del método se denominan parámetros formales.
Para cada parámetro, hemos de especificar tanto su tipo como un identificador que nos permita acceder a su valor actual en la implementación del método.
Cuando un método tiene varios parámetros, los distintos parámetros se separan por comas en la cabecera del método.
En la definición de un método, la lista de parámetros formales de un método establece:
- Cuántos parámetros tiene el método
- El tipo de los valores que se usarán como parámetros
- El orden en el que han de especificarse los parámetros
En la invocación de un método, se han de especificar los valores concretos para los parámetros.
Los valores que se utilizan como parámetros al invocar un método se denominan parámetros actuales (o “argumentos”).
Ejemplo : Intercambio incorrecto de valores
public void swap (int a, int b) // Definición { int aux; aux = b; a = b; b = aux; } ... swap(a,b); // Invocación
Los valores de num1 y num2 se copian en a y b. La ejecución del método swap no afecta ni a num1 ni a num2.
swap no intercambia los valores de las variables porque el intercambio se hace sobre las copias locales de los parámetros de las que dispone el método, no sobre las variables originales.
Convenciones
- Si varios métodos utilizan los mismos parámetros, éstos han de ponerse siempre en el mismo orden.
De esta forma, resulta más fácil de recordar la forma correcta de usar un método.
- No es aconsejable utilizar los parámetros de una rutina como si fuesen variables locales de la rutina.
En otras palabras, los parámetros no los utilizaremos para almacenar resultados parciales.
- Se han de documentar claramente las suposiciones que se hagan acerca de los valores permitidos para los distintos parámetros de un método.
Esta información debería figurar en la documentación del código realizada con la herramienta javadoc.
- Sólo se deben incluir los parámetros que realmente necesite el método para efectuar su labor.
Si un dato no es necesario para realizar un cálculo, no tiene sentido que tengamos que pasárselo al método.
- Las dependencias existentes entre distintos métodos han de hacerse explícitas mediante el uso de parámetros.
Si evitamos la existencia de variables globales (datos compartidos entre distintos módulos), el código resultante será más fácil de entender.
Ejemplo Figuras geométricas
// Title: Geometry // Version: 0. // Copyright: 2004 // Author: Fernando Berzal // E-mail: [email protected]
public class Point { // Variables de instancia
private double x; private double y;
// Constructor
public Point (double x, double y) { this.x = x; this.y = y; }
// Métodos
public double distance (Point p) { double dx = this.x - p.x; double dy = this.y - p.y;
return Math.sqrt(dxdx+dydy); }
public String toString () { return "(" + x + "," + y + ")"; } }
NB: La interfaz de la clase habría que documentarlo añadiendo los correspondientes comentarios javadoc.
public class Circle { private Point centro; private double radio;
// Constructor public Circle (Point centro, double radio) { this.centro = centro; this.radio = radio; }
// Métodos public double area () { return Math.PIradioradio; }
public boolean isInside (Point p) { return ( centro.distance(p) < radio ); }
public String toString () { return "Círculo con radio " + radio
- " y centro en " + centro; } }
Ejemplo de uso
public static void main(String[] args) { Circle fig = new Circle( new Point(0,0), 10); Point dentro = new Point (3,3); Point fuera = new Point (10,10);
System.out.println(figura); System.out.println(dentro+"? "+fig.isInside(dentro)); System.out.println(fuera +"? "+fig.isInside(fuera) ); }
La clave de implementar la clase Point de esta forma (y no dar acceso directo a las variables de instancia) es que podemos cambiar la implementación de Point para usar coordenadas polares y la implementación de las clases que trabajan con puntos (p.ej. Circle) no hay que tocarla:
public class Point { // Variables de instancia private double r; private double theta;
// Constructor public Point (double x, double y) { r = Math.sqrt(xx+yy); theta = Math.atan2(y,x); }
// Acceso a las coordenadas
public double getX () { return r*Math.cos(theta); }
public double getY () { return return r*Math.sin(theta); } }
Gracias a la encapsulación, podemos crear componentes reutilizables cuya evolución no afectará al resto del sistema.
Podemos definir varios constructores para poder inicializar un objeto de distintas formas (siempre y cuando los constructores tengan signaturas diferentes);
public class Contacto { private String nombre; private String email;
public Contacto (String nombre) { this.nombre = nombre; }
public Contacto (String nombre, String email) { this.nombre = nombre; this.email = email; }
}
Ejemplo de uso:
public class ContactoTest { public static void main(String[] args) { Contacto nico = new Contacto (“Nicolás”);
Contacto juan = new Contacto (“Juan”, “[email protected]”); ... } }
Constructor de copia Un constructor que recibe como parámetro un objeto de la misma clase que la del constructor
Métodos estáticos
Los métodos estáticos pertenecen a la clase (no están asociados a un objeto particular de la clase)
Ya hemos visto algunos ejemplos:
Math.pow(x,y)
public static void main (String[] args) …
Para invocar un método estático, usamos directamente el nombre de la clase (p.ej. Math)
No tenemos que instanciar antes un objeto de la clase.
main es un método estático de forma que la máquina virtual Java puede invocarlo sin tener que crear antes un objeto.
Como los métodos estáticos no están asociados a objetos concretos, no pueden acceder a las variables de instancia de un objeto (las cuales pertenecen a objetos particulares).
Variables estáticas = Variables de clase
Las clases también pueden tener variables que se suelen emplear para representar constantes y variables globales a las cuales se pueda acceder desde cualquier parte de la aplicación (aunque esto último no es muy recomendable).
Ejemplos System.out
Colores predefinidos: Color.black, Color.red…
Como es lógico, los métodos estáticos sólo pueden acceder a variables estáticas.
public class Mensajes { private String mensaje = “Hola”; // ¡Error!
public static void main (String[] args) { mostrarMensaje(mensaje); }
private static void mostrarMensaje (String mensaje) { System.out.println("*** " + mensaje + " ***"); } }
El programa anterior funcionaría correctamente si hubiésemos declarado mensaje como una variable estática:
private static String mensaje = “Hola”;
NOTA: No es aconsejable declarar variables estáticas salvo para definir constantes, como sucede en la clase Math.
Métodos estáticos y variables estáticas en la clase Math
- Constantes matemáticas: Math.PI, Math.E
- Métodos estáticos: Funciones trigonométricas (sin, cos, tan, acos, asin, atan), logaritmos y exponenciales (exp, log, pow, sqrt), funciones de redondeo (ceil, floor, round [== Math.floor(x+0.5)], rint [al entero más cercano, se coge el par]), máximo y mínimo (max, min), valor absoluto (abs), generación de número pseudoaleatorios (random)…
