Metoder

“Do or do not, there is no try… but there are definitely methods!”

Welcome back, young Padawan! Efter att ha lärt dig om The Force of Data (variabler), är det dags att lära dig Jedi Arts - metoder. En metod är som en Force-power: en namngiven förmåga du kan använda om och om igen. Skillnaden är att metoder faktiskt fungerar konsekvent (till skillnad från Luke’s första försök med lightsaber-träning).

Vad är en metod? (Think Jedi Training Manual)

En metod är som ett detaljerat recept för att göra något specifikt, fast mycket mer pålitligt än C-3PO’s kulinariska databank. Precis som Yoda lärde Luke olika Force-tekniker, skapar du metoder för att lära datorn olika tricks.

En metod har fyra huvuddelar, som The Force has different aspects:

Åtkomstmodifierare (public) - Vem får använda din metod (hela galaxen eller bara du?)
Returtyp - Vad metoden ger tillbaka (som när Yoda lyfter X-wing:en ur träsket)
Metodnamn - Vad din metod heter (var beskrivande, inte som “DoStuff”)
Parametrar - Vad metoden behöver för att fungera (som ingredienser till blue milk)

Grundläggande metodstruktur (The Jedi Way)

public int CalculateRebelShips(int xWings, int yWings)    // <-- Metodhuvud (som Jedi robe)
{                                                        // <-- Början av metodkropp (som lightsaber hilt)
    int totalShips = xWings + yWings;                    // <-- Force calculations happening
    return totalShips;                                   // <-- The power returns (som Force lightning)
}                                                        // <-- Slut av metodkropp (mission complete)

Delarna förklarade (för dig som inte pratar Droid):

public = Som att broadcasta över rebel communications - alla kan höra
int = Metoden returnerar ett heltal (som antal överlevande rebels)
CalculateRebelShips = Metodens namn (tydligare än “Method66”)
(int xWings, int yWings) = Input-parametrarna (som pilotrapporter från olika squadrons)
return totalShips = Vad metoden skickar tillbaka (som slutrapporten till Mon Mothma)

Enkla exempel (From Padawan to Knight)

Metod som returnerar något (Som when Obi-Wan returns Luke’s lightsaber)

public int CalculateJediAge(int birthYear)
{
    int currentYear = 2024;                    // Assuming vi fortfarande använder Coruscant Standard Time
    int jediAge = currentYear - birthYear;
    return jediAge;                            // Returns the wisdom-to-age ratio
}

// Användning (praktisk Jedi application):
int lukesAge = CalculateJediAge(1995);         // Luke blir 29 (Perfect Jedi prime age)
Console.WriteLine("Luke är " + lukesAge + " år gammal och ready för adventure!");

Metod som bara gör något - void (Som when Obi-Wan becomes one with the Force)

public void DeliverJediWisdom(string padawanName)
{
    Console.WriteLine("Young " + padawanName + ", much to learn you still have.");
    Console.WriteLine("Patience, you must have my young padawan.");
    // Ingen return här - wisdom ges fritt, som Jedi way
}

// Användning:
DeliverJediWisdom("Luke");
// Skriver ut Yoda-style wisdom för Luke

void är som when en Jedi becomes one with the Force - de gör något viktigt men kommer inte tillbaka med fysiska saker. Perfect för actions som att visa meddelanden eller spara galaxen.

Praktiskt exempel (Real Galaxy Applications)

// Beräkna cost för Death Star construction (Ekonomisk planering for Imperial budget)
public double CalculateDeathStarCostWithInflation(double baseConstructionCost, double inflationRate)
{
    double inflationAmount = (baseConstructionCost * inflationRate) / 100;
    double totalCost = baseConstructionCost + inflationAmount;
    return totalCost;
}

// Användning (Emperor's financial planning):
double deathStarCost = CalculateDeathStarCostWithInflation(1000000000000, 15.5);
Console.WriteLine("Total Death Star cost: " + deathStarCost + " Imperial Credits");
Console.WriteLine("(Palpatine is not gonna be happy about this budget...)");

Metoder utan parametrar (Solo Flight Methods)

public string GetCurrentGalacticDate()
{
    // Assumming BBY/ABY dating system still works
    return "Current date: " + DateTime.Now.ToString("yyyy-MM-dd") + " ABY (After Battle of Yavin)";
}

// Användning:
string todaysDate = GetCurrentGalacticDate();
Console.WriteLine(todaysDate);
// Current date: 2024-08-31 ABY (After Battle of Yavin)

Ibland behöver din metod ingen input, som when Han Solo deciderar att göra Kessel Run solo. Den vet helt enkelt vad den ska göra.

Flera parametrar (Squad-based Operations)

public string CreateRebelProfile(string firstName, string lastName, string homeworld, int combatRating)
{
    string profile = firstName + " " + lastName + " från " + homeworld;
    profile = profile + " (Combat Rating: " + combatRating + "/10)";

    // Lägg till special rebel commentary
    if (combatRating >= 9)
    {
        profile = profile + " - Elite Rebel Fighter!";
    }
    else if (combatRating >= 7)
    {
        profile = profile + " - Solid Rebel Material";
    }
    else if (combatRating >= 5)
    {
        profile = profile + " - Still Learning the Ropes";
    }
    else
    {
        profile = profile + " - Maybe stick to maintenance work...";
    }

    return profile;
}

// Användning (Rebel recruitment):
string hanInfo = CreateRebelProfile("Han", "Solo", "Corellia", 10);
Console.WriteLine(hanInfo);
// Han Solo från Corellia (Combat Rating: 10/10) - Elite Rebel Fighter!

string jar_jarInfo = CreateRebelProfile("Jar Jar", "Binks", "Naboo", 2);
Console.WriteLine(jar_jarInfo);
// Jar Jar Binks från Naboo (Combat Rating: 2/10) - Maybe stick to maintenance work...

Varför använda metoder? (The Jedi Philosophy)

1. Undvik upprepning (Don’t be like Imperial bureaucracy)

Utan metoder (The Dark Side way - repetitive och ineffective):

// Calculating cost för varje Death Star individually (så inefficient!)
double deathStar1Cost = 1000000000000;
double deathStar1Tax = (deathStar1Cost * 15.5) / 100;
double deathStar1Total = deathStar1Cost + deathStar1Tax;

double deathStar2Cost = 2000000000000;  // Bigger och more expensive
double deathStar2Tax = (deathStar2Cost * 15.5) / 100;
double deathStar2Total = deathStar2Cost + deathStar2Tax;

// Detta är som att bygga samma Death Star två gånger... vilket de faktiskt gjorde

Med metod (The Jedi Way - efficient och reusable):

public double CalculateImperialProjectCost(double baseCost)
{
    double imperialTax = (baseCost * 15.5) / 100;    // Emperor's cut
    return baseCost + imperialTax;
}

// Användning (Much more efficient Imperial accounting):
double deathStar1Total = CalculateImperialProjectCost(1000000000000);
double deathStar2Total = CalculateImperialProjectCost(2000000000000);
double starkillerTotal = CalculateImperialProjectCost(5000000000000);  // First Order escalation

2. Lättare att förstå (Code så tydligt att även C-3PO förstår)

// Istället för cryptic math överallt som liknar Sith ancient texts:
// if (midichlorians > 7000 && (age < 10 || (age < 16 && hasStrongForceConnection)))

// Skapa en tydlig metod som är mer readable än Jedi holocrons:
public bool IsEligibleForJediTraining(int midichlorianCount, int age, bool hasForceConnection)
{
    bool hasSufficientMidichlorians = midichlorianCount > 7000;
    bool isRightAge = age < 10 || (age < 16 && hasForceConnection);

    return hasSufficientMidichlorians && isRightAge;
}

// Sedan använd den (Crystal clear like Kyber crystals):
if (IsEligibleForJediTraining(27700, 9, true))   // Anakin's stats
{
    Console.WriteLine("This kid could become the Chosen One!");
}
else
{
    Console.WriteLine("Keep your day job, kid.");
}

Metodöverlagring (Multiple Force Powers med samma namn)

Precis som Force Lightning kan användas på olika sätt (stun, kill, power spaceship), kan du ha metoder med samma namn men olika parameters:

public class JediForceAbilities
{
    // Force Push på en person
    public void ForcePush(string target)
    {
        Console.WriteLine("Force pushing " + target + " across the room!");
    }

    // Force Push på flera personer
    public void ForcePush(string[] multipleTargets)
    {
        Console.WriteLine("Force pushing " + multipleTargets.Length + " targets at once!");
        foreach(string target in multipleTargets)
        {
            Console.WriteLine("- Pushed " + target);
        }
    }

    // Force Push med power level
    public void ForcePush(string target, int powerLevel)
    {
        if (powerLevel > 8)
        {
            Console.WriteLine("SUPER Force pushing " + target + " into next star system!");
        }
        else
        {
            Console.WriteLine("Gently Force pushing " + target + " (we're Jedi, not Sith)");
        }
    }
}

// Användning (Compilatorn chooser rätt metod automatically):
var luke = new JediForceAbilities();
luke.ForcePush("Storm Trooper");                           // Single target version
luke.ForcePush(new string[] {"Vader", "Emperor"});        // Multiple targets version
luke.ForcePush("Death Star", 10);                         // Power level version

Return vs Void (To Return or Not to Return)

Return Methods (Methods som ger dig något tillbaka)

public string GetJediWisdom()
{
    return "Do or do not, there is no try.";  // Yoda always returns wisdom
}

public int CountSurvivingJedis()
{
    return 2;  // Luke och Leia... maybe a few more hidden ones
}

public bool CanUseForce(string person)
{
    if (person == "Luke" || person == "Leia" || person == "Rey")
    {
        return true;   // Force-sensitive individuals
    }
    return false;      // Regular folks like Han Solo
}

Void Methods (Methods som gör saker utan att returnera)

public void DisplayRebelAlliance()
{
    Console.WriteLine("=== REBEL ALLIANCE ===");
    Console.WriteLine("Luke Skywalker - Jedi Knight");
    Console.WriteLine("Leia Organa - Princess & General");
    Console.WriteLine("Han Solo - Smuggler turned Hero");
    Console.WriteLine("Chewbacca - Loyal Wookiee");
    // Ingen return - bara displays information
}

public void ActivateLightsaber()
{
    Console.WriteLine("*VZZZWWMMM* - Lightsaber ignited!");
    Console.WriteLine("The Force flows through you...");
    // Actions happen, men inget returneras
}

Bra metod-namn (Naming som skulle make Obi-Wan proud)

Bra namn (Jedi Council approved):

public double ConvertParsecToLightYears(double parsecs)          // Crystal clear purpose
public bool IsStormTrooperAimAccurate(double accuracy)          // We all know detta returns false
public void SaveGalaxyFromDarkSide(string hero)                 // Epic och descriptive
public int CountMidichlorians(string jedi)                      // Scientific och specific

Undvik (Dark Side naming practices):

public double Convert(double distance)     // Convert vad till vad? Confusing like Sith riddles
public bool Check(string person)          // Check för vad? Mystery det är
public void Do(string action)             // Do vad exactly? Vague som Emperor's plans
public int Count()                        // Count vad? Frustrating som Sand People sounds

Naming Conventions (The Jedi Code för Methods):

Verb först - Methods do things: CalculateDistance, DisplayMessage, CheckForce
Beskrivande - Så tydliga att inte ens Jar Jar kan misunderstand
camelCase - First word small, others Capitalized: calculateRebelShips
Engelska - Standard över hela galaktiska imperiet
No abbreviations - Write CalculateDistance not CalcDist

Vanliga misstag att undvika (Don’t pull an Anakin)

Misstag 1: Glömma return statement (Like forgetting your lightsaber i en fight)

// FEL - Method says it returns int men glömmer att actually do it
public int CountJediSurvivors()
{
    int survivors = 2;
    // Glömde: return survivors;  <-- Detta kommer crash your program som Death Star
}

// RÄTT - Always return vad du lovade
public int CountJediSurvivors()
{
    int survivors = 2;
    return survivors;  // Now vi actually får ett svar
}

Misstag 2: Trying to return from void (Like trying to bring back Obi-Wan physically)

// FEL - void methods kan inte return values
public void DisplayJediName(string name)
{
    Console.WriteLine("Jedi: " + name);
    return name;  // FEL! void betyder "jag returnerar inget", som Force ghosts
}

// RÄTT - void methods bara gör saker
public void DisplayJediName(string name)
{
    Console.WriteLine("Jedi: " + name);
    // No return needed - mission accomplished
}

Misstag 3: Konfusing parameters with variables (Like confusing Padmé med Leia)

// FEL - använder variable names som inte existerar
public string CreateJediGreeting(string jediName)
{
    return "Hello there, " + padawanName;  // FEL! parametern heter jediName, inte padawanName
}

// RÄTT - använd exact parameter names
public string CreateJediGreeting(string jediName)
{
    return "Hello there, " + jediName;     // Perfect som Obi-Wan's greeting
}

Method Signatures (The Unique ID för varje Method)

Varje method har en unique “signature” som identifies it, precis som varje Jedi har unique lightsaber design:

public int CalculateShips(int xWings, int yWings)           // Signature: CalculateShips(int, int)
public double CalculateShips(double xWings, double yWings)  // Different signature: CalculateShips(double, double)
public int CalculateShips(int xWings)                       // Different signature: CalculateShips(int)

// Alla kan coexist peacefully som different Jedi techniques

Sammanfattning (What you learned, young Padawan)

Metoder är named code blocks som utför specific tasks (som Jedi abilities)
Return type säger vad method ger tillbaka (int, string, bool, eller void for nothing)
Parameters är input som method behöver (som Force focus objects)
Method names should vara clear och descriptive (som Jedi wisdom)
Void methods gör actions utan att return något (som sacrifice för greater good)
Method overloading låter dig ha same name med different parameters (som versatile Force powers)
Always return vad du promised - annars crash det kommer, guaranteed

Remember: “The Force will be with you, always” - och nu har du methods som companions på din coding journey!

En method är som en lightsaber - du bygger den once, men kan use it whenever du behöver den. Build them well, ung Padawan, och de will serve you throughout your programming adventures.

May the Methods be with you!

Föregående: Kapitel 1 - Variabler och typer: The Force of Data Nästa: Kapitel 3 - Klasser: Building the Rebel Alliance