El documento explica cómo dividir un programa grande en métodos más pequeños y manejables. Un método se define indicando su tipo de valor de retorno, nombre, lista de parámetros y bloque de código. Los métodos permiten evitar la repetición de código y estructurar un programa de manera modular. Se provee un ejemplo de clase con diferentes métodos que ilustra conceptos como invocación de métodos, paso de parámetros, variables locales y retorno de valores.

1. Métodos en
Java

2. Métodos
La mejor forma de
crear y mantener un
programa grande, es
construirlo a partir de
piezas más pequeñas o
módulos.
Cada uno de los cuales
es más manejable que
el programa en su
totalidad.

3. Los métodos(subprogramas em
Algoritmos) también son
utlizados para evitar la repetición
de código en un programa al
poder ejecutarlo desde varios
puntos de un programa con sólo
invocarlo.
Métodos

4. Esta técnica de descomposición se
denomina Divide y vencerás.
Los módulos en Java se denominan
métodos.
Un método se invoca ,es decir, se le pide
realizar su tarea designada con una llamada
de método.
Métodos

5. La llamada a métodos especifica el nombre del
método y proporciona la información (en forma
de argumentos) cuando el método lo necesite
para hacer su trabajo.
Métodos
El formato de una definición de método es:
tipo-de-valor-devuelto nombredelmétodo(lista-param)
{
declaraciones y sentencias
}

6. Casi todos los métodos tienen una lista de
parámetros; los parámetros de un método
también son variables locales.
Es recomendable limitar los métodos a
realizar una sola tarea bien definida y el
nombre del método debe expresar
efectivamente dicha tarea.
Métodos

7. El nombre es cualquier identificador válido.
El tipo-de-valor-devuelto es el tipo de dato
del resultado, que el método devuelve al
invocador.
El tipo-de-valor-devuelto void indica que el
método no devuelve ningún valor.
Métodos

8. Omitir el tipo-de-valor-devuelto en
una definición de método causa un error
de sintaxis.
Olvidar devolver un valor desde un
método que se supone debe devolver un
valor es un error de sintaxis.
Métodos

9. Si se especifica un tipo-de-valor-devuelto
distinto de void el método debe contener
una sentencia return.
Devolver un valor de un método cuyo tipo
devuelto se ha declarado void causa un
error de sintaxis.
Métodos

10. Todas las variables declaradas en las
definiciones de los métodos son
variables locales; solo se conocen
en el método en el que se definen.
Métodos
static int sumarNum(int e)
{
e+=e;
System.out.println(+e);
return e; //Este método retorna un valor
}

11. La lista-de-parámetros es una lista separada
por comas que contiene las declaraciones de
los parámetros que el método recibe cuando
es invocado.
Si un método no recibe valores, se coloca un
juego de paréntesis vacío ( ) después del
nombre del método.
Métodos

12. Declarar parámetros para un método que
poseen el mismo tipo float x,y en lugar de
float x, float y producirá un error de
compilación porque se requiere un tipo para
cada parámetro.
Colocar punto y coma después del paréntesis
que encierra la lista de parámetros es un error
de sintaxis.
Métodos
static void Calcular (float x,y);
Esta es una declaración de un método que contiene 2 errores.

13. Definir una variable local de un método igual que un
parámetro es un error de sintaxis.
Métodos
class CCmporvalor
{
public static void main(String args[])
{
int a=10;
System.out.println(a);
SumarNum(a);
System.out.println(a);
}
static int SumarNum(int e)
{
e+=e;
System.out.println(e);
return e; //Este método retorna un valor
}
}
Ejemplo:

14. Definir un método dentro de otro es un error
de sintaxis.
Existen tres formas de devolver el control al
punto en el que se invocó un método:
a) Si el método no devuelve un resultado el control se
devuelve cuando se llega a la llave derecha que
termina el método.
b) Al ejecutarse la sentencia return también, si el
método NO devuelve ningún resultado.
c) return expresión;
Métodos

15. Ejemplo

16. Entrada: v1,v2,v3 :numéricos
Inicio Programa Principal
V1,v2,v3,promn,mayor:numéricos
Procesar IntroDatos //Llamada a un subprograma tipo procedimiento
promn Procesar Calprom //Llamada a un subprograma tipo función
Procesar Imprime(promn)
Mostrar (“El mayor es “ mayor Procesar Max)
Terminar Programa Principal

17. class CPrueba //Clase (Programa)
{
static int v1,v2,v3;//Números enteros declarados en forma Global
public static void main (String args[ ]) //Método principal
{
float prom;
IntroDatos(); //Llamada a un método que no devuelve nada
prom=CalcProm(); //Llamada a un método tipo función
Imprime(prom); //Llamada a un método con pase de parámetros
System.out.println("El mayor: "+ Max( ));
}

18. Inicio IntroDatos
Mostrar (“Introduce el primer valor v1”)
Leer v1
Mostrar (“Introduce el segundo valor v2”)
Leer v2
Mostrar (“Introduce el tercer valor v3”)
Leer v3
Regresar

19. static void IntroDatos() //Método que no devuelve ni recibe nada
{
System.out.println("introduce el valor V1: ");
v1=CTeclado.ReadInt( );
System.out.println("introduce el valor V2: ");
v2=CTeclado.ReadInt( );
System.out.println("introduce el valor V3: ");
v3=CTeclado.ReadInt( );
}

20. Inicio Calcprom
aux: numérico
aux (v1+v2+v3)/3
Retornar aux
Inicio Imprime
valor:numérico
Mostrar (“Promedio”)
Mostrar (valor)
Regresar

21. static float CalcProm( ) //Método que devuelve un valor
{
float aux;
aux=(v1+v2+v3)/3; //V1,V2,V3 variables globales
return aux; // Valor que retorna el método
}
static void Imprime(float valor)//Observe el cambio de nombre
{
System.out.print("Promedio: ");
System.out.println(valor);
}

22. Inicio Max
aux:numérico
aux 0
Si ((v1>=v2)and (v1>=v3)) entonces
Auxv1
Si ((v2>=v1)and(v2>=v3))entonces
Auxv2
Si ((v3>=v1)and(v3>=v2))entonces
Auxv3
Retornar aux.

23. static int Max() // Método que retorna un valor
{
int aux=0;
if((v1>=v2)&&(v1>=v3))
{
aux=v1;
}
if((v2>=v1)&&(v2>=v3))
{
aux=v2;
}
if((v3>=v1)&&(v3>=v2))
{
aux=v3;
}
return aux;
}
}// fin de clase
//V1,V2,V3 variables globales

24. Métodos de la Clase Math

25.  Referencia Bibliográfica
medusa.unimet.edu.ve/programacion/bppr11/.../claseMetodos.ppt

26.  Desarrolle la calculadora utilizando metodos.