El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

Mètodes

Següent ►
►

Els mètodes són blocs de codi que realitzen una tasca específica i es poden reutilitzar en diferents parts del programa. En C#, els mètodes són essencials per a la modularitat i la reutilització del codi. En aquesta secció, aprendrem com definir i utilitzar mètodes, així com els diferents tipus de mètodes disponibles en C#.

Continguts

  1. Definició de Mètodes
  2. Paràmetres i Arguments
  3. Tipus de Retorn
  4. Mètodes Estàtics vs. Mètodes d'Instància
  5. Sobrecàrrega de Mètodes
  6. Exemples Pràctics
  7. Exercicis Pràctics

Definició de Mètodes

Un mètode en C# es defineix dins d'una classe. La sintaxi bàsica per definir un mètode és la següent:

public class MyClass
{
    public void MyMethod()
    {
        // Codi del mètode
    }
}

Explicació:

  • public: Modificador d'accés que indica que el mètode és accessible des de qualsevol part del programa.
  • void: Tipus de retorn del mètode. En aquest cas, void indica que el mètode no retorna cap valor.
  • MyMethod(): Nom del mètode seguit de parèntesis. Els parèntesis poden contenir paràmetres.

Paràmetres i Arguments

Els paràmetres són variables que es defineixen en la signatura del mètode i que reben valors quan el mètode és cridat. Els arguments són els valors que es passen als paràmetres quan es crida el mètode.

public class MyClass
{
    public void MyMethod(int param1, string param2)
    {
        // Utilitza param1 i param2 dins del mètode
    }
}

// Crida al mètode
MyClass obj = new MyClass();
obj.MyMethod(10, "Hola");

Explicació:

  • int param1, string param2: Paràmetres del mètode MyMethod.
  • obj.MyMethod(10, "Hola"): Crida al mètode amb els arguments 10 i "Hola".

Tipus de Retorn

Un mètode pot retornar un valor utilitzant la paraula clau return. El tipus de retorn es defineix abans del nom del mètode.

public class MyClass
{
    public int Sum(int a, int b)
    {
        return a + b;
    }
}

// Crida al mètode
MyClass obj = new MyClass();
int result = obj.Sum(5, 3); // result és 8

Explicació:

  • public int Sum(int a, int b): El mètode Sum retorna un valor de tipus int.
  • return a + b;: Retorna la suma de a i b.

Mètodes Estàtics vs. Mètodes d'Instància

Mètodes Estàtics

Els mètodes estàtics pertanyen a la classe en lloc de a una instància específica de la classe. Es criden utilitzant el nom de la classe.

public class MyClass
{
    public static void StaticMethod()
    {
        // Codi del mètode estàtic
    }
}

// Crida al mètode estàtic
MyClass.StaticMethod();

Mètodes d'Instància

Els mètodes d'instància requereixen una instància de la classe per ser cridats.

public class MyClass
{
    public void InstanceMethod()
    {
        // Codi del mètode d'instància
    }
}

// Crida al mètode d'instància
MyClass obj = new MyClass();
obj.InstanceMethod();

Sobrecàrrega de Mètodes

La sobrecàrrega de mètodes permet definir múltiples mètodes amb el mateix nom però amb diferents signatures (nombre o tipus de paràmetres).

public class MyClass
{
    public void Display(int a)
    {
        Console.WriteLine("Enter: " + a);
    }

    public void Display(string a)
    {
        Console.WriteLine("Enter: " + a);
    }
}

// Crida als mètodes sobrecarregats
MyClass obj = new MyClass();
obj.Display(10); // Crida a Display(int a)
obj.Display("Hola"); // Crida a Display(string a)

Exemples Pràctics

Exemple 1: Mètode que Calcula l'Àrea d'un Rectangle

public class Rectangle
{
    public int CalculateArea(int width, int height)
    {
        return width * height;
    }
}

// Crida al mètode
Rectangle rect = new Rectangle();
int area = rect.CalculateArea(5, 10);
Console.WriteLine("Àrea: " + area); // Àrea: 50

Exemple 2: Mètode Estàtic que Converteix Celsius a Fahrenheit

public class TemperatureConverter
{
    public static double CelsiusToFahrenheit(double celsius)
    {
        return (celsius * 9 / 5) + 32;
    }
}

// Crida al mètode estàtic
double fahrenheit = TemperatureConverter.CelsiusToFahrenheit(25);
Console.WriteLine("Fahrenheit: " + fahrenheit); // Fahrenheit: 77

Exercicis Pràctics

Exercici 1: Crear un Mètode per Calcular el Factorial d'un Nombre

Descripció: Escriu un mètode anomenat CalculateFactorial que prengui un enter com a paràmetre i retorni el factorial d'aquest nombre.

public class FactorialCalculator
{
    public int CalculateFactorial(int number)
    {
        // Implementació del mètode
    }
}

// Crida al mètode
FactorialCalculator calc = new FactorialCalculator();
int factorial = calc.CalculateFactorial(5);
Console.WriteLine("Factorial: " + factorial); // Factorial: 120

Solució:

public class FactorialCalculator
{
    public int CalculateFactorial(int number)
    {
        if (number <= 1)
            return 1;
        else
            return number * CalculateFactorial(number - 1);
    }
}

// Crida al mètode
FactorialCalculator calc = new FactorialCalculator();
int factorial = calc.CalculateFactorial(5);
Console.WriteLine("Factorial: " + factorial); // Factorial: 120

Exercici 2: Crear un Mètode Estàtic per Invertir una Cadena

Descripció: Escriu un mètode estàtic anomenat ReverseString que prengui una cadena com a paràmetre i retorni la cadena invertida.

public class StringManipulator
{
    public static string ReverseString(string input)
    {
        // Implementació del mètode
    }
}

// Crida al mètode estàtic
string reversed = StringManipulator.ReverseString("Hola");
Console.WriteLine("Cadena Invertida: " + reversed); // Cadena Invertida: aloH

Solució:

public class StringManipulator
{
    public static string ReverseString(string input)
    {
        char[] charArray = input.ToCharArray();
        Array.Reverse(charArray);
        return new string(charArray);
    }
}

// Crida al mètode estàtic
string reversed = StringManipulator.ReverseString("Hola");
Console.WriteLine("Cadena Invertida: " + reversed); // Cadena Invertida: aloH

Conclusió

En aquesta secció, hem après com definir i utilitzar mètodes en C#. Hem explorat la sintaxi bàsica, els paràmetres i arguments, els tipus de retorn, i la diferència entre mètodes estàtics i d'instància. També hem vist com sobrecarregar mètodes i hem treballat amb exemples pràctics i exercicis per reforçar els conceptes apresos. Amb aquests coneixements, estàs preparat per modularitzar i reutilitzar el teu codi de manera eficient en els teus projectes de C#.

◄ Anterior
◄
Següent ►
►
El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats