Métodos: Declaración.

 Además de crear objetos de unas propiedades determinadas -atributos-, las Clases en Java permiten crear, declarar o definir operaciones o métodos que actúen con los objetos creados al ser invocados o llamados por ellos. El obrar sigue al ser: se crean objetos y esos objetos pueden operar de muchos modos. Los métodos son esas herramientas que utilizan los objetos en su operar.

Además se pueden definir métodos que no precisan objetos para operar. Se emplean en cualquier Clase, y se llaman métodos estáticos o de clase. Por ejemplo System.out.println(), o Math.ramdow(); Es preciso para usarlos que la Clase esté cargada: import.java.util.*;  .... u otros modos para clases específicas.

Los métodos de objeto o dinámicos, en contraposición a los estáticos o de clase, requieren ser utilizados, llamados o invocados por objetos ya existentes, para ello se utilizan los métodos constructores que los crean e inicializan sus atributos mediante los valores de los parámetros materiales.

•En cualquier clase Java, y tal como ya hemos visto en las clases predefinidas (Point, String, ...) se van a poder incluir definiciones de métodos de los siguientes tipos:
- Constructores: Se usan para crear un objeto de la clase (con el operador new), entre los que se encuentra el constructor por defecto.
- Métodos de instancia: Métodos que se aplican con la notación de punto sobre un objeto de la clase previamente construido.
- Métodos estáticos: aquellos que no precisan que exista un objeto de la clase al que se les pueda aplicar.

•Se denomina objeto en curso al objeto concreto que se está creando o al que se le está aplicando el método. Cada vez que se usa uno de estos métodos se dice que se hace una llamada o invocación al método y se ejecutan las instrucciones que se incluyen en la definición del método, con la sintaxis y comportamiento que se va a mostrar en este tema.
 •Métodos de objeto
Los métodos, también los constructores, se declaran siempre con la siguiente estructura:
cabecera o perfil:  [modificadores] TipoRetorno  nombreMetodo([Lista de parámetros])
cuerpo del método: {......}

La cabecera indica dónde o cómo emplear el método; Si público se puede emplear en cualquier clase que tenga acceso (importación...). Si privado, sólo en la clase en la que está definido. Si estático, es un método de Clase y se accede a través de la misma. Si dinámico ha de ser utilizado o invocado por un objeto de esta Clase, bien sea público o privado:

[modificadores] TipoRetorno nombreMétodo ([ListaParámetros])
•Los modificadores pueden ser una o más etiquetas de los siguientes dos tipos:
1. public/private/por defecto: determinan la visibilidad o accesibilidad del método.
2. static/por defecto: static indica que el método es de clase; por defecto el método es de objeto.

•Los métodos públicos aparecen en la interfaz de la clase. Ejemplo: Considerar el método de String
El código que aparece escrito dentro de la clase lo etiqueta como public:
•Las clases pueden contener otros métodos que sólo sirvan para hacer cálculos auxiliares o de apoyo para el resto de métodos, por lo que se etiquetan como private y no pueden usarse fuera de la clase ni aparecen en la interfaz.

[modificadores] TipoRetorno nombreMétodo ([ListaParámetros])
1. public/private/por defecto: las reglas de visibilidad son las mismas que en el caso de los atributos.
public double distancia(Punto p1, Punto p2) {
...
}
•Ejemplo: En la clase Punto se pueden incluir, entre otros, un método que sirva para calcular la  distancia de un punto al origen, métodos que tomando como datos unas coordenadas polares, calculen la abscisa y la ordenada de las coordenadas cartesianas, ...
public class Punto{
double x, y;
public Punto() { }
...
public double distOrigen( ){ ... }
...
public static double absDePolares(double dist,double alfa) {
...
}
public static double ordDePolares(double dist,double alfa) {
...
}
Se declaran static porque no trabajan con los datos x, y de ningún punto que debiera existir previamente.

[modificadores] TipoRetorno nombreMétodo ([ListaParámetros])
•El tipo de retorno indica de qué tipo es el resultado del método.
•Todos los métodos, con la sola excepción de los constructores, llevan en el cabecera el tipo de retorno.
•Aquellos métodos que no retornan ningún valor, se deben declarar de tipo void (vacío).
Un ejemplo de método void que ya hemos usado en nuestros programas es el método de escritura en la salida estándar:
El uso de un método void debe terminar con ;
System.out.println("Hola"); // No se asigna ningún resultado a ninguna variable

[modificadores] TipoRetorno nombreMétodo ([ListaParámetros])
•La lista de parámetros es una lista ordenada de la forma: tipo1 nomPar1, tipo2 nomPar2, ..., tipoN nomParN que define cuáles son los datos del método. Se les denomina los parámetros formales del
método, mientras que a los valores que se usan como datos en una llamada concreta se denominan parámetros reales.
•Ejemplo: Una de las variantes del método substring de la clase String está declarado
con la siguiente cabecera:
public String substring(int beginIndex, int endIndex)
String s = "Ejemplo" ; int n = s.lenght(); // n vale 7
String s2 = s.substring(n-4,n-2); // s2 es "mp"
Lista de parámetros beginIndex, endIndex son los parámetros formales del método, mientras que en
la siguiente llamada al método, los correspondientes parámetros reales valen 3 y 5 respectivamente.

•Todo parámetro debe venir acompañado por su tipo. Si se dan varios parámetros del mismo tipo, se deberá repetir el tipo para cada uno de ellos. Ejemplo:
•En la misma clase pueden declararse métodos con el mismo nombre e incluso con igual tipo de retorno, siempre que tengan diferentes listas de parámetros (lo que permite distinguirlos).
En dicho caso, se dice que el método está sobrecargado.
Ejemplos: las diversas variantes de indexOf, o de substring en la clase String.
public String substring(int beginIndex, int endIndex)
public String substring(int beginIndex, endIndex) Sintácticamente incorrecto

En el cuerpo del método se implementan los algoritmos necesarios para que realice las operaciones que se desea que ejecute. Digamos que es la parte específica de programación. Puede utilizar variables locales: las específicas que se definen en el método y, al terminar de ejecutarse, dejan de tener valores. Las que se obtienen mediante métodos como algunos de la clase String, o de la clase Array. Las que se introducen mediante los parámetros formales a través de los parámetros materiales o valores específicos. Y variables globales como los atributos de los objetos. También variables que se importan de otras clases, como PI, e, ... 

•El cuerpo del método es un bloque de instrucciones que contiene las instrucciones a ejecutar cuando se usa el método.
•Si el tipo de retorno no es void, debe incluir al menos una instrucción de la forma:
return expresión;
en donde expresión ha de ser del tipo de retorno.
La ejecución de esta instrucción siempre produce que el método acabe, y devuelve el valor de la expresión como valor resultante del método.
Ejemplo: Método que dadas las coordenadas polares de un punto, distancia y ángulo, calcula la abscisa.
public static double absDePolares(double dist,double alfa) {
return dist*Math.cos(alfa);
}

•En el cuerpo del método se pueden declarar y manipular variables, y hacer llamadas a otros métodos.
•Se denominan variables locales del método a:
-las que se declaran dentro del cuerpo,
-los parámetros formales del método,
-la variable final this implícita de los métodos de objeto, cuyo tipo siempre el de la clase en la que se escribe el método.
•Las variables locales se pueden usar en el cuerpo del método y se inician de la siguiente forma:
-Los parámetros formales se inician automáticamente a los valores de los parámetros reales.
-La variable this se inicia al objeto en curso, y no se puede cambiar.
-Para poder usar una variable declarada en el cuerpo de un método hay que haberla iniciado.
•Si la variable local es un objeto, se puede acceder a sus atributos si las reglas de visibilidad lo permiten.

•Además de las variables locales, se pueden usar los atributos estáticos de cualquier clase, siempre que las reglas de visibilidad lo permitan (por ejemplo, Math.PI, Math.E se pueden usar en cualquier  método).
•Se pueden usar los métodos de cualquier clase siempre que sean visibles.
•Ejemplo: El siguiente método de la clase Punto calcula la distancia entre el Punto (el objeto en curso) y p.
public double distancia(Punto p){
double dx = p.x –this.x;
double dy = p.y –this.y;
return Math.sqrt(dx*dx + dy*dy);
}

•En el cuerpo de los constructores también se pueden declarar variables locales y manipular el objeto en curso (objeto que se crea).
public class Punto{
double x;
double y;
public Punto(){ }
public Punto(double x,
double y){
this.x = x;
this.y = y;
}
...
}
•Ejemplo:
Se ha sobrecargado el constructor:
1. Constructor por defecto (como el cuerpo se deja vacío, los atributos se inician al valor por defecto).
2. Constructor que crea el objeto e inicia sus atributos con los valores x e y.
•¡Atención cuando se sobrecarga el constructor! Si se desea mantener el constructor por defecto, hay que escribirlo explícitamente.

•Si el método es de clase no hay objeto en curso, por lo que no puede aparecer la palabra this en su cuerpo.
•Ejemplos. Métodos que calculan las coordenadas cartesianas de un punto a partir de las coordenadas polares:
•Otro ejemplo es el método especial con perfil:
public static void main(String[] args)
que caracteriza a las clases ejecutables por la JVM.
public static double absDePolares(double dist,double angulo){
return dist*Math.cos(angulo);
}
public static double ordDePolares(double dist,double angulo){
return dist*Math.sin(angulo);
}
public static Punto polaresAPunto(double dist,double angulo){
Punto p = new Punto();
p.x = dist*Math.cos(angulo);
p.y = dist*Math.sin(angulo);
return p;
}

Comentarios

Entradas populares de este blog

Definición de la estructura o atributos que tendrán los objetos de una clase.

La clase String de java