Jyoc java-cap05 metodos (funciones)

TemariodecursoJavaSE©IñakiMartín
5.- Métodos
TEMARIO DE CURSO
PROGRAMACIÓN JAVA SE
CAPÍTULO 5
MÉTODOS (FUNCIONES)
© Iñaki Martín
Este obra está bajo una licencia de Creative Commons Reconocimiento-NoComercial-SinObraDerivada 4.0 Internacional.

5.- Métodos 2Métodos: Resumen
métodos
métodos: reglas sobrecarga
๏ Un método sobrecargado:
• Debe cambiar el patrón de los parámetros que recibe.
• Puede si quiere cambiar el tipo de valor de resultado (retorno)
• Puede si quiere cambiar los modificadores de acceso sin
ninguna restricción
• Puede declara nuevas excepciones sin ninguna restricción (se
verán excepciones mas adelante)
• Se puede sobrecargar un método en la misma clase… ¡ o en
una subclase !
métodos: argumentos y parámetros
STATIC
• Es obligatorio si se llama a este método desde otro método que sea static
• Permite invocar al método sólo con el nombre de la clase
public static String leerCadena(String mensaje, int max) {
System.out.println(mensaje);
Scanner sc = new Scanner(System.in);
String texto = sc.nextLine();
return texto;
}
PARAMETROS
• Para cada uno se indica el tipo y una variable
donde se recibirá el argumento
• No tiene que llamarse igual que el argumento
• En la práctica, recibe la información por valor si el
tipo es primitivo, y por referencia si es un objeto (*)
(*) Siempre se recibe por valor, pero el valor en los objetos es la referencia del mismo, con lo que el paso con objetos es su referencia
MODIFICADOR DE ACCESO
• Public -Todo el mundo puede invocar el metodo
• Private -Solo invocable desde dentro de la clase
• Protected - Solo invocable desde la clase y sus herederas
• (sin nada) -Solo invocable desde dentro del paquete
TIPO RESULTADO (Retorno)
• Si no da ningun resultado, debe indicarse void
• Si no da un resultado, debe indicarse su tipo (int, String, Coche, double …)
• Si no da un resultado, debe incluir la instrucción return seguida del valor
El nombre del argumento y del parámetro NO tienen que ser iguales
public static void main(String[] args) {
int valor1 = 7;
int valor2 = 5;
sumar( valor1, valor2 );
}
public static sumar( int a,int b ) {
System.out.println(a + b);
}
argumentos
parámetros

5.- Métodos
๏ Si en un programa tenemos una serie de instrucciones que repiten varias veces, ¿por qué no agruparlas y
aislarlas, darles un nombre, y llamarlas para que se realicen cuando se las necesite, en vez de escribirlas
varias veces?
๏ O también, a veces, se desea dividir el código en trozos aislados, bien sea por separar e identificar mejor las
diferentes actividades, bien por que alguno de los trozos se desee individualizar para reutilizarse en el futuro.
๏ Esto se consigue mediante métodos. Un método en Java es un conjunto de instrucciones agrupadas,
dentro de una clase, a las que se da un nombre, y que realizan una determinada tarea. A este conjunto de
instrucciones se le puede llamar luego mediante su nombre.
๏ 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.
๏ Los métodos permiten, entre otras ventajas:
- separar las operaciones en módulos, aislados y más fáciles de comprender
- reutilizar código, pues si unas operativas son repetitivas, se repitan varias veces, puedo escribirlas solo
una vez y llamarlas tantas veces como quiera
Creando métodos (I)
Qué son los métodos
3

5.- Métodos
public static void main(String args[]){
Scanner entrada = new Scanner(System.in);
int a = 0, b = 0, c = 0, suma = 0;
do {
System.out.println("Dime un numero");
a = entrada.nextInt();
if (a < 0) {
System.out.println("no puede ser negativo");
}
} while (a < 0);
suma = suma + a;
do {
System.out.println("Dime un número");
b = entrada.nextInt();
if (b < 0) {
}
} while (b < 0);
suma = suma + b;
do {
c = entrada.nextInt();
if (c < 0) {
}
} while (c < 0);
suma = suma + c;
System.out.println("la suma de los tres es " + suma);
}
๏ Este ejemplo ilustra el caso de una serie de instrucciones que, inicialmente, se repiten varias veces, pero que se
han agrupado, y aislado en un método ( llamado pedir ) , al que se llama cuando se necesita
Creando métodos (I) 4
public static void main(String args[]){
int a = 0, b = 0, c = 0, suma = 0;
a= pedir();
suma = suma + a;
b= pedir();
suma = suma + b;
c= pedir();
suma = suma + c;
System.out.println("la suma de los tres es " + suma);
}
public static int pedir() {
Scanner entrada = new Scanner(System.in);
int x = 0;
do {
x = entrada.nextInt();
if (x < 0) {
}
} while (x < 0);
return x;
}

5.- Métodos
๏ Los métodos deben escribirse dentro de una clase. Su contenido esta delimitado entre llaves ( { } ), con lo que queda
claro dónde están sus límites.
๏ El subprograma main que se ha usado hasta ahora es, en realidad, un método, uno que escribimos dentro de nuestra
clase. Es un método especial por que es el punto de entrada al programa, eso es, cuando se manda ejecutar un
programa Java busca un método llamado main, y por ahí empieza a leer instrucciones.
๏ Nuestros métodos, pues, se escribirán dentro la clase, fuera del main, y al mismo nivel que éste.
๏ Al crear un método, éste es el formato que hay que usar (el contenido entre [ ] es opcional ):
‣ Los modificadores de un método son parecidos a los de las variables (public, private, protected). Se verán en
próximos capítulos
‣ El valor de resultado (retorno) se explica en las páginas siguientes. Como es opcional, imaginamos por ahora que no
se usa (bueno, hay que poner la palabra void, luego veremos por qué)
‣ Los parámetros se explican igualmente en las páginas siguientes, por ahora, lo dejamos vacío
๏ Este es nuestro primer método, consiste en algo muy simple (y sí, absurdo, pero más adelante veremos que no lo será
tanto…) que pide un texto por teclado y lo imprime en mayusculas:
Creando métodos (I)
void saludar() {
System.out.println("Dame tu nombre y yo te lo imprimo en mayusculas...");
System.out.println(texto.toUpperCase());
}
5
Crear métodos
// [modificadores] [valoresultado] nombredelmétodo ( [parámetros] ) {
// … (instrucciones del método)
// }

5.- Métodos
๏ Desde un método main, u cualquier otro método, se puede llamar al método creado simplemente con el nombre
y los parentesis (en nuestro caso, aun estarán vacíos).
๏ Leer atentamente este ejemplo, ejecutarlo y evaluar los resultados:
๏ Por supuesto, dentro de un método, se puede llamar a otro método, y dentro de este a otro…
Creando métodos (III)
Llamando a métodos creados
public class Inicio {
System.out.println("Primera linea del programa");
System.out.println("Estas lineas se ejecutan antes de llamar al método");
saludar();
System.out.println("Estas lineas se ejecutan despues de llamar al método");
System.out.println("Ultima linea del programa");
}
public static void saludar() {
System.out.println("-- Esta es la primera linea del método que se ejecuta");
System.out.println("Dame tu nombre y yo te lo imprimo en mayusculas...");
System.out.println(texto.toUpperCase());
System.out.println("-- Esta es la ultima linea del método que se ejecuta");
}
}
saludar();
6

5.- Métodos
๏ A los métodos, además de decirles "Haz lo que dice aquí ", se les puede decir también
"Haz lo que dice aquí, pero cuidado que además te paso esta información por si la quieres usar”. Esto es
lo que se llama parámetros de entrada
"Haz lo que dice aquí, pero cuidado que cuando acabes, me voy a quedar esperando que me des un
resultado, alguna información a mi”. Esto es el llamado valor de resultado (o de retorno), y se dice que el
método da como resultado un valor
๏ Se pueden combinar ambos casos, de modo que un método puede "recibir información adicional
(parámetros) para usarla si lo desea, y a la vez, dar como resultado un valor al sitio desde donde se le
llamó inicialmente"
Creando métodos (IV)
Parámetros y valor de resultado (retorno)
Se envían datos para que el
método los use
El método puede dar como resultado
un valor que lo usamos para
almacenarlo o cualquier otro fin
int solucion = sumarNumeros(4,6);
7

5.- Métodos
๏ Cuando un método necesita infomación, se le puede enviar por medio de los parámetros de entrada.
๏ Al usar un método (con un objeto ya construido, por ejemplo) se le añade información dentro de los paréntesis
que hay detrás del nombre del método. Esta informacion la “recibe” el método en sus parámetros
๏ ¿Como se definen los parámetros? En el método, cuando se escribe en la clase se debe especificar (entre
los paréntesis) para cada parámetro:
✴ tipo de dato que se espera recibir en el futuro
✴ nombre interno con el que vamos a llamar a lo que venga
➡ Ejemplo:
๏ Se pueden poner varios parámetros separados por coma, y pueden ser de diferente tipo:
➡ Ejemplo:
๏ El tipo de dato puede ser un tipo primitivo, o una clase Java o propia (depende de lo que se desee recibir)
➡ Ejemplo:
Usando métodos con parámetros (I)
Métodos con parámetros
Crear método con parámetros
void mimetodo ( String unavariable){
...
}
void mimetodo ( String unavariable, Coche uncoche){
...
}
void mimetodo ( String unavariable, int otravar){
…
}
8

5.- Métodos
๏ Ejemplo: Imaginemos que al método que se vio antes que leia un String por teclado, le vamos a añadir que
antes de hacer esta petición, muestre un mensaje, pero no siempre el mismo, sino el que se le pase como
parámetro:
Usando métodos con parámetros (I)
// Método que recibe un string como parámetro, lo imprime y luego pide
// por teclado una cadena, que tambien imprime
public static void leerCadena(String mensaje) {
System.out.println(texto);
}
9
๏ Se denomina firma de un método a la composicion de:
‣ nombre del metodo
‣ tipo de los parámetros.
En el método anterior, la firma es pues
leerCadena(String mensaje)
๏ La firma de un método no incluye, por lo tanto, ni el valor de resultado
(retorno) ni los modificadores

5.- Métodos
๏ A la hora de llamar a un método con parámetros, se invoca a su nombre, y entre paréntesis, se le
envian los valores que correspondan con los parámetros esperados. A estos valores se les llama
argumentos
๏ Aqui NO se tiene que indicar el tipo de dato enviado (el propio dato ya es de algun tipo…). El tipo de
dato solo se indica cuando se fabrica el método, de modo que asi decide qué tipo de dato es el que
espera recibir (tambien afecta al principio de sobrecarga, pero eso se verá más adelante)
Usando métodos con parámetros (II)
Invocar (llamar) a método con parámetros
10
// Llamada al método
sumar( 3 , 4 );
}
// Declaración del método
public static void sumar ( int a,int b ) {
System.out.println(a+b);
}
}
argumentos
parámetros
๏ No tienen nada que ver la variable con la que se
llama a un método (argumento), con la variable
que recibe el valor del método (parámetro),
pueden llamarse igual o no, no tiene importancia, son
variables diferentes.
El argumento le pasa su valor a la variable parámetro,
y ésta se usa dentro del método
A menudo se usan indistintamente las palabras parámetros y argumentos, deberian distinguirse como se ha explicado. Tambien se
llaman “parametros actuales” a los argumentos, y “parametros formales” a los parámetros. Por no complicar mucho al alumno, se
puede usar en estos apunte, sobre todo en los primeros capítulos, el término parámetro para ambos elementos
Es como si dentro del método, al principio, estuvieran las lineas
a = valor1;
b = valor2;
int valor1 = 7;
int valor2 = 5;
sumar( valor1, valor2 );
}
public static sumar( int a,int b ) {
System.out.println(a + b);
}
argumentos
parámetros

5.- Métodos
๏ Cuando se usa un método, como argumento, se le puede pasar un valor explícito (un número, una
cadena) o una variable (que contiene el valor a pasar).
Usando métodos con parámetros (II)
// opcion 1, pasamos al método una variable (objeto) de tipo String
String unacadena = "Introduzca un texto, por favor:";
leerCadena(unacadena);
// opcion 2, pasamos al método un String directamente
leerCadena("Introduzca otro texto, por favor:");
}
// Método que recibe un string como parámetro (o argumento), lo imprime y luego pide
// por teclado una cadena, que tambien imprime
public static void leerCadena(String mensaje) {
}
}
11
CUIDADO
Si desde dentro de un método con el modificador static se llama a otro método, o se
usa un atributo de clase, el método y el atributo llamados también han de tener el
modificador static (se explicará el por qué más adelante)
Esto ocurre por tanto con todos los métodos static, y recordar que main es uno de
ellos, así que todo método invocado desde main ha de ser static

5.- Métodos
๏ Vamos a coger el método anterior y vamos a hacer que reciba dos parámetros, además del mensaje, un int
que usaremos para validar que la cadena que se lea por teclado no sea muy larga (el int será el número
maximo de caracteres que se puedan leer). El nuevo método se llamara leerCadenaAcotada:
๏ En este caso, cuando se llama desde el programa principal con
el programa principal dice: “Llamar a un método llamado leerCadenaAcotada y ADEMÁS, le envió esta
información: “Introduzca un texto” y 20” (UN STRING, Y UN INT)
y luego buscará si realmente existe un método que se llame así y que:
• tenga esos parámetros, solo dos, y
• con esos tipos de datos, y
• en ese orden.
๏ Esto es una llamada correcta:
๏ Estas, son incorrectas
Usando métodos con parámetros (III)
Métodos con más de un parámetro
leerCadenaAcotada("Introduzca un texto", 20);
public static void leerCadenaAcotada(String mensaje, int max) {
if (texto.length() > max) {
System.out.println("Cadena introducida muy larga, maximo : "+ max);
} else {
}
}
leerCadenaAcotada("Introduzca un texto", 20);
leerCadenaAcotada(20, “Introduzca un texto");
leerCadenaAcotada("Introduzca un texto", 20, 1000);
12
Los parámetros siempre en el orden correcto, con
el tipo correcto, y el número correcto de ellos

5.- Métodos
๏ Cambiamos el método de leer, ahora nos da como resultado la cadena que ha leido (no valida ya el tamaño):
Usando métodos con resultado (I)
Métodos con valor de resultado
// Método que recibe un string como parámetro, lo imprime y luego pide
// por teclado una cadena, que da como resultado
public static String leerCadena(String mensaje) {
return texto;
}
13
✴ En la definición del método, poner delante del nombre del método
un indicador de cual es el tipo de dato que va a tener el valor de
resultado.
✴ Dentro de las instrucciones del método debe haber una nueva
instrucción que sea return valorderesultado
donde return es una palabra clave de java, y valorderesultado, lo
que queremos dar como resultado al programa que ha llamado al
método.
public int sumar(int a,int b){
int resultado = a+b;
return resultado;
}
๏ Si el método no da como resultado nada, se debe incluir la palabra clave void ... que significa “no da ningún
resultado” (es lo que hacíamos en nuestros métodos anteriores, no daban resultado alguno).
CREAR el método con valor de resultado
๏ Para definir un valor de resultado (retorno) en un método, hay que hacer dos cosas:

5.- Métodos
๏ Para llamar a un método que tiene un valor de resultado, hay que considerar que el método, tras ejecutarse,
se convierte en una informacion, la que el método da como respuesta.
๏ Es como cualquier operacion, que tambien da una respuesta. Si yo escribo
el programa dirá “vale, ok, son 12…. ¿ que hago con ese resultado, con ese 12 ?
Evidentemente, lo que solemos hacer es guardar la respuesta en alguna variable, imprimir la respuesta….
๏ De igual modo, un método que tiene un valor de resultado, al acabar, da como respuesta una informacion
(la que hay tras la instrucción return antes vista), retorna un valor, por lo que hay que hacer algo con ella.
๏ Algunos ejemplos de como llamar al método leerCadena desde el programa main:
Usando métodos con resultado (I)
String cadenaleida = leerCadena("Introduzca un texto, por favor:") ;
System.out.println("La cadena leida es : " + cadenaleida) ;
14
LLAMAR a ejecución un método con valor de resultado
int numero = 4 + 8;
System.out.println(4 + 8);
4 + 8
System.out.println("La cadena leida es : " + leerCadena("Introduzca un texto, por favor:") );
Temas avanzados Creacion de métodos propios como utilidades
Consejo: Dado el (aparentemente) errático funcionamiento de Scanner, sería una buena práctica hacer métodos como estos para leer por
teclado con Scanner (un método para leer un String, otro para un int, y más si hace falta). Como el objeto de Scanner creado en el método se
destruye al salir del método, evitamos los problemas de lecturas seguidas como los comentados anteriormente.
Llamada al método que devuelve un
valor y lo guardo en una variable
Llamada al método que devuelve un
valor y lo imprimo

5.- Métodos
๏ Si un método ha de dar como resultado un valor, y no tiene orden return, falla. También falla si el compilador
prevé que puede que no se llegue nunca a una orden return. Por ejemplo, este método falla al compilar:
¿Por que? por que si se llama al método y se le pasa un parámetro que no sea “Amarillo”, no se cumple la
condición del if, con lo que el return no se ejecuta.
๏ Un array se comporta como cualquier tipo de dato, por lo tanto
puede ser usado como argumento o como valor de resultado
• Como argumento se le pasa el nombre del array
• como valor de resultado, se define el tipo del array
Recordar que en un array de int llamado X,
• X es el nombre del array
• int[] es el tipo de la variable X
• X[0] es un elemento del array
๏ El valor de resultado puede ser un tipo objeto.
En tal caso, null también es válido como valor de resultado
๏ Si el valor de resultado es tipo objeto, se puede dar como resultado cualquier objeto que se puede convertir implícitamente en ese tipo (cosas que
se analizarán al ver Herencia e Interfaces, es válido para ambos)
Usando métodos con resultado (II)
Consideraciones a los valores de resultado y parámetros de un método
public String notas () {
return null;
}
public int[] nuevoarray( int[] arr ) {
int[] otroarr = new int [1];
otroarr[0]=arr.length;
return otroarr;
}
// Llamada al método desde fuera
int[] unarr = new int [2];
int[] otroarra = nuevoarray(unarra);
boolean ponerColor (String parámetroColor) {
boolean respuesta;
if (parámetroColor.equals ("Amarillo")) {
respuesta = true;
return respuesta;
}
}
public List ordenar (List as){ return new ArrayList(); }
15
El valor devuelto por el método
debe ser el array (su nombre)
Al definir el método, el tipo de dato que
devuelve es el tipo del array ( int[] )
El parámetro del método debe indicar que se recibe un
valor de tipo array (int [] ) y el nombre con el que se
usará dentro del método (arr)

5.- Métodos 16
๏ Esta técnica permite que existan varios métodos con el mismo nombre, normalmente, bien por que:
‣ se quiere que actúen de modo diferente según los parámetros que lleven
‣ se quiere que hagan lo mismo, pero que funcionen con cualquier tipo de parámetro.
Esto se ve en muchísimos métodos de Java base, cuando un método hace lo mismo independientemente de que el parámetro que se le pase
sea String, int, boolean u otro tipo. Un ejemplo claro es el método archiusado hasta ahora, println() (con System.out). Este método funciona tanto
si se le pasa un String, como un int, como un float o un boolean, y esto es así porque realmente existen definidos (ya se verá dónde) los
métodos:
Así, si se llama a println con un argumento String, se ejecuta el primero de los métodos, si se llama con un argumento int, se ejecuta el
segundo, si se llama con un boolean, se ejecuta el tercero… y todos ellos tienen la misma funcionalidad.
Sobrecarga
Sobrecarga
println(String k) {…}
println(int k) {…}
println(boolean k) {…}
……
๏ Para poder sobrecargar un método han de tener diferente firma, esto es, deben ser diferentes el número, o el
tipo, o el orden de los parámetros.
๏ El tipo del resultado de los métodos no influye en la sobrecarga, puede ser el mismo o distinto, es indiferente.
๏ Ejemplos: Estas declaraciones de métodos si pueden coexistir en la misma clase:
pero este no puede añadirse
Esto es fácil de entender si pensamos como piensa el traductor de Java a la hora de ejecutar un programa. Si queremos tener en
nuestra clase dos métodos con la misma firma, cuando luego desde el main u otro método quisieramos llamar a uno de estos métodos,
el compilador de Java buscaría el mñetodo y encontraría dos iguales .... ¿A cuál de ellos habría de invocar? No podría saberlo.…
public int test (int a) { … }
public String test () { … }
public int test (String s) { … }
public int test (int z) { … }
En java no existe sobrecarga de operadores, solo
una excepción, y está ya implementada por el
compilador, que es “+”, que vale para sumar
números y para concatenar cadenas.

5.- Métodos
๏ Hemos visto que un método puede recibir varios parámetros, pero siempre un numero fijo de ellos.
๏ Si el número de parámetros no es conocido, se puede pasar un array (o colección) como parámetro, como en este ejemplo:
y llamar así al método:
๏ Pero desde Java SE 5.0 se permite el uso de varargs, argumentos variables, de este modo (con el mismo ejemplo anterior);
๏ Parece que no simplifica mucho, pero sí se simplifica en la llamada al método, evitándonos crear arrays o colecciones;
๏ Se puede usar varargs junto con otros parámetros, aunque con ciertas limitaciones: podemos declarar varios
parámetros simples pero sólo podemos declarar un vararg (por método, claro) y además el vararg debe ser el último de
los parámetros:
Parámetros variables (var-args) (I)Temas avanzados
Parámetros Variables (VarArgs) (I)
public String concatenar(String [] cadenas) {
String res = "";
for (int i=0; i< cadenas.length ; i++) {
res = res + cadenas [i];
}
return res;
}
String sol = concatenar("Lunes","Miercoles","Viernes");
public String concatenar(String ... cadenas) {
String res = "";
for (int i=0; i< cadenas.length ; i++) {
}
return res;
}
String [] pruebas = {"Lunes","Miercoles","Viernes"};
String sol = concatenar(pruebas);
public String concatenarHasta(int cantidad, String ... cadenas) {
String res = "";
for (int i=0; i< cantidad ; i++) {
}
return res;
}
17

5.- Métodos
๏ A la hora de usar parámetros variables, hemos de tener en cuenta que no se pueden realizar ciertas acciones
๏ Ya sabemos que no se puede sobrecargar métodos si tienen la misma firma, y en esto hay que tener cuidado con
parámetros variables. Esto NO compila, pues los dos métodos están esperando recibir lo mismo, una lista variable de Strings
๏ Esto es también erróneo, pues nuevamente los dos métodos están esperando recibir lo mismo, una lista variable de Strings
๏ Constatar que se puede hacer un método que reciba un numero indeterminado… de arrays (u otra colección) :
๏ Eso si, dentro de una declaración SOLO puede haber un parámetro var-args… :
๏ Como curiosidad, con esta funcionalidad se puede cambiar la firma del famoso método main, pasando de
void main (String[] args)
a poder usarse sin el menor problema como
void main (String … args)
Parámetros variables (var-args) (II)Temas avanzados
Parámetros Variables (VarArgs) (II)
void acumular(String [] ... grupos ) {
// lineas de código
}
void concatenar(String... variosStrings) {
}
void concatenar(String unstring, String... variosStrings) {
}
void concatenar(String... variosStrings) {
}
void concatenar(String [] variosStrings) {
}
18

Jyoc java-cap05 metodos (funciones)

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (19)

Similar a Jyoc java-cap05 metodos (funciones)

Similar a Jyoc java-cap05 metodos (funciones) (20)

Más de Jyoc X

Más de Jyoc X (14)

Último

Último (20)

Jyoc java-cap05 metodos (funciones)