3. INTRODUCCIÓN A LOS MÉTODOS
Definición de métodos
Main es un método
Para definir métodos propios se usa la misma
sintaxis
using System;
using System;
class ExampleClass
class ExampleClass
{{
static void ExampleMethod( )
static void ExampleMethod( )
{
{
Console.WriteLine("ExampleMethod");
Console.WriteLine("ExampleMethod");
}
}
static void Main( )
static void Main( )
{
{
// ...
// ...
}
}
}}
4. Tipos Métodos
Procedimiento Void : Un procedimiento debe
tener un nombre. Este nombre será utilizado para
invocarle. No retorna datos. Ej: Void Hola Mundo()
Funciones: Si un método devuelve valor, se
llama función sino retorna valor se le llama
procedimiento.
Procedimientos de eventos : 2 elementos
distinguen un procedimiento clásico a un de
eventos:
La llamada al procedimiento de eventos se realiza
automáticamente.
El nombre del procedimiento de eventos es la
concatenación del nombre del evento para la cual se
gestiona el evento: Ej: button_click()
5. Llamadas a métodos
Una vez definido un método, se puede:
Llamar a un método desde dentro de la misma
clase
Se usa el nombre del método seguido de una
lista de parámetros entre paréntesis
Llamar a un método que está en una clase
diferente
Hay que indicar al compilador cuál es la clase
que contiene el método que se desea llamar
El método llamado se debe declarar con la
palabra clave public
Usar llamadas anidadas
Unos métodos pueden hacer llamadas a
otros, que a su vez pueden llamar a otros
métodos, y así sucesivamente.
6. Uso de la instrucción return
Return inmediato
Return con una instrucción condicional
static void ExampleMethod( )
static void ExampleMethod( )
{
{
int numBeans;
int numBeans;
//...
//...
Console.WriteLine("Hello");
Console.WriteLine("Hello");
if (numBeans < 10)
if (numBeans < 10)
return;
return;
Console.WriteLine("World");
Console.WriteLine("World");
}
}
7. Uso de variables locales
Variables locales
Se crean cuando comienza el método
Son privadas para el método
Se destruyen a la salida
Variables compartidas
Para compartir se utilizan variables de clase
Conflictos de ámbito
El compilador no avisa si hay conflictos entre
nombres locales y de clase
8. Devolución de valores
El método se debe declarar con un tipo
que no sea void
Se añade una instrucción return con una
expresión
Fija el valor de retorno
Se devuelve al llamador
Los métodos que no son void deben
devolver un valor
static int DosMasDos( )
static int DosMasDos( ) {in t x ;
i nt x;
{
int a,b;
int a,b; x = DosMasDos( );
x = DosMasDos( );
a = 2;
a = 2; Console.WriteLine(x);
Console.WriteLine(x);
b = 2;
b = 2;
return a + b;
return a + b;
}
}
9. UTILIZACIÓN DE PARAMETROS
Declaración y llamadas a
parámetros
Declaración de parámetros
Se ponen entre paréntesis después del nombre
del método
Se definen el tipo y el nombre de cada parámetro
Llamadas a métodos con parámetros
Un valor para cada parámetro
st a t i c v o i d
tatic void MethodWithParameters(int n, string y)
MethodWithParameters(int n, string y
{ ... }
... }
Me t h o d W i t h P a r a m e t e r s ( 2 , " H o l a , m u n d o " ) ;
ethodWithParameters(2, "Hola, mundo");
10. Mecanismos de paso de
parámetros
Tres maneras de pasar parámetros
entrada Paso por valor
entrada Paso por valor
entrada
entrada Paso por referencia
Paso por referencia
salida
salida
salida Parámetros de salida
salida Parámetros de salida
11. Paso por valor
Mecanismo predeterminado para el paso de
parámetros:
Se copia el valor del parámetro
Se puede cambiar la variable dentro del método
No afecta al valor fuera del método
El parámetro debe ser de un tipo igual o compatible
at i c v o i d S u m a U n o ( i n t x )
tic void SumaUno(int x)
x++; // Incrementar x
x++; // Incrementar x
at i c v o i d M a i n ( )
tic void Main( )
int k = 6;
int k = 6;
SumaUno(k);
SumaUno(k);
Console.WriteLine(k); // Muestra el valor 6, no
Console.WriteLine(k); // Muestra el valor 6, n
12. Paso por referencia
¿Qué son los parámetros referencia?
Una referencia a una posición de memoria
Uso de parámetros referencia
Se usa la palabra clave ref en la declaración y
las llamadas al método
Los tipos y valores de variables deben coincidir
Los cambios hechos en el método afectan al
llamador
Hay que asignar un valor al parámetro antes de
la llamada al método
13. Parámetros de salida
¿Qué son los parámetros de salida?
Pasan valores hacia fuera, pero no
hacia dentro
Uso de parámetros de salida
Como ref , pero no se pasan valores al
método
Se usa la palabra clave out en la
static void OutDemo(out int p)
static void OutDemo(out int p)
{
{ declaración y las llamadas al método
// ...
// ...
}
}
int n;
int n;
OutDemo(out n);
OutDemo(out n);
14. Uso de listas de parámetros de
longitud variable
Se usa la palabra clave params
Se declara como tabla al final de la lista de
parámetros
Siempre paso por valor
static long AddList(params long[ ] v)
static long AddList(params long[ ] v)
{
{
long total, i;
long total, i;
for (i = 0, total = 0; i < v.Length; i++)
for (i = 0, total = 0; i < v.Length; i++)
total += v[i];
total += v[i];
return total;
return total;
}
}
static void Main( )
static void Main( )
{
{
long x = AddList(63,21,84);
long x = AddList(63,21,84);
}
}
15. Normas para el paso de
parámetros
Mecanismos
El paso por valor es el más habitual
El valor de retorno del método es útil para un
solo valor
ref y/o out son útiles para más de un valor de
retorno
ref sólo se usa si los datos se pasan en ambos
sentidos
Eficiencia
El paso por valor suele ser el más eficaz
16. Uso de métodos recursivos
Un método puede hacer una llamada a sí
mismo
Directamente
Indirectamente
Útil para resolver ciertos problemas
17. Declaración de métodos
sobrecargados
Métodos que comparten un nombre en una
clase
la s s O e r l odistinguen m p l e
a s s Ov eSe oa d i n g E x a examinando la lista de parámetros
v rl adingExample
static int Suma(int a, int b)
static int Suma(int a, int b)
{
{
return a + b;
return a + b;
}
}
static int Suma(int a, int b, int
static int Suma(int a, int b, int c)
c)
{
{
return a + b + c;
return a + b + c;
}
}
static void Main( )
static void Main( )
{
{
Console.WriteLine(Suma(1,2) +
Console.WriteLine(Suma(1,2) + Suma(1,2,3))
Suma(1,2,3))
}
}
18. Signaturas de métodos
Las signaturas de métodos deben
ser únicas dentro de una clase
Definición de signatura
Forman la definición
Forman la definición No afectan a la
No afectan a la
de la signatura
de la signatura signatura
signatura
Nombre del método
Nombre del método Nombre de parámetro
Nombre de parámetro
Tipo de parámetro
Tipo de parámetro Tipo de retorno de
Tipo de retorno de
método
método
Modificador
Modificador
19. Uso de métodos sobrecargados
Conviene usar métodos sobrecargados si:
Hay métodos similares que requieren
parámetros diferentes
Se quiere añadir funcionalidad al código
existente
No hay que abusar, ya que:
Son difíciles de depurar
Son difíciles de mantener
20. Ejercicios
1. Desarrolle un programa que calcule la fórmula de energía cinética. El
cálculo debe estar definido en una función que reciba los datos para el
cálculo y que retorne el resultado a una variable. Fórmula: Ec = 1 / 2
* M * V 2.
2. Desarrolle un programa que determine si un número es primo, el
calculo debe ser realizado en una función que recibe como parámetro
el numero a evaluar y retorno si es primo o no (verdadero o falso). Un
número es primo cuando solo es divisible entre él y la unidad. Ej.: 3, 5,
7, 11,17….
3. Desarrolle un programa que calcule en factorial de un numero. El
calculo debe ser realizado en una función que reciba como parámetro
el numero a factorizar.
4. Opcional: Desarrollar el programa de factorial pero con funciones
recursivas
