Método (Method)

Un método es un bloque de código con nombre. Puedes ejecutar este bloque llamando al nombre del método desde cualquier otra parte del programa, enviar datos al método y recibir los valores que este devuelve.

Estructura de un método

Como comentamos antes, un método es un miembro función de una clase.

Un método es básicamente una función. Recibe el nombre de «método» cuando la función pertenece a una clase. En el lenguaje C, todas estas construcciones se llaman simplemente funciones.

Cada método se divide en dos partes fundamentales: cabecera del método (declaración del método) y cuerpo del método.

1. Cabecera del método: Define todas las características del método y contiene esta información:
   • Si el método devuelve un valor; en caso afirmativo, hay que especificar el tipo de retorno
   • El nombre del método
   • Los tipos de datos que se pueden enviar y recibir, además de las reglas de tratamiento de datos
2. Cuerpo del método: Formado por una secuencia de sentencias ejecutables. La ejecución comienza en la primera sentencia del cuerpo y se va ejecutando línea por línea en orden.

Veamos un ejemplo

    string Introduce(string name,int age)
    {
        string words = $"hello my name is {name},i'm {age} years old";
        Console.WriteLine(words);
        return words;
    }Lenguaje del código: C# (cs)

Cabecera del método: string Introduce(string name,int age)

• string : Tipo de retorno, cadena de texto
• Introduce: Nombre del método
• (string name,int age): Lista de parámetros. Estas dos entradas actúan como variables que reciben el nombre y la edad externos, y se pueden usar dentro del cuerpo del método.

¿Cómo invocamos este método?

Este método pertenece a la clase Program y comparte clase con el método Main. Sin embargo, Main es un método estático. Los métodos estáticos no pueden llamar directamente a métodos no estáticos. Para usar Introduce, debes crear primero una instancia de Program y llamar al método mediante esa instancia.

class Program
{
    static void Main()
    {
        Program program = new Program();
        program.Introduce("John", 30);
    }

    string Introduce(string name,int age)
    {
        string words = $"hello my name is {name},i'm {age} years old";
        Console.WriteLine(words);
        return words;
    }
}Lenguaje del código: C# (cs)

Si lo llamas directamente como se muestra abajo, se producirá un error de compilación

La forma correcta es crear una instancia de Program con new dentro de Main y llamar a Introduce desde esa instancia

Program program = new Program();//√
program.Introduce("John", 30);Lenguaje del código: C# (cs)

---

Cuerpo del método

El cuerpo de un método puede contener cero o varias sentencias ejecutables.

El cuerpo del método es un bloque de código (conjunto de sentencias entre llaves). Dentro de un bloque de código podemos incluir estos elementos:

• Variables locales
• Estructuras de control de flujo (bucles, bifurcaciones, etc.)
• Llamadas a otros métodos
• Subbloques de código anidados
• Funciones locales (submétodos definidos dentro de un método) [lo veremos más adelante]

class Program
{
    static void Main()
    {
        int age = 3; // Variable local, valor inicial 3
        while (age > 0) // Estructura de control
        {
            --age;
            Introduce("Tom", age); // Llamada a método
        }

        {
            //Subbloque de código anidado
        }
    }

    static string Introduce(string name,int age)
    {
        string words = $"hello my name is {name},i'm {age} years old";
        Console.WriteLine(words);
        return words;
    }
}
Lenguaje del código: JavaScript (javascript)

En el código anterior añadimos la palabra reservada static a Introduce para convertirlo en método estático. De este modo se puede invocar directamente desde Main sin necesidad de crear una instancia.

---

Variables locales (Local Variables)

Al igual que los campos de instancia vistos anteriormente, las variables locales sirven para guardar datos. Los campos de instancia suelen conservar el estado de un objeto, mientras que las variables locales solo almacenan datos temporales para cálculos puntuales.

Cuando finaliza la ejecución del método que contiene variables locales, estas se eliminan de la pila. Las variables de tipo valor se destruyen inmediatamente; las de tipo referencia serán eliminadas por el recolector de basura en algún momento posterior.

1. Sintaxis de declaración de variables locales

Tipo NombreVariable = ValorInicial;

• NombreVariable: Identificador definido por el usuario
• = ValorInicial: Inicializador opcional para asignar un valor inicial a la variable

2. Reglas fundamentales de las variables locales

1. Ciclo de vida y ámbito: Solo existen dentro del bloque donde se declaran y en todos los subbloques anidados
   • La variable queda activa desde la línea donde se declara
   • Cuando el bloque de código termina su ejecución, la variable deja de ser válida y se destruye
2. Posición de declaración libre: Se pueden escribir en cualquier lugar del cuerpo del método, pero hay que declararlas antes de usarlas

    static void Main()
    {
        int age = 3; //Variable local
        Phone p = new Phone(); //Variable local de tipo personalizado

        {
            int one = 1; //Variable local perteneciente al subbloque
            bool two = false;
        }

        double d = 0;
    }Lenguaje del código: JavaScript (javascript)

Campos de instancia vs Variables locales

	Campo de instancia	Variable local
Ciclo de vida	Se crea al instanciar el objeto; se destruye cuando el objeto es inaccesible	Se activa en la línea de declaración; se destruye cuando finaliza el bloque al que pertenece
Inicialización por defecto	El compilador asigna automáticamente el valor por defecto del tipo	Sin inicialización automática; usarla sin asignar valor causa error de compilación
Almacenamiento en memoria	Reside totalmente en el montículo (Heap), tanto tipos valor como tipos referencia	Tipo valor: pila (Stack); Tipo referencia: referencia en pila, datos del objeto en montículo

Método (Method)