Metoda C #

Metoda C #, jak określono w

Przy określaniu sposobu, zasadniczo rzecz biorąc, jest to zestawienie elementów konstrukcji. W języku C #, metoda definicji składnia jest następująca:

<Dostęp Specyfikator> <Powrót Rodzaj> <Metoda Name> (Lista parametrów)
{
   metoda ciała
}

Poniżej przedstawiono poszczególne elementy:

• Dostęp Specyfikator: modyfikator dostępu, zmienne decyzyjne lub metody dla innej klasy widoczności.
• Zwraca typ: typ zwracany, metoda może zwracać wartość.Zwracany typ to typ danych wartości zwracanej przez metodę. Jeśli metoda nie zwraca żadnych wartości, typ zwracany jestnieaktualna.
• Nazwa metody: nazwa metody, to unikatowy identyfikator i jest wielkość liter.Nie może być taka sama, jak innych zgłoszenia identyfikator klasy.
• Lista parametrów: lista parametrów, w nawiasach, parametr służy do transmisji danych i sposobu przyjmującego.Lista parametrów parametr typu odnosi się do sposobu, w kolejności i ilości. Parametr jest opcjonalne, to znaczy, sposób może zawierać parametry.
• Metoda ciała: ciało metody, łącznie z koniecznością wykonywania zadań zestaw instrukcji.

Przykłady

Poniższy fragment kodu pokazuje funkcjęFindMax,który przyjmuje dwie wartości całkowite i zwraca większą z dwóch wartości. Ma modyfikator dostępu publicznego, więc można go uzyskać za pomocą instancji klasy spoza klasy.

class NumberManipulator
{
   public int FindMax(int num1, int num2)
   {
      /* 局部变量声明 */
      int result;

      if (num1 > num2)
         result = num1;
      else
         result = num2;

      return result;
   }
   ...
}

Zadzwoń do metod w C #

Można użyć nazwy metody wywołującego. Poniższy przykład ilustruje ten punkt:

using System;

nazw CalculatorApplication
{
   Klasa NumberManipulator
   {
      public int FindMax (int num1, int num2)
      {
         / * Deklaracja Zmienna lokalna * /
         int wynik;

         if (num1> num2)
            wynik = num1;
         więcej
            wynik = num2;

         powrót rezultat;
      }
      static void Main (string [] args)
      {
         / * Definicje zmiennej lokalnej * /
         int a = 100;
         int b = 200;
         int ret;
         NumberManipulator n = new NumberManipulator ();

         // Wywołanie FindMax Metoda ret = n.FindMax (a, b);
         Console.WriteLine ( "Max jest: {0}", ret);
         Console.ReadLine ();
      }
   }
}

Gdy powyższy kod jest kompilowany i wykonany, że daje następujące wyniki:

Maksymalna wartość wynosi: 200

Można także inne rodzaje publicznych metod instancji klasy wywoływana z innej klasy. Na przykład, metodaFindMaxnależą klasęNumberManipulator,można nazwać to z innej klasytestin.

using System;

nazw CalculatorApplication
{
    Klasa NumberManipulator
    {
        public int FindMax (int num1, int num2)
        {
            / * Deklaracja Zmienna lokalna * /
            int wynik;

            if (num1> num2)
                wynik = num1;
            więcej
                wynik = num2;

            powrót rezultat;
        }
    }
    Klasa kontrolna
    {
        static void Main (string [] args)
        {
            / * Definicje zmiennej lokalnej * /
            int a = 100;
            int b = 200;
            int ret;
            NumberManipulator n = new NumberManipulator ();
            // Wywołanie FindMax Metoda ret = n.FindMax (a, b);
            Console.WriteLine ( "Max jest: {0}", ret);
            Console.ReadLine ();

        }
    }
}

Gdy powyższy kod jest kompilowany i wykonany, że daje następujące wyniki:

最大值是： 200

Rekurencyjne wywołania metod

Metoda może wywołać siebie. To się nazywarekurencji.Poniższy przykład używa funkcji rekurencyjnej, aby obliczyć silnię liczby:

using System;

nazw CalculatorApplication
{
    Klasa NumberManipulator
    {
        public int silnia (int num)
        {
            / * Definicje zmiennej lokalnej * /
            int wynik;

            if (num == 1)
            {
                zwraca 1;
            }
            więcej
            {
                wynik = silnia (num - 1) * num;
                powrót rezultat;
            }
        }
    
        static void Main (string [] args)
        {
            NumberManipulator n = new NumberManipulator ();
            // Wywołanie silni metody Console.WriteLine ( "6 silnia to: {0}", n.factorial (6));
            Console.WriteLine ( "7 silnia to: {0}", n.factorial (7));
            Console.WriteLine ( "8 silnia to: {0}", n.factorial (8));
            Console.ReadLine ();

        }
    }
}

Gdy powyższy kod jest kompilowany i wykonany, że daje następujące wyniki:

6 silnia jest: 720
7 silnia jest: 5040
8 silnia jest: 40320

parametr przechodzącej

Podczas wywołania metody z parametrami, musisz przekazać parametry do metody. W języku C #, istnieją trzy sposoby przekazywania parametrów do metody:

Przekazywanie parametrów przez wartość

Jest to przejście domyślne parametrów. W ten sposób, gdy dzwonisz to metoda, która tworzy nową lokalizację zapisu dla każdego parametru.

Rzeczywista wartość parametru jest kopiowana do parametrów, argumentów i parametrów stosowanych w dwóch różnych wartości w pamięci. Tak więc, gdy zmienia się wartość parametru nie ma wpływu na wartość argumentu, zapewniając tym samym bezpieczeństwo danych rzeczywistego parametru. Poniższy przykład ilustruje tę koncepcję:

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();
      }
   }
}

Gdy powyższy kod jest kompilowany i wykonany, że daje następujące wyniki:

在交换之前，a 的值：100
在交换之前，b 的值：200
在交换之后，a 的值：100
在交换之后，b 的值：200

Wyniki pokazały, że nawet w obrębie funkcja zmienia wartość, wartość jakichkolwiek zmian zaszło.

Przekazać parametry przez odniesienie

Parametr referencyjnyjest odwołaniem do zmiennej lokalizacji pamięci.Gdy parametry przekazywane przez referencję, z wartością parametru jest inna jest to, że nie tworzy nowego miejsca przechowywania tych parametrów. Parametr referencyjny reprezentuje rzeczywisty parametr metody ma ten sam obszar pamięci.

W języku C #, używając słowa kluczowegoref zadeklarować parametr odniesienia.Poniższy przykład ilustruje ten punkt:

using System;
nazw CalculatorApplication
{
   Klasa NumberManipulator
   {
      public void swap (ref int x, int y ref)
      {
         int temp;

         temp = x / * zapisać wartość x * /
         X = Y / * y jest przypisany x * /
         y = temp; / * przypisanie do temp y * /
       }
   
      static void Main (string [] args)
      {
         NumberManipulator n = new NumberManipulator ();
         / * Definicje zmiennej lokalnej * /
         int a = 100;
         int b = 200;

         Console.WriteLine ( "Przed wymianą, wartość: {0}", a);
         Console.WriteLine ( "przed wymianą, b wartości: {0}", b);

         / * Wywołanie funkcji do wartości wymiennej * /
         n.swap (ref ref a, b);

         Console.WriteLine ( "Po wymianie, wartość: {0}", a);
         Console.WriteLine ( "po wymianie, wartość B: {0}", b);
 
         Console.ReadLine ();

      }
   }
}

Gdy powyższy kod jest kompilowany i wykonany, że daje następujące wyniki:

在交换之前，a 的值：100
在交换之前，b 的值：200
在交换之后，a 的值：200
在交换之后，b 的值：100

Wyniki wykazały, że wartość funkcjizamianyw obrębie zmiany, a zmiana ta może zostać odzwierciedlonewfunkcjigłównego.

Przekazywanie parametrów przez wyjście

Instrukcja return może być używany tylko do zwracania wartości z funkcji. Jednakże, można użyćparametru wyjściowego wrócić dwóch wartości z funkcji.Wyjście danych Sposób wyświetlania parametrów przypisze własną rękę, i inne podobne parametry referencyjne.

Poniższy przykład ilustruje ten 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();

      }
   }
}

Gdy powyższy kod jest kompilowany i wykonany, że daje następujące wyniki:

在方法调用之前，a 的值： 100
在方法调用之后，a 的值： 5

Dostarczane do zmiennych parametrów wyjścia nie wymaga przyporządkowania. Kiedy trzeba zwrócić wartość z początkowej wartości parametru nie jest określony w sposób, parametr wyjściowy jest szczególnie przydatna. Rozważmy następujący przykład, aby to zrozumieć:

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();
      }
   }
}

Jeżeli powyższy kod jest kompilowany i wykonywany, to daje następujące wyniki (w zależności od danych wprowadzonych przez użytkownika):

Proszę wprowadzić wartość:
7
Proszę wprowadzić drugą wartość:
8
Po wywołaniu metody wartość: 7
Po wywołaniu metody, b wartości: 8