C # Methode
Eine Möglichkeit ist, einige relevante Aussagen zu verlassen zusammengefasst für einen Block von Anweisungen, um die Aufgabe auszuführen. Jedes Programm hat mindestens eine C # Klasse mit einer Main-Methode.
Um eine Methode zu verwenden, benötigen Sie:
- Definition Methode
- Rufen Sie die Methode
C # Verfahren gemäß der Definition in
Wenn ein Verfahren definiert, im Grunde genommen ist es eine Erklärung der Elemente der Struktur. In C # ist die Syntax-Definition-Methode wie folgt:
<Zugriffsbezeichner> <Return Typ> <Methodenname> (Parameterliste)
{
Methode Gehäuse
}
Im Folgenden sind die einzelnen Elemente:
- Zugriffsbezeichner: Zugriffsmodifikator, die Entscheidungsvariablen oder Verfahren für eine andere Klasse Sichtbarkeit.
- Rückgabetyp: Rückgabetyp kann eine Methode einen Wert zurückgeben.Der Rückgabetyp ist der Datentyp des Wertes durch das Verfahren zurückgeführt. Wenn die Methode alle Werte nicht zurückgibt, ist der Rückgabetypungültig.
- Methodenname: den Namen der Methode, ist eine eindeutige Kennung, und Groß- und Kleinschreibung.Es kann nicht das gleiche wie andere Bezeichner Klassendeklaration sein.
- Parameterliste: Die Liste der Parameter, die in Klammern eingeschlossen, wird der Parameter für die Datenübertragung und Empfangsverfahren verwendet.Parametertyp Parameterliste bezieht sich auf die Methode, die Reihenfolge und Menge. Parameter ist optional, das heißt, ein Verfahren, keine Parameter enthalten.
- Methode Körper: method Körper, einschließlich der Notwendigkeit , Aufgaben Befehlssatz zu vervollständigen.
Beispiele
Das folgende Codefragment zeigt eine FunktionFindMax,die zwei Integer - Werte annimmt, und gibt die größere von zwei Werten. Es verfügt über einen öffentlichen Zugang Modifikator, so kann es mit der Instanz der Klasse von außerhalb der Klasse zugegriffen werden.
class NumberManipulator
{
public int FindMax(int num1, int num2)
{
/* 局部变量声明 */
int result;
if (num1 > num2)
result = num1;
else
result = num2;
return result;
}
...
}
Rufen Sie Methoden in C #
Sie können den Namen des anrufenden Methode verwenden. Das folgende Beispiel veranschaulicht diesen Punkt:
using System;
Namespace CalculatorApplication
{
Klasse NumberManipulator
{
public int FindMax (int num1, int num2)
{
/ * Lokale Variablendeklaration * /
int result;
if (num1> num2)
Ergebnis = num1;
sonst
Ergebnis = num2;
Rückkehr Ergebnis;
}
static void Main (string [] args)
{
/ * Lokale Variablen-Definitionen * /
int a = 100;
int b = 200;
int ret;
NumberManipulator n = new NumberManipulator ();
// Aufruf FindMax Methode ret = n.FindMax (a, b);
Console.WriteLine ( "Max ist: {0}", ret);
Console.ReadLine ();
}
}
}
Wenn der obige Code kompiliert und ausgeführt wird, erzeugt es die folgenden Ergebnisse:
Der Maximalwert beträgt: 200
Sie können auch andere Arten von öffentlichen Methoden Klasseninstanz von einer anderen Klasse. Zum BeispielFindMaxdie MethodeNumberManipulatorKlasse gehören, können Sie es von einer anderen Klasse -Testin rufen.
using System;
Namespace CalculatorApplication
{
Klasse NumberManipulator
{
public int FindMax (int num1, int num2)
{
/ * Lokale Variablendeklaration * /
int result;
if (num1> num2)
Ergebnis = num1;
sonst
Ergebnis = num2;
Rückkehr Ergebnis;
}
}
class Test
{
static void Main (string [] args)
{
/ * Lokale Variablen-Definitionen * /
int a = 100;
int b = 200;
int ret;
NumberManipulator n = new NumberManipulator ();
// Aufruf FindMax Methode ret = n.FindMax (a, b);
Console.WriteLine ( "Max ist: {0}", ret);
Console.ReadLine ();
}
}
}
Wenn der obige Code kompiliert und ausgeführt wird, erzeugt es die folgenden Ergebnisse:
最大值是： 200
Rekursive Methodenaufrufe
Ein Verfahren kann das Selbst nennen. Dies wirdRekursion bezeichnet.Das folgende Beispiel verwendet eine rekursive Funktion die Fakultät einer Zahl zu berechnen:
using System;
Namespace CalculatorApplication
{
Klasse NumberManipulator
{
public int factorial (int num)
{
/ * Lokale Variablen-Definitionen * /
int result;
if (num == 1)
{
1 zurück;
}
sonst
{
Ergebnis = factorial (num - 1) * num;
Rückkehr Ergebnis;
}
}
static void Main (string [] args)
{
NumberManipulator n = new NumberManipulator ();
// Die faktorielle Methode Console.WriteLine Rufen ( "6 faktorieller ist: {0}", n.factorial (6));
Console.WriteLine ( "7 faktorieller ist: {0}", n.factorial (7));
Console.WriteLine ( "8 faktorieller ist: {0}", n.factorial (8));
Console.ReadLine ();
}
}
}
Wenn der obige Code kompiliert und ausgeführt wird, erzeugt es die folgenden Ergebnisse:
6 faktorieller ist: 720 7 faktorieller ist: 5040 8 faktorieller ist: 40320
Die Parameterübergabe
Wenn Sie eine Methode mit Parametern aufrufen, müssen Sie Parameter an die Methode zu übergeben. In C # gibt es drei Möglichkeiten, Parameter an die Methode zu übergeben:
| 方式 | 描述 |
|---|---|
| 值参数 | 这种方式复制参数的实际值给函数的形式参数，实参和形参使用的是两个不同内存中的值。在这种情况下，当形参的值发生改变时，不会影响实参的值，从而保证了实参数据的安全。 |
| 引用参数 | 这种方式复制参数的内存位置的引用给形式参数。这意味着，当形参的值发生改变时，同时也改变实参的值。 |
| 输出参数 | 这种方式可以返回多个值。 |
Übergeben von Parametern nach Wert
Dies ist der Standardparameterübergabe. Auf diese Weise, wenn Sie eine Methode aufrufen, die einen neuen Speicherort für jeden Parameter erzeugt.
Der aktuelle Parameterwert wird auf Parameter, Argumente und Parameter in zwei verschiedenen Speicherwert verwendet, kopiert. Also, wenn der Parameterwert ändert nicht den Wert des Arguments beeinflussen, so dass die realen Parameter Datensicherheit zu gewährleisten. Das folgende Beispiel veranschaulicht dieses Konzept:
using System;
namespace CalculatorApplication
{
class NumberManipulator
{
public void swap(int x, int y)
{
int temp;
temp = x; /* 保存 x 的值 */
x = y; /* 把 y 赋值给 x */
y = temp; /* 把 temp 赋值给 y */
}
static void Main(string[] args)
{
NumberManipulator n = new NumberManipulator();
/* 局部变量定义 */
int a = 100;
int b = 200;
Console.WriteLine("在交换之前，a 的值： {0}", a);
Console.WriteLine("在交换之前，b 的值： {0}", b);
/* 调用函数来交换值 */
n.swap(a, b);
Console.WriteLine("在交换之后，a 的值： {0}", a);
Console.WriteLine("在交换之后，b 的值： {0}", b);
Console.ReadLine();
}
}
}
Wenn der obige Code kompiliert und ausgeführt wird, erzeugt es die folgenden Ergebnisse:
在交换之前，a 的值：100 在交换之前，b 的值：200 在交换之后，a 的值：100 在交换之后，b 的值：200
Die Ergebnisse zeigten, dass selbst in der Funktion den Wert ändert, hatte der Wert einer Änderung passiert ist.
Übergeben Sie Parameter durch Verweis
Referenzparameter istein Verweis auf den variablen Speicherstelle.Wenn die Parameter als Referenz übergeben, mit dem Wert des Parameters unterschiedlich ist, ist es, dass es nicht einen neuen Speicherort für diese Parameter nicht erstellen. Referenzparameter stellt die tatsächliche Parameter an die Methode die gleiche Speicherstelle aufweist.
In C #, das Schlüsselwortref mit einem Referenzparameter zu erklären.Das folgende Beispiel veranschaulicht diesen Punkt:
using System;
Namespace CalculatorApplication
{
Klasse NumberManipulator
{
public void swap (ref int x, ref int y)
{
int Temp;
temp = x; / * den Wert von x * Speichern /
x = y; / * y zur x * zugeordnet ist /
y = Temp / * temp Zuordnung zu y * /
}
static void Main (string [] args)
{
NumberManipulator n = new NumberManipulator ();
/ * Lokale Variablen-Definitionen * /
int a = 100;
int b = 200;
Console.WriteLine ( "Vor dem Austausch, ein Wert von: {0}", a);
Console.WriteLine ( "Vor dem Austausch, b-Werte: {0}", b);
/ * Die Funktion Tauschwert * Call /
n.swap (ref ein, ref b);
Console.WriteLine ( "Nach einem Austausch, ein Wert von: {0}", a);
Console.WriteLine ( "Nach einem Austausch, b-Werte: {0}", b);
Console.ReadLine ();
}
}
}
Wenn der obige Code kompiliert und ausgeführt wird, erzeugt es die folgenden Ergebnisse:
在交换之前，a 的值：100 在交换之前，b 的值：200 在交换之后，a 的值：200 在交换之后，b 的值：100
Die Ergebnisse zeigten , dass der Wert desSwap- Funktion innerhalb der Veränderung, und diese Änderung kann inder Hauptfunktionwiderspiegeln.
Übergeben von Parametern durch Ausgabe
return-Anweisung kann nur zurückkehren einen Wert aus einer Funktion verwendet. Sie können jedoch denAusgangsparameter verwenden , um zwei Werte von Funktionen zurückgeben.Datenausgabeparameter Ausgabeverfahren werden ihre eigenen und andere ähnliche Bezugsparameter zuweisen.
Das folgende Beispiel veranschaulicht diesen Punkt:
using System;
namespace CalculatorApplication
{
class NumberManipulator
{
public void getValue(out int x )
{
int temp = 5;
x = temp;
}
static void Main(string[] args)
{
NumberManipulator n = new NumberManipulator();
/* 局部变量定义 */
int a = 100;
Console.WriteLine("在方法调用之前，a 的值： {0}", a);
/* 调用函数来获取值 */
n.getValue(out a);
Console.WriteLine("在方法调用之后，a 的值： {0}", a);
Console.ReadLine();
}
}
}
Wenn der obige Code kompiliert und ausgeführt wird, erzeugt es die folgenden Ergebnisse:
在方法调用之前，a 的值： 100 在方法调用之后，a 的值： 5
Lieferung an die Ausgangsparametervariablen erfordert nicht die Zuordnung. Wenn die Notwendigkeit, einen Wert von dem Anfangswert des Parameters zurückzukehren angeben kein Verfahren, wird der Ausgangsparameter besonders nützlich. Betrachten Sie das folgende Beispiel, das zu verstehen:
using System;
namespace CalculatorApplication
{
class NumberManipulator
{
public void getValues(out int x, out int y )
{
Console.WriteLine("请输入第一个值： ");
x = Convert.ToInt32(Console.ReadLine());
Console.WriteLine("请输入第二个值： ");
y = Convert.ToInt32(Console.ReadLine());
}
static void Main(string[] args)
{
NumberManipulator n = new NumberManipulator();
/* 局部变量定义 */
int a , b;
/* 调用函数来获取值 */
n.getValues(out a, out b);
Console.WriteLine("在方法调用之后，a 的值： {0}", a);
Console.WriteLine("在方法调用之后，b 的值： {0}", b);
Console.ReadLine();
}
}
}
Wenn der obige Code kompiliert und ausgeführt wird, erzeugt es das folgende Ergebnis (je nach Benutzereingabe):
Bitte geben Sie einen Wert: 7 Bitte geben Sie den zweiten Wert: 8 Nach dem Aufruf der Methode ein Wert: 7 Nach dem Methodenaufruf, b-Werte: 8