MÉTODOS, OBJETOS, CLASES Y CONSTRUCTORES EN JAVA
Un método en Java es un conjunto de instrucciones definidas dentro de una clase, que realizan una determinada tarea y a las que podemos invocar mediante un nombre.
Algunos métodos que hemos utilizado hasta ahora:
– Math.pow()
– Math.sqrt()
– Character.isDigit()
- System.out.println();
Cuando se llama a un método, la ejecución del programa pasa al método y cuando éste acaba, la ejecución continúa a partir del punto donde se produjo la llamada.
Utilizando métodos:
- Podemos construir programas modulares.
- Se consigue la reutilización de código. En lugar de escribir el mismo código repetido cuando se necesite, por ejemplo para validar una fecha, se hace una llamada al método que lo realiza.
En Java un método siempre pertenece a una clase.
Todo programa java tiene un método llamado main. Este método es el punto de entrada al programa y también el punto de salida.
1. ESTRUCTURA GENERAL DE UN MÉTODO JAVA
La estructura general de un método Java es la siguiente:
La estructura general de un método Java es la siguiente:
[especificadores] tipoDevuelto nombreMetodo([lista parámetros]) [throws listaExcepciones]
{
// instrucciones
[return valor;]
}
Los elementos que aparecen entre corchetes son opcionales.
especificadores (opcional): determinan el tipo de acceso al método. Se verán en detalle más adelante.
tipoDevuelto: indica el tipo del valor que devuelve el método. En Java es imprescindible que en la declaración de un método, se indique el tipo de dato que ha de devolver. El dato se devuelve mediante la instrucción return. Si el método no devuelve ningún valor este tipo será void.
nombreMetodo: es el nombre que se le da al método. Para crearlo hay que seguir las mismas normas que para crear nombres de variables.
Lista de parámetros (opcional): después del nombre del método y siempre entre paréntesis puede aparecer una lista de parámetros (también llamados argumentos) separados por comas. Estos parámetros son los datos de entrada que recibe el método para operar con ellos. Un método puede recibir cero o más argumentos. Se debe especificar para cada argumento su tipo. Los paréntesis son obligatorios aunque estén vacíos.
throws listaExcepciones (opcional): indica las excepciones que puede generar y manipular el método.
return: se utiliza para devolver un valor. La palabra clave return va seguida de una expresión que será evaluada para saber el valor de retorno. Esta expresión puede ser compleja o puede ser simplemente el nombre de un objeto, una variable de tipo primitivo o una constante.
El tipo del valor de retorno debe coincidir con el tipoDevuelto que se ha indicado en la declaración del método.
Si el método no devuelve nada (tipoDevuelto = void) la instrucción return es opcional.
Un método puede devolver un tipo primitivo, un array, un String o un objeto.
Un método tiene un único punto de inicio, representado por la llave de inicio {. La ejecución de un método termina cuando se llega a la llave final } o cuando se ejecuta la instrucción return.
La instrucción return puede aparecer en cualquier lugar dentro del método, no tiene que estar necesariamente al final.
2. IMPLEMENTACIÓN DE MÉTODOS EN JAVA
Pasos para implementar un método:
1. Describir lo que el método debe hacer
2. Determinar las entradas del método
3. Determinar los tipos de las entradas
4. Determinar el tipo del valor retornado
5. Escribir las instrucciones que forman el cuerpo del método
6. Prueba del método: diseñar distintos casos de prueba
Ejemplo de método: método que suma dos números enteros.
import java.util.*;
public class Metodos1 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int numero1, numero2, resultado;
System.out.print("Introduce primer número: ");
numero1 = sc.nextInt();
System.out.print("Introduce segundo número: ");
numero2 = sc.nextInt();
resultado = sumar(numero1, numero2);
System.out.println("Suma: " + resultado);
}
public static int sumar(int a, int b){
int c;
c = a + b;
return c;
}
}
El método se llama sumar y recibe dos números enteros a y b. En la llamada al método los valores de las variables numero1 y numero2 se copian en las variables a y b. El método suma los dos números y guarda el resultado en c. Finalmente devuelve mediante la instrucción return la suma calculada.
Ejemplo de programa Java que contiene un método con varios return:
Programa que lee por teclado un año y calcula y muestra si es bisiesto. Para realizar el cálculo utiliza un método llamado esBisiesto.
import java.util.*;
public class Bisiesto {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int año;
System.out.print("Introduce año: ");
año = sc.nextInt();
if(esBisiesto(año)) //llamada al método
System.out.println("Bisiesto");
else
System.out.println("No es bisiesto");
}
/**
* método que calcula si un año es o no bisiesto
*/
public static boolean esBisiesto(int a){
if(a%4==0 && a%100!=0 || a%400==0)
return true;
else
return false;
}
}
En la llamada al método bisiesto, el valor de la variable año se copia en la variable a y el método trabaja con esta variable. El valor true ó false devuelto por return pasa a ser el valor de la condición.
Ejemplo de programa Java: Método que no devuelve ningún valor. El método cajaTexto recibe un String y lo muestra rodeado con un borde.
Los constructores tienen el mismo nombre que la clase en la que son definidos y nunca tienen tipo de retorno, ni especificado ni void. Tenemos aquí un aspecto que nos permite diferenciar constructores de métodos: un constructor nunca tiene tipo de retorno mientras que un método siempre lo tiene. Es recomendable que en un constructor se inicialicen todos los atributos de la clase aunque su valor vaya a ser nulo o vacío. Si un atributo se quiere inicializar a cero (valores numéricos) siempre lo declararemos específicamente: nombreAtributo = 0;. Si un atributo se quiere inicializar a contenido nulo (atributos que son objetos) siempre lo declararemos específicamente: nombreAtributo = null;. Si un atributo tipo texto se quiere inicializar vacío siempre lo declararemos específicamente: nombreAtributo = “”;. El motivo para actuar de esta manera es que declarando los atributos como nulos o vacíos, dejamos claro que esa es nuestra decisión como programadores. Si dejamos de incluir uno o varios campos en el constructor puede quedar la duda de si hemos olvidado inicializar ese campo o inducir a pensar que trabajamos con malas prácticas de programación.
El tipo devuelto es void y no es necesario escribir la sentencia return. El método acaba cuando se alcanza la llave final.
import java.util.*;
public class MetodoVoid {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String cadena;
System.out.print("Introduce cadena de texto: ");
cadena = sc.nextLine();
cajaTexto(cadena); //llamada al método
}
/**
* método que muestra un String rodeado por un borde
*/
public static void cajaTexto(String str){
int n = str.length();
for (int i = 0; i < n + 4; i++){
System.out.print("#");
}
System.out.println();
System.out.println("# " + str + " #");
for (int i = 0; i < n + 4; i++){
System.out.print("#");
}
System.out.println();
OBJETOS Y CONSTRUCTORES
CREANDO CONSTRUCTORES EN JAVA.
Los constructores de una clase son fragmentos de código que sirven para inicializar un objeto a un estado determinado. Una clase puede carecer de constructor, pero esto no es lo más habitual. Normalmente todas nuestras clases llevarán constructor. En un constructor es frecuente usar un esquema de este tipo:
ublic MismoNombreQueLaClase (tipo parámetro1, tipo parámetro2 …, tipo parámetro n ) {
campo1 = valor o parámetro;
campo2 = valor o parámetro;
.
.
.
campo n = valor o parámetro;
}
Los constructores tienen el mismo nombre que la clase en la que son definidos y nunca tienen tipo de retorno, ni especificado ni void. Tenemos aquí un aspecto que nos permite diferenciar constructores de métodos: un constructor nunca tiene tipo de retorno mientras que un método siempre lo tiene. Es recomendable que en un constructor se inicialicen todos los atributos de la clase aunque su valor vaya a ser nulo o vacío. Si un atributo se quiere inicializar a cero (valores numéricos) siempre lo declararemos específicamente: nombreAtributo = 0;. Si un atributo se quiere inicializar a contenido nulo (atributos que son objetos) siempre lo declararemos específicamente: nombreAtributo = null;. Si un atributo tipo texto se quiere inicializar vacío siempre lo declararemos específicamente: nombreAtributo = “”;. El motivo para actuar de esta manera es que declarando los atributos como nulos o vacíos, dejamos claro que esa es nuestra decisión como programadores. Si dejamos de incluir uno o varios campos en el constructor puede quedar la duda de si hemos olvidado inicializar ese campo o inducir a pensar que trabajamos con malas prácticas de programación.
La inicialización de campos y variables es un proceso muy importante. Su mala definición es fuente de problemas en el desarrollo de programas. Como regla de buena programación, cuando crees campos o variables, procede de forma inmediata a definir su inicialización.
Un constructor puede:
a) Carecer de parámetros: que no sea necesario pasarle un parámetro o varios al objeto para inicializarse. Un constructor sin parámetros se denomina “constructor general”.
b) Carecer de contenido. Por ejemplo, public Taxi () { } podría ser un constructor, vacío. En general un constructor no estará vacío, pero en algunos casos particulares puede estarlo. Si el constructor carece de contenido los campos se inicializan con valor nulo o, si son tipos definidos en otra clase, como se haya definido en el constructor de la otra clase. Excepto en casos controlados, evitaremos que existan constructores vacíos.
Si un constructor tiene parámetros, el funcionamiento es análogo al que ya hemos visto para métodos. Cuando vayamos a crear el objeto con BlueJ, se nos pedirá además del nombre que va a tener el objeto, el valor o contenido de los parámetros requeridos. Un parámetro con frecuencia sirve para inicializar el objeto como hemos visto, y en ese caso el objeto tendrá el valor pasado como parámetro como atributo “para siempre”, a no ser que lo cambiemos por otra vía como puede ser un método modificador del atributo. No obstante, en algunos casos los parámetros que recibe un constructor no se incorporarán directamente como atributos del objeto sino que servirán para realizar operaciones de diversa índole. Escribe y compila el siguiente código:
public class Taxi { //El nombre de la clase
String ciudad; //Ciudad de cada objeto taxi
String matricula; //Matrícula de cada objeto taxi
String distrito; //Distrito asignado a cada objeto taxi
int tipoMotor; //Tipo de motor asignado a cada objeto taxi. 0 = desconocido, 1 = gasolina, 2 = diesel
//Constructor: cuando se cree un objeto taxi se ejecutará el código que incluyamos en el constructor
public Taxi (String valorMatricula, String valorDistrito, int valorTipoMotor) {
ciudad = "México D.F.";
matricula = valorMatricula;
distrito = valorDistrito;
tipoMotor = valorTipoMotor;
} //Cierre del constructor
//Método para obtener la matrícula del objeto taxi
public String getMatricula () { return matricula; } //Cierre del método
//Método para obtener el distrito del objeto taxi
public String getDistrito () { return distrito; } //Cierre del método
//Método para obtener el tipo de motor del objeto taxi
public int getTipoMotor () { return tipoMotor; } //Cierre del método
} //Cierre de la clase
No hay comentarios:
Publicar un comentario