Kaedah C#
Satu kaedah ialah mengumpulkan beberapa pernyataan berkaitan bersama-sama ke dalam blok pernyataan yang digunakan untuk melaksanakan tugas. Setiap program C# mempunyai sekurang-kurangnya satu kelas dengan kaedah Utama.
Untuk menggunakan kaedah anda perlu:
Tentukan kaedah
Kaedah panggilan
Mentakrifkan kaedah dalam C#
Apabila anda mentakrifkan kaedah, anda pada asasnya mengisytiharkan unsur-unsur strukturnya. Dalam C#, sintaks untuk mentakrifkan kaedah adalah seperti berikut:
<Access Specifier> <Return Type> <Method Name>(Parameter List)
{
Method Body
}Berikut ialah pelbagai elemen kaedah:
Penentukan Akses : pengubah suai akses, ini Menentukan keterlihatan pembolehubah atau kaedah kepada kelas lain.
Jenis pulangan: Jenis pulangan, kaedah boleh mengembalikan nilai. Jenis pulangan ialah jenis data nilai yang dikembalikan oleh kaedah. Jika kaedah tidak mengembalikan sebarang nilai, jenis pulangan ialah batal.
Nama kaedah: Nama kaedah ialah pengecam unik dan sensitif huruf besar. Ia tidak boleh sama dengan pengecam lain yang diisytiharkan dalam kelas.
Senarai parameter: Senarai parameter, disertakan dalam kurungan, parameter ini digunakan untuk menghantar dan menerima data kaedah. Senarai parameter merujuk kepada jenis parameter kaedah, susunan dan nombor. Parameter adalah pilihan, iaitu, kaedah mungkin tidak mengandungi parameter.
Isi kaedah: Badan kaedah, mengandungi set arahan yang diperlukan untuk menyelesaikan tugasan.
Contoh
Coretan kod di bawah menunjukkan fungsi FindMax yang menerima dua nilai integer dan mengembalikan nilai yang lebih besar daripada dua . Ia mempunyai pengubah suai akses awam, jadi ia boleh diakses dari luar kelas menggunakan contoh kelas.
class NumberManipulator
{
public int FindMax(int num1, int num2)
{
/* 局部变量声明 */
int result;
if (num1 > num2)
result = num1;
else
result = num2;
return result;
}
...
}Kaedah panggilan dalam C#
Anda boleh memanggil kaedah menggunakan namanya. Contoh berikut menunjukkan ini:
using System;
namespace CalculatorApplication
{
class NumberManipulator
{
public int FindMax(int num1, int num2)
{
/* 局部变量声明 */
int result;
if (num1 > num2)
result = num1;
else
result = num2;
return result;
}
static void Main(string[] args)
{
/* 局部变量定义 */
int a = 100;
int b = 200;
int ret;
NumberManipulator n = new NumberManipulator();
//调用 FindMax 方法
ret = n.FindMax(a, b);
Console.WriteLine("最大值是： {0}", ret );
Console.ReadLine();
}
}
}Apabila kod di atas disusun dan dilaksanakan, ia menghasilkan keputusan berikut:
最大值是： 200
Anda juga boleh menggunakan contoh kelas daripada kelas lain Panggil kaedah awam daripada kelas lain. Contohnya, kaedah FindMax tergolong dalam kelas NumberManipulator dan anda boleh memanggilnya daripada kelas lain Ujian.
using System;
namespace CalculatorApplication
{
class NumberManipulator
{
public int FindMax(int num1, int num2)
{
/* 局部变量声明 */
int result;
if (num1 > num2)
result = num1;
else
result = num2;
return result;
}
}
class Test
{
static void Main(string[] args)
{
/* 局部变量定义 */
int a = 100;
int b = 200;
int ret;
NumberManipulator n = new NumberManipulator();
//调用 FindMax 方法
ret = n.FindMax(a, b);
Console.WriteLine("最大值是： {0}", ret );
Console.ReadLine();
}
}
}Apabila kod di atas disusun dan dilaksanakan, ia menghasilkan keputusan berikut:
最大值是： 200
Panggilan kaedah rekursif
Kaedah boleh memanggil dirinya sendiri. Ini dipanggil rekursi. Contoh berikut menggunakan fungsi rekursif untuk mengira pemfaktoran nombor:
using System;
namespace CalculatorApplication
{
class NumberManipulator
{
public int factorial(int num)
{
/* 局部变量定义 */
int result;
if (num == 1)
{
return 1;
}
else
{
result = factorial(num - 1) * num;
return result;
}
}
static void Main(string[] args)
{
NumberManipulator n = new NumberManipulator();
//调用 factorial 方法
Console.WriteLine("6 的阶乘是： {0}", n.factorial(6));
Console.WriteLine("7 的阶乘是： {0}", n.factorial(7));
Console.WriteLine("8 的阶乘是： {0}", n.factorial(8));
Console.ReadLine();
}
}
}Apabila kod di atas disusun dan dilaksanakan, ia menghasilkan keputusan berikut:
6 的阶乘是： 720 7 的阶乘是： 5040 8 的阶乘是： 40320
Melalui parameter
Apabila memanggil kaedah dengan parameter, anda perlu menghantar parameter kepada kaedah tersebut. Dalam C#, terdapat tiga cara untuk menghantar parameter kepada kaedah:
| 方式 | 描述 |
|---|---|
| 值参数 | 这种方式复制参数的实际值给函数的形式参数，实参和形参使用的是两个不同内存中的值。在这种情况下，当形参的值发生改变时，不会影响实参的值，从而保证了实参数据的安全。 |
| 引用参数 | 这种方式复制参数的内存位置的引用给形式参数。这意味着，当形参的值发生改变时，同时也改变实参的值。 |
| 输出参数 | 这种方式可以返回多个值。 |
Lepasi parameter mengikut nilai
Ini ialah cara lalai untuk lulus parameter. Dengan cara ini, apabila kaedah dipanggil, lokasi storan baharu dicipta untuk setiap parameter nilai.
Nilai parameter sebenar akan disalin ke parameter formal Parameter sebenar dan parameter formal menggunakan dua nilai berbeza dalam ingatan. Oleh itu, apabila nilai parameter formal berubah, nilai parameter sebenar tidak akan terjejas, sekali gus memastikan keselamatan data parameter sebenar. Contoh berikut menunjukkan konsep ini:
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();
}
}
}Apabila kod di atas disusun dan dilaksanakan, ia menghasilkan keputusan berikut:
在交换之前，a 的值：100 在交换之前，b 的值：200 在交换之后，a 的值：100 在交换之后，b 的值：200
Keputusan menunjukkan bahawa walaupun nilai diubah dalam fungsi, nilai Tiada yang berubah.
Melalui parameter melalui rujukan
Parameter rujukan ialah rujukan kepada lokasi memori pembolehubah. Apabila parameter diluluskan melalui rujukan, tidak seperti parameter nilai, ia tidak mewujudkan lokasi storan baharu untuk parameter tersebut. Parameter rujukan mewakili lokasi memori yang sama seperti parameter sebenar yang dibekalkan kepada kaedah.
Dalam C#, gunakan kata kunci ref untuk mengisytiharkan parameter rujukan. Contoh berikut menunjukkan ini:
using System;
namespace CalculatorApplication
{
class NumberManipulator
{
public void swap(ref int x, ref 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(ref a, ref b);
Console.WriteLine("在交换之后，a 的值： {0}", a);
Console.WriteLine("在交换之后，b 的值： {0}", b);
Console.ReadLine();
}
}
}Apabila kod di atas disusun dan dilaksanakan, ia menghasilkan keputusan berikut:
在交换之前，a 的值：100 在交换之前，b 的值：200 在交换之后，a 的值：200 在交换之后，b 的值：100
Ternyata dalam fungsi swap The nilai telah berubah, dan perubahan ini boleh dicerminkan dalam fungsi Utama.
Pas parameter mengikut output
Pernyataan pemulangan boleh digunakan untuk memulangkan hanya nilai daripada fungsi. Walau bagaimanapun, anda boleh menggunakan parameter output untuk mengembalikan dua nilai daripada fungsi tersebut. Parameter output memperuntukkan output data mengikut kaedah kepada diri mereka sendiri, dan sebaliknya serupa dengan parameter rujukan.
Contoh berikut menunjukkan ini:
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();
}
}
}Apabila kod di atas disusun dan dilaksanakan, ia menghasilkan keputusan berikut:
在方法调用之前，a 的值： 100 在方法调用之后，a 的值： 5
Pembolehubah yang diberikan kepada parameter output Tiada penetapan diperlukan. Parameter output amat berguna apabila anda perlu mengembalikan nilai daripada kaedah yang tidak menentukan nilai awal untuk parameter tersebut. Lihat contoh berikut untuk memahami perkara ini:
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();
}
}
}Apabila kod di atas disusun dan dilaksanakan, ia menghasilkan keputusan berikut (bergantung pada input pengguna):
请输入第一个值： 7 请输入第二个值： 8 在方法调用之后，a 的值： 7 在方法调用之后，b 的值： 8
