C método #
Uma forma é colocar algumas declarações relevantes agrupadas por um bloco de instruções para executar a tarefa. Cada programa tem, pelo menos, uma classe C # com um método Main.
Para usar um método, é necessário:
- método definição
- Chame o método
C # método, tal como definido em
Ao definir um método, fundamentalmente falando, é uma declaração dos elementos da estrutura. Em C #, a definição da sintaxe método é como se segue:
<Access especificador> <Return Type> <Nome do método> (lista de parâmetros)
{
corpo do método
}
A seguir estão os elementos individuais de:
- Especificador de acesso: modificador de acesso, variáveis de decisão ou método para uma outra visibilidade classe.
- Tipo de retorno: tipo de retorno, um método pode retornar um valor.O tipo de retorno é o tipo de dados do valor retornado pelo método. Se o método não retorna nenhum valor, o tipo de retorno énulo.
- nome de Método: o nome do método, é um identificador único, e é sensível a maiúsculas.Ele não pode ser o mesmo que outro identificador declaração da classe.
- Lista de parâmetros: a lista de parâmetros, entre parênteses, o parâmetro é utilizado para a transmissão de dados e método de recepção.Lista de parâmetros tipo de parâmetro se refere ao método, a ordem e quantidade. O parâmetro é opcional, isto é, um método não pode conter parâmetros.
- corpo do método: corpo do método, incluindo a necessidade de concluir as tarefas do conjunto de instruções.
Exemplos
O fragmento de código a seguir mostra uma funçãoFindMax,que aceita dois valores inteiros, e retorna o maior dos dois valores. Ele tem um modificador de acesso público, para que ele possa ser acessado usando a instância da classe de fora da classe.
class NumberManipulator
{
public int FindMax(int num1, int num2)
{
/* 局部变量声明 */
int result;
if (num1 > num2)
result = num1;
else
result = num2;
return result;
}
...
}
Chamar métodos em C #
Você pode usar o nome do método de chamada. O exemplo a seguir ilustra esse ponto:
using System;
CalculatorApplication namespace
{
NumberManipulator classe
{
public int FindMax (int num1, int num2)
{
/ * Declaração de variável local * /
resultado int;
if (num1> num2)
result = num1;
mais
result = num2;
retornar resultado;
}
static void Main (string [] args)
{
/ * Definições de variáveis locais * /
int a = 100;
int b = 200;
int ret;
NumberManipulator n = new NumberManipulator ();
// Chamada FindMax método ret = n.FindMax (a, b);
Console.WriteLine ( "Max é: {0}", ret);
Console.ReadLine ();
}
}
}
Quando o código acima é compilado e executado, ele produz os seguintes resultados:
O valor máximo é: 200
Você pode também outros tipos de instância de classe métodos públicos chamados de outro classe. Por exemplo, o métodoFindMaxpertencem classeNumberManipulator,você pode chamá-lo de outroteste declasse em.
using System;
CalculatorApplication namespace
{
NumberManipulator classe
{
public int FindMax (int num1, int num2)
{
/ * Declaração de variável local * /
resultado int;
if (num1> num2)
result = num1;
mais
result = num2;
retornar resultado;
}
}
Teste de classe
{
static void Main (string [] args)
{
/ * Definições de variáveis locais * /
int a = 100;
int b = 200;
int ret;
NumberManipulator n = new NumberManipulator ();
// Chamada FindMax método ret = n.FindMax (a, b);
Console.WriteLine ( "Max é: {0}", ret);
Console.ReadLine ();
}
}
}
Quando o código acima é compilado e executado, ele produz os seguintes resultados:
最大值是： 200
chamadas de método recursivo
Um método pode chamar a si mesmo. Isso é chamadorecursão.O exemplo a seguir utiliza uma função recursiva para calcular o fatorial de um número de telefone:
using System;
CalculatorApplication namespace
{
NumberManipulator classe
{
public int factorial (int num)
{
/ * Definições de variáveis locais * /
resultado int;
if (== num 1)
{
retornar 1;
}
mais
{
result = fatorial (num - 1) * num;
retornar resultado;
}
}
static void Main (string [] args)
{
NumberManipulator n = new NumberManipulator ();
// Chamar o método Console.WriteLine fatorial ( "6 factorial é: {0}", n.factorial (6));
Console.WriteLine ( "7 factorial é: {0}", n.factorial (7));
Console.WriteLine ( "8 factorial é: {0}", n.factorial (8));
Console.ReadLine ();
}
}
}
Quando o código acima é compilado e executado, ele produz os seguintes resultados:
6 factorial é: 720 7 factorial é: 5040 8 factorial é: 40320
passagem de parâmetro
Quando você chamar um método com parâmetros, você precisa passar parâmetros para o método. Em C #, existem três maneiras de passar parâmetros para o método:
| 方式 | 描述 |
|---|---|
| 值参数 | 这种方式复制参数的实际值给函数的形式参数，实参和形参使用的是两个不同内存中的值。在这种情况下，当形参的值发生改变时，不会影响实参的值，从而保证了实参数据的安全。 |
| 引用参数 | 这种方式复制参数的内存位置的引用给形式参数。这意味着，当形参的值发生改变时，同时也改变实参的值。 |
| 输出参数 | 这种方式可以返回多个值。 |
Passando parâmetros por valor
Esta é a passagem de parâmetro padrão. Desta forma, quando você chamar um método que cria um novo local de armazenamento para cada parâmetro.
O valor do parâmetro real é copiado para parâmetros, argumentos e parâmetros formais usando dois valores de memória diferente. Assim, quando as mudanças no valor do parâmetro não afetará o valor do argumento, garantindo assim a segurança dos dados de parâmetro real. O exemplo a seguir ilustra esse conceito:
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();
}
}
}
Quando o código acima é compilado e executado, ele produz os seguintes resultados:
在交换之前，a 的值：100 在交换之前，b 的值：200 在交换之后，a 的值：100 在交换之后，b 的值：200
Os resultados mostraram que, mesmo dentro da função altera o valor, o valor de qualquer mudança tinha acontecido.
Passar parâmetros por referência
parâmetro de referência éuma referência para a localizaçãodememória variável.Quando os parâmetros passados por referência, com o valor do parâmetro é diferente é que ela não cria um novo local de armazenamento para estes parâmetros. parâmetro de referência representa o parâmetro real com o método tem a mesma localização de memória.
Em C #, usando a palavra-chaveref para declarar um parâmetro de referência.O exemplo a seguir ilustra esse ponto:
using System;
CalculatorApplication namespace
{
NumberManipulator classe
{
troca public void (ref int x, int y ref)
{
int temp;
temp = x; / * salvar o valor de x * /
X = Y; / * Y é atribuída ao x * /
y = temperatura; / * a atribuição temp para y * /
}
static void Main (string [] args)
{
NumberManipulator n = new NumberManipulator ();
/ * Definições de variáveis locais * /
int a = 100;
int b = 200;
Console.WriteLine ( "Antes da troca, um valor de: {0}", a);
Console.WriteLine ( "antes da troca, os valores B: {0}", b);
/ * Chame a função de valor de troca * /
n.swap (ref a, ref b);
Console.WriteLine ( "Depois de uma troca, um valor de: {0}", a);
Console.WriteLine ( "depois de uma troca, os valores B: {0}", b);
Console.ReadLine ();
}
}
}
Quando o código acima é compilado e executado, ele produz os seguintes resultados:
在交换之前，a 的值：100 在交换之前，b 的值：200 在交换之后，a 的值：200 在交换之后，b 的值：100
Os resultados mostraram que o valor da funçãode comutaçãodentro da mudança, e esta alteração pode reflectir-senafunçãoprincipal.
Passando parâmetros de saída
instrução de retorno só pode ser utilizado para retornar um valor de uma função. No entanto, você pode usar oparâmetro de saídapara retornar dois valores de funções. método de saída de dados de saída parâmetro irá atribuir os seus próprios, e outros parâmetros de referência similares.
O exemplo a seguir ilustra esse ponto:
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();
}
}
}
Quando o código acima é compilado e executado, ele produz os seguintes resultados:
在方法调用之前，a 的值： 100 在方法调用之后，a 的值： 5
Fornecida às variáveis de parâmetro de saída não requer a atribuição. Quando você precisa retornar um valor a partir do valor inicial do parâmetro não especificar um método, em particular os parâmetros de saída úteis. Considere o seguinte exemplo para entender isso:
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();
}
}
}
Quando o código acima é compilado e executado, ele produz o seguinte resultado (dependendo da entrada do usuário):
Por favor, indique um valor: 7 Digite o segundo valor: 8 Após a chamada de método, um valor: 7 Após a chamada de método, valores de b: 8