Στη γλώσσα C#, οι μέθοδοι αποτελούν μια μονάδα κώδικα που χρησιμοποιείται για να εκτελέσει συγκεκριμένες ενέργειες όταν καλούνται. Μπορείτε να περάσετε δεδομένα, γνωστά ως παράμετροι, σε μια μέθοδο για να τα χρησιμοποιήσετε κατά την εκτέλεσή της.
Οι μέθοδοι χρησιμοποιούνται για να οργανώσουν τον κώδικα και να τον καθιστούν επαναχρησιμοποιήσιμο. Όταν ορίζετε μια μέθοδο, μπορείτε να την καλέσετε από οπουδήποτε στο πρόγραμμά σας και να εκτελέσει τον κώδικα που έχετε ορίσει μέσα σε αυτήν.
Για να ορίσετε μια μέθοδο στη C#, χρησιμοποιείτε την εξής σύνταξη:
accessModifier returnType MethodName(parameters)
{
// Κώδικας εδώ
}
Εδώ, accessModifier είναι ο τρόπος πρόσβασης της μεθόδου (π.χ. public, private), returnType είναι ο τύπος δεδομένων που επιστρέφει η μέθοδος (ή void αν δεν επιστρέφει τίποτα), MethodName είναι το όνομα της μεθόδου και parameters είναι οι παράμετροι που δέχεται η μέθοδος (μπορεί να είναι κενές αν δεν δέχεται παραμέτρους).
Παρακάτω παραθέτω ένα αναλυτικό παράδειγμα ορισμού μιας μεθόδου στη γλώσσα C#:
using System;
class Program
{
static void Main()
{
// Κλήση της μεθόδου AddNumbers και αποθήκευση του αποτελέσματος σε μια μεταβλητή
int sum = AddNumbers(10, 20);
// Εκτύπωση του αποτελέσματος
Console.WriteLine("Το άθροισμα είναι: " + sum);
}
// Ορισμός της μεθόδου AddNumbers με δύο παραμέτρους ακεραίων και επιστροφή ακέραιου αποτελέσματος
static int AddNumbers(int num1, int num2)
{
// Υπολογισμός του άθροισματος
int sum = num1 + num2;
// Επιστροφή του αποτελέσματος
return sum;
}
}
Στο παραπάνω παράδειγμα, ορίζουμε τη μέθοδο AddNumbers, η οποία δέχεται δύο παραμέτρους τύπου int και επιστρέφει έναν ακέραιο αριθμό. Μέσα στη μέθοδο, υπολογίζουμε το άθροισμα των δύο αριθμών και το αποθηκεύουμε στη μεταβλητή sum. Τέλος, επιστρέφουμε την τιμή της μεταβλητής sum στο σημείο κλήσης της μεθόδου.
Στην Main μέθοδο, καλούμε τη μέθοδο AddNumbers με τις παράμετρους 10 και 20 και αποθηκεύουμε το αποτέλεσμα στη μεταβλητή sum. Στη συνέχεια, εκτυπώνουμε το αποτέλεσμα στην οθόνη.
Στη συνέχεια, καλούμε τη μέθοδο Greet περνώντας διάφορα ονόματα ως παράμετροι. Η μέθοδος εκτελείται για κάθε κλήση, εμφανίζοντας το κατάλληλο μήνυμα χαιρετισμού στην οθόνη.
[adinserter block=”2″]
Η έξοδος θα είναι:
Hello, John! Hello, Jane!
Αυτό είναι ένα απλό παράδειγμα μεθόδου. Οι μέθοδοι μπορούν να περιλαμβάνουν πολύπλοκη λογική και να εκτελούν πολλές ενέργειες. Μπορείτε να χρησιμοποιήσετε μέθοδους για να οργανώσετε τον κώδικα σας και να επαναχρησιμοποιήσετε τον κώδικα που έχετε ορίσει μέσα σε αυτές.
Μπορείτε να δημιουργήσετε τις δικές σας μεθόδους στη C# για να εκτελέσετε συγκεκριμένες ενέργειες. Για να δημιουργήσετε μια μέθοδο, ακολουθήστε τα παρακάτω βήματα:
- Ορίστε τον τύπο πρόσβασης της μεθόδου (π.χ.
public,private). Ο τύπος πρόσβασης καθορίζει από πού μπορεί να κληθεί η μέθοδος. - Ορίστε τον τύπο δεδομένων που επιστρέφει η μέθοδος. Αν η μέθοδος δεν επιστρέφει τίποτα, χρησιμοποιήστε τον τύπο
void. - Δημιουργήστε το όνομα της μεθόδου, ακολουθούμενο από παρενθέσεις. Οι παρενθέσεις μπορεί να περιέχουν παραμέτρους που περνούν στη μέθοδο.
- Ορίστε το σώμα της μεθόδου με τον κώδικα που εκτελείται όταν καλείται η μέθοδος.
Παρακάτω παρουσιάζεται ένα παράδειγμα δημιουργίας μιας μεθόδου που εκτυπώνει ένα καλωσόρισμα:
public void PrintGreeting()
{
Console.WriteLine("Welcome to the program!");
}
Σε αυτό το παράδειγμα, δημιουργούμε μια μέθοδο με το όνομα PrintGreeting. Η μέθοδος δεν δέχεται κανένα παράμετρο και δεν επιστρέφει κάποιο αποτέλεσμα (void).
Για να καλέσετε (εκτελέσετε) μια μέθοδο, γράψτε το όνομα της μεθόδου ακολουθούμενο από δύο παρενθέσεις () και ένα ερωτηματικό ερωτηματικό:
MyMethod();
Στο παραπάνω παράδειγμα, η μέθοδος MyMethod() καλείται για να εκτελέσει έναν κώδικα ή μια ενέργεια. Μπορείτε να καλέσετε τη μέθοδο αυτή οπουδήποτε στο πρόγραμμά σας όπου χρειάζεται να εκτελεστεί ο κώδικας που έχει οριστεί μέσα σε αυτήν.
Συνεχίζοντας από το προηγούμενο παράδειγμα, ας καλέσουμε τη μέθοδο PrintGreeting για να εκτυπώσουμε το καλωσόρισμα:
PrintGreeting();
Με την παραπάνω κλήση, η μέθοδος PrintGreeting θα εκτελέσει τον κώδικα που περιέχεται μέσα της και θα εμφανίσει το μήνυμα “Welcome to the program!” στην οθόνη.
Αυτό είναι ένα απλό παράδειγμα κλήσης μιας μεθόδου. Μπορείτε να καλέσετε μια μέθοδο όσες φορές θέλετε ανάλογα με τις ανάγκες σας.
Μια μέθοδος μπορεί να καλεστεί πολλές φορές ανάλογα με τις ανάγκες σας. Μπορείτε να καλέσετε μια μέθοδο από διάφορα σημεία του προγράμματος σας και τον κώδικα που περιέχει θα εκτελεστεί κάθε φορά που καλείται.
Για παράδειγμα, ας υποθέσουμε ότι έχουμε την παρακάτω μέθοδο PrintMessage():
public void PrintMessage()
{
Console.WriteLine("This is a message.");
}
Μπορούμε να την καλέσουμε πολλές φορές ανάλογα με τις ανάγκες μας:
PrintMessage(); // Κλήση της μεθόδου για πρώτη φορά PrintMessage(); // Κλήση της μεθόδου για δεύτερη φορά PrintMessage(); // Κλήση της μεθόδου για τρίτη φορά
Στη γλώσσα προγραμματισμού C#, μπορούμε να μεταβιβάσουμε πληροφορίες σε μεθόδους χρησιμοποιώντας παράμετρους. Οι παράμετροι λειτουργούν ως μεταβλητές που χρησιμοποιούνται εντός της μεθόδου.
Ορίζουμε τις παραμέτρους μετά το όνομα της μεθόδου, μέσα σε παρενθέσεις. Μπορούμε να προσθέσουμε όσες παραμέτρους χρειαζόμαστε, απλά τις χωρίζουμε με κόμμα.
Παρακάτω παραθέτω ένα παράδειγμα κώδικα που περιέχει μια μέθοδο με όνομα “PrintFullName”, η οποία δέχεται ένα αλφαριθμητικό με το όνομα “fname” ως παράμετρο. Κατά την κλήση της μεθόδου, περνάμε ένα μικρό όνομα (first name), το οποίο χρησιμοποιείται εντός της μεθόδου για να εκτυπωθεί το πλήρες όνομα.
void PrintFullName(string fname)
{
Console.WriteLine("Το πλήρες όνομα είναι: " + fname + " Smith");
}
Για παράδειγμα, αν θέλουμε να καλέσουμε αυτήν τη μέθοδο και να περάσουμε το όνομα “John” ως όρισμα, το κάνουμε ως εξής:
PrintFullName("John");
Το παραπάνω κώδικας θα εκτυπώσει το ακόλουθο μήνυμα:
Το πλήρες όνομα είναι: John Smith
Με αυτόν τον τρόπο, μπορούμε να περάσουμε διαφορετικά ονόματα ως παράμετρο στη μέθοδο PrintFullName και θα εκτυπώνονται τα αντίστοιχα πλήρη ονόματα.
Συνεχίζοντας με την περιγραφή, το παράδειγμα που ακολουθεί παρουσιάζει τη χρήση πολλαπλών παραμέτρων σε μια μέθοδο:
void PrintFullName(string firstName, string lastName)
{
Console.WriteLine("Το πλήρες όνομα είναι: " + firstName + " " + lastName);
}
Για να καλέσετε αυτήν τη μέθοδο και να περάσετε τα ονόματα “John” και “Doe” ως ορίσματα, θα το κάνετε με την εξής σύνταξη:
PrintFullName("John", "Doe");
Το παραπάνω κομμάτι κώδικα θα εκτυπώσει το ακόλουθο μήνυμα:
Το πλήρες όνομα είναι: John Doe
Με αυτόν τον τρόπο, μπορείτε να περάσετε πολλές παραμέτρους σε μια μέθοδο και να τις χρησιμοποιήσετε μέσα σε αυτήν για την εκτέλεση των αντίστοιχων λειτουργιών.
[adinserter block=”3″]
Μπορείτε να έχετε όσες παραμέτρους θέλετε, απλά χωρίζοντάς την κάθε μια με κόμμα:
void ExampleMethod(int parameter1, string parameter2, bool parameter3)
{
// Ο κώδικάς σας εδώ
}
Στο παραπάνω παράδειγμα, έχουμε μια μέθοδο με τρεις παραμέτρους. Η πρώτη παράμετρος είναι ένας ακέραιος αριθμός με το όνομα parameter1, η δεύτερη παράμετρος είναι ένα αλφαριθμητικό με το όνομα parameter2, και η τρίτη παράμετρος είναι ένα bool με το όνομα parameter3.
Μπορείτε να καλέσετε αυτήν τη μέθοδο και να περάσετε τιμές για κάθε παράμετρο ως εξής:
ExampleMethod(10, "Hello", true);
Στο παραπάνω παράδειγμα, περνάμε την τιμή 10 για την παράμετρο parameter1, το αλφαριθμητικό “Hello” για την παράμετρο parameter2, και την τιμή true για την παράμετρο parameter3.
Μπορείτε να προσαρμόσετε τον κώδικα της μεθόδου ανάλογα με τις ανάγκες σας και τον τύπο των παραμέτρων που χρειάζεστε.
Μπορείτε επίσης να χρησιμοποιήσετε μια προεπιλεγμένη τιμή για μια παράμετρο, χρησιμοποιώντας τον χαρακτήρα ίσον (=).
Παράδειγμα:
void ExampleMethod(string parameter1, int parameter2 = 10)
{
// Ο κώδικάς σας εδώ
}
Στο παραπάνω παράδειγμα, έχουμε μια μέθοδο με δύο παραμέτρους. Η πρώτη παράμετρος είναι ένα αλφαριθμητικό με το όνομα parameter1, και η δεύτερη παράμετρος είναι ένας ακέραιος αριθμός με το όνομα parameter2. Ωστόσο, η παράμετρος parameter2 έχει μια προεπιλεγμένη τιμή του 10.
Αυτό σημαίνει ότι μπορείτε να καλέσετε αυτήν τη μέθοδο με μια ή δύο παραμέτρους. Αν παραλείψετε τη δεύτερη παράμετρο κατά την κλήση της μεθόδου, η τιμή της parameter2 θα είναι η προεπιλεγμένη τιμή του 10.
Παραδείγματα:
ExampleMethod("Hello"); // Το parameter1 παίρνει την τιμή "Hello", ενώ η parameter2 παίρνει την προεπιλεγμένη τιμή 10
ExampleMethod("World", 20); // Το parameter1 παίρνει την τιμή "World", ενώ η parameter2 παίρνει την τιμή 20
Στην προηγούμενη παράγραφο, χρησιμοποιήσαμε τη λέξη-κλειδί void σε όλα τα παραδείγματα, που υποδηλώνει ότι η μέθοδος δεν πρέπει να επιστρέψει κάποια τιμή.
Αν θέλετε η μέθοδος να επιστρέφει μια τιμή, μπορείτε να χρησιμοποιήσετε έναν αρχέτυπο τύπο δεδομένων (όπως int ή double) αντί για το void, και να χρησιμοποιήσετε τη λέξη-κλειδί return μέσα στη μέθοδο:
int AddNumbers(int a, int b)
{
int sum = a + b;
return sum;
}
Στο παραπάνω παράδειγμα, έχουμε μια μέθοδο με δύο παραμέτρους τύπου int, a και b. Οι παράμετροι προστίθενται μαζί και το αποτέλεσμα αποθηκεύεται στη μεταβλητή sum. Στη συνέχεια, χρησιμοποιούμε τη λέξη-κλειδί return για να επιστρέψουμε την τιμή της μεταβλητής sum.
Μπορείτε να καλέσετε αυτήν τη μέθοδο και να αποθηκεύσετε την επιστρεφόμενη τιμή όπως εξής:
int result = AddNumbers(5, 3); Console.WriteLine(result); // Θα εκτυπωθεί 8
Στο παραπάνω παράδειγμα, καλούμε τη μέθοδο AddNumbers και περνάμε τις τιμές 5 και 3 για τις παραμέτρους a και b. Η μέθοδος επιστρέφει το άθροισμα των δύο αριθμών, που στην περίπτωση μας είναι το 8. Στη συνέχεια, αποθηκεύουμε αυτήν την επιστρεφόμενη τιμή στη μεταβλητή result και την εκτυπώνουμε στην οθόνη.
[adinserter block=”4″]
Μπορείτε να προσαρμόσετε τον κώδικα σας ανάλογα με τις ανάγκες σας και τον τύπο της επιστρεφόμενης τιμής που επιθυμείτε.
Μπορείτε επίσης να αποθηκεύσετε το αποτέλεσμα σε μια μεταβλητή (προτείνεται, καθώς είναι πιο ευανάγνωστο και συντηρήσιμο):
int result = AddNumbers(5, 3); Console.WriteLine(result); // Θα εκτυπωθεί: 8
Στο παραπάνω παράδειγμα, αποθηκεύουμε το αποτέλεσμα της κλήσης της μεθόδου AddNumbers(5, 3) στη μεταβλητή result. Έπειτα, εκτυπώνουμε την τιμή της μεταβλητής result, η οποία θα είναι το άθροισμα των αριθμών 5 και 3, δηλαδή το 8.
Αποθηκεύοντας το αποτέλεσμα σε μια μεταβλητή, μπορείτε να το χρησιμοποιήσετε αργότερα στο πρόγραμμά σας, να το περάσετε ως όρισμα σε άλλες μεθόδους, ή να το χρησιμοποιήσετε για περαιτέρω υπολογισμούς.
Είναι επίσης δυνατόν να στείλετε ορίσματα χρησιμοποιώντας τη σύνταξη “κλειδί: τιμή”.
Με αυτόν τον τρόπο, η σειρά των ορισμάτων δεν έχει σημασία:
void PrintStudentInfo(string name, int age)
{
Console.WriteLine("Name: " + name);
Console.WriteLine("Age: " + age);
}
Στο παραπάνω παράδειγμα, έχουμε μια μέθοδο PrintStudentInfo που παίρνει δύο παραμέτρους, το όνομα name και την ηλικία age. Αντί να καλέσετε τη μέθοδο με τη σειρά των ορισμάτων, μπορείτε να χρησιμοποιήσετε τη σύνταξη “κλειδί: τιμή” για να στείλετε τα ορίσματα:
PrintStudentInfo(name: "John", age: 20);
Μπορείτε επίσης να αλλάξετε τη σειρά των ορισμάτων:
PrintStudentInfo(age: 20, name: "John");
Και σε αυτές τις περιπτώσεις, η μέθοδος θα εκτυπώσει τις πληροφορίες του φοιτητή, χρησιμοποιώντας τα ορίσματα που έχουν δοθεί.
Αυτό μπορεί να είναι χρήσιμο όταν έχετε πολλά ορίσματα και θέλετε να είστε σαφείς σχετικά με τις τιμές που περνάτε.
Ο πολυμορφισμός μεθόδων (method overloading) επιτρέπει την ύπαρξη πολλαπλών μεθόδων με το ίδιο όνομα αλλά διαφορετικές παραμέτρους.
void PrintNumber(int number)
{
Console.WriteLine("Ο αριθμός είναι: " + number);
}
void PrintNumber(double number)
{
Console.WriteLine("Ο αριθμός είναι: " + number);
}
Στο παραπάνω παράδειγμα, έχουμε δύο μέθοδους με το όνομα PrintNumber, αλλά διαφορετικές παράμετρους. Η πρώτη μέθοδος παίρνει έναν ακέραιο αριθμό (int) και η δεύτερη μέθοδος παίρνει έναν δεκαδικό αριθμό (double). Με τη χρήση του πολυμορφισμού μεθόδων, μπορούμε να έχουμε διαφορετικές υλοποιήσεις της ίδιας λειτουργίας ανάλογα με τον τύπο των παραμέτρων.
Κατά την κλήση της μεθόδου, ο μεταγλωττιστής θα επιλέξει την κατάλληλη υλοποίηση με βάση τις παρεχόμενες παραμέτρους:
PrintNumber(10); // Θα εκτυπωθεί: Ο αριθμός είναι: 10 PrintNumber(3.14); // Θα εκτυπωθεί: Ο αριθμός είναι: 3.14
Στο παραπάνω παράδειγμα, καλούμε τη μέθοδο PrintNumber δύο φορές. Στην πρώτη κλήση, περνάμε έναν ακέραιο αριθμό (10), ενώ στη δεύτερη κλήση της μεθόδου PrintNumber περνάμε έναν δεκαδικό αριθμό (3.14). Ο μεταγλωττιστής θα επιλέξει την κατάλληλη υλοποίηση της μεθόδου με βάση τον τύπο των παρεχόμενων ορισμάτων και θα εκτυπώσει το αντίστοιχο μήνυμα.
[adinserter block=”5″]
Ο πολυμορφισμός μεθόδων μας επιτρέπει να έχουμε περισσότερη ευελιξία στον τρόπο που καλούμε μια μέθοδο, επιτρέποντάς μας να χρησιμοποιούμε την ίδια ονομασία μεθόδου για διαφορετικούς τύπους ορισμάτων.
Η μέθοδος του method overloading στη C# αναφέρεται στη δυνατότητα να ορίσουμε πολλαπλές μεθόδους με το ίδιο όνομα αλλά διαφορετικά σύνολα παραμέτρων. Αυτό μας επιτρέπει να καλούμε την ίδια μέθοδο με διαφορετικές παράμετρους και η C# θα αναγνωρίσει αυτόματα ποια μέθοδο πρέπει να εκτελεστεί με βάση τις παρεχόμενες παραμέτρους.
Μέσω του method overloading, μπορούμε να δημιουργήσουμε πιο ευέλικτο και ευανάγνωστο κώδικα. Καθώς καλούμε μια μέθοδο με συγκεκριμένες παράμετρους, ο μεταγλωττιστής αναζητεί την κατάλληλη μέθοδο με βάση τον τύπο και τη σειρά των παραμέτρων που παρέχονται.
Ένα παράδειγμα του method overloading στη C# είναι η παρακάτω κώδικας:
using System;
class Program
{
static void Main()
{
// Δημιουργία αντικειμένου της κλάσης Calculator
Calculator calculator = new Calculator();
// Κλήση της μεθόδου Add με δύο ακέραιους αριθμούς
int sum1 = calculator.Add(5, 3);
// Κλήση της μεθόδου Add με δύο δεκαδικούς αριθμούς
double sum2 = calculator.Add(2.5, 1.5);
// Κλήση της μεθόδου Add με τρεις ακέραιους αριθμούς
int sum3 = calculator.Add(1, 2, 3);
// Εκτύπωση των αποτελεσμάτων
Console.WriteLine("Άθροισμα 1: " + sum1);
Console.WriteLine("Άθροισμα 2: " + sum2);
Console.WriteLine("Άθροισμα 3: " + sum3);
}
}
// Ορισμός της κλάσης Calculator
class Calculator
{
// Μέθοδος που προσθέτει δύο ακέραιους αριθμούς
public int Add(int a, int b)
{
return a + b;
}
// Μέθοδος που προσθέτει δύο δεκαδικούς αριθμούς
public double Add(double a, double b)
{
return a + b;
}
// Μέθοδος που προσθέτει τρεις ακέραιους αριθμούς
public int Add(int a, int b, int c)
{
return a + b + c;
}
}
Ο παραπάνω κώδικας δημιουργεί μια κλάση με το όνομα “Calculator”, η οποία περιέχει τρεις μεθόδους για την προσθήκη αριθμών. Ο κώδικας περιέχει επίσης την κλάση “Program” με την μέθοδο “Main”, η οποία είναι η κύρια μέθοδος εκτέλεσης του προγράμματος.
Η κλάση “Calculator” έχει τρεις μέθοδους “Add” που προσθέτουν αριθμούς. Η πρώτη μέθοδος “Add” δέχεται δύο ακέραιους αριθμούς, πραγματοποιεί την πρόσθεσή τους και επιστρέφει το αποτέλεσμα ως ακέραιος αριθμός. Η δεύτερη μέθοδος “Add” δέχεται δύο δεκαδικούς αριθμούς, πραγματοποιεί την πρόσθεσή τους και επιστρέφει το αποτέλεσμα ως δεκαδικός αριθμός. Η τρίτη μέθοδος “Add” δέχεται τρεις ακέραιους αριθμούς, πραγματοποιεί την πρόσθεσή τους και επιστρέφει το αποτέλεσμα ως ακέραιος αριθμός.
Η μέθοδος “Main” είναι η κύρια μέθοδος εκτέλεσης του προγράμματος. Μέσα σε αυτήν, δημιουργείται ένα αντικείμενο της κλάσης “Calculator”. Στη συνέχεια, καλούνται οι μέθοδοι “Add” του αντικειμένου με διάφορες παρ
αμέτρους για να προσθέσουν αριθμούς. Τα αποτελέσματα των πράξεων αποθηκεύονται σε μεταβλητές και εκτυπώνονται στην οθόνη.
Συνολικά, ο κώδικας υλοποιεί ένα απλό πρόγραμμα υπολογισμού αθροίσματος αριθμών χρησιμοποιώντας την κλάση “Calculator”.
Για παράδειγμα:
Calculator calc = new Calculator(); int result1 = calc.Add(1, 2); // Καλείται η μέθοδος Add(int a, int b) double result2 = calc.Add(1.5, 2.5); // Καλείται η μέθοδος Add(double a, double b) int result3 = calc.Add(1, 2, 3); // Καλείται η μέθοδος Add(int a, int b, int c)
Με το method overloading, μπορούμε να ορίσουμε πολλαπλές μεθόδους με το ίδιο όνομα αλλά διαφορετικές παράμετρους, προσφέροντας έτσι ευελιξία και ευαναγνωστία στον κώδικα μας.