C Método #
Una forma es poner algunas declaraciones pertinentes agrupados juntos por un bloque de instrucciones para llevar a cabo la tarea. Cada programa tiene por lo menos una clase C # con un método Main.
Para utilizar un método, se necesita:
- método de definición
- Llamar al método
C # método como se define en
Cuando se define un método, fundamentalmente hablando, es una declaración de los elementos de la estructura. En C #, los métodos de definición de sintaxis son los siguientes:
<Especificador de acceso> <Tipo de retorno> <Nombre de método> (lista de parámetros)
{
método Cuerpo
}
Los siguientes son los elementos individuales de:
- Acceso a quien especifica: modificador de acceso, las variables de decisión o método para otra clase de visibilidad.
- Tipo de retorno: Tipo de cambio, un método puede devolver un valor.El tipo de retorno es el tipo de datos del valor devuelto por el método. Si el método no devuelve ningún valor, el tipo de retorno esnulo.
- Nombre de método: el nombre del método, es un identificador único, y es sensible a mayúsculas.No puede ser el mismo que otra declaración de la clase identificador.
- Lista de parámetros: la lista de parámetros, entre paréntesis, el parámetro se utiliza para la transmisión de datos y el método de recepción.lista de parámetros tipo de parámetro se refiere al método, el orden y la cantidad. El parámetro es opcional, es decir, un método no puede contener parámetros.
- Método cuerpo: cuerpo del método, incluyendo la necesidad de completar las tareas del conjunto de instrucciones.
Ejemplos
El siguiente fragmento de código muestra una funciónencontrarMax,que acepta dos valores enteros y devuelve el mayor de dos valores. Tiene un modificador de acceso público, por lo que se puede acceder mediante la instancia de la clase desde fuera de la clase.
class NumberManipulator
{
public int FindMax(int num1, int num2)
{
/* 局部变量声明 */
int result;
if (num1 > num2)
result = num1;
else
result = num2;
return result;
}
...
}
Llamar a métodos en C #
Puede usar el nombre del método de llamada. El siguiente ejemplo ilustra este punto:
using System;
CalculatorApplication espacio de nombres
{
NumberManipulator clase
{
public int encontrarMax (int num1, int num2)
{
/ * Declaración de variable local * /
int resultado;
si (num1> num2)
resultado = num1;
otro
resultado = num2;
return resultado;
}
static void main (String [] args)
{
/ * Definiciones de variables locales * /
int a = 100;
int b = 200;
int ret;
NumberManipulator n = new NumberManipulator ();
// Llamar encontrarMax método ret = n.FindMax (a, b);
Console.WriteLine ( "Max es: {0}", ret);
Console.ReadLine ();
}
}
}
Cuando el código se compila y ejecuta, produce los siguientes resultados:
El valor máximo es: 200
También puede otros tipos de métodos públicos instancia de clase llamada de otra clase. Por ejemplo, el métodoencontrarMaxpertenecen claseNumberManipulator,se le puede llamar de otra clasede pruebaen.
using System;
CalculatorApplication espacio de nombres
{
NumberManipulator clase
{
public int encontrarMax (int num1, int num2)
{
/ * Declaración de variable local * /
int resultado;
si (num1> num2)
resultado = num1;
otro
resultado = num2;
return resultado;
}
}
clase Test
{
static void main (String [] args)
{
/ * Definiciones de variables locales * /
int a = 100;
int b = 200;
int ret;
NumberManipulator n = new NumberManipulator ();
// Llamar encontrarMax método ret = n.FindMax (a, b);
Console.WriteLine ( "Max es: {0}", ret);
Console.ReadLine ();
}
}
}
Cuando el código se compila y ejecuta, produce los siguientes resultados:
最大值是： 200
llamadas a métodos recursivos
Un método puede llamar a la asistencia. Esto se llamarecursión.En el siguiente ejemplo se utiliza una función recursiva para calcular el factorial de un número:
using System;
CalculatorApplication espacio de nombres
{
NumberManipulator clase
{
public int factorial (int num)
{
/ * Definiciones de variables locales * /
int resultado;
si (== num 1)
{
volver 1;
}
otro
{
resultado = factorial (num - 1) * num;
return resultado;
}
}
static void main (String [] args)
{
NumberManipulator n = new NumberManipulator ();
// Llamar al método factorial Console.WriteLine ( "6 factorial es: {0}", n.factorial (6));
Console.WriteLine ( "factorial 7 son: {0}", n.factorial (7));
Console.WriteLine ( "8 factorial es: {0}", n.factorial (8));
Console.ReadLine ();
}
}
}
Cuando el código se compila y ejecuta, produce los siguientes resultados:
6 factorial es: 720 7 factorial es: 5040 8 factorial es: 40320
el paso de parámetros
Cuando se llama a un método con parámetros, es necesario pasar parámetros al método. En C #, hay tres formas de pasar parámetros al método:
| 方式 | 描述 |
|---|---|
| 值参数 | 这种方式复制参数的实际值给函数的形式参数，实参和形参使用的是两个不同内存中的值。在这种情况下，当形参的值发生改变时，不会影响实参的值，从而保证了实参数据的安全。 |
| 引用参数 | 这种方式复制参数的内存位置的引用给形式参数。这意味着，当形参的值发生改变时，同时也改变实参的值。 |
| 输出参数 | 这种方式可以返回多个值。 |
Paso de parámetros por valor
Este es el paso de parámetros por defecto. De esta manera, cuando se llama a un método que crea una nueva ubicación de almacenamiento para cada parámetro.
El valor de parámetro real se copia en los parámetros, los argumentos y parámetros utilizados en dos valores de memoria diferente. Por lo tanto, cuando cambia el valor del parámetro no afectarán el valor del argumento, lo que garantiza la seguridad de los datos de parámetro real. El siguiente ejemplo ilustra este concepto:
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();
}
}
}
Cuando el código se compila y ejecuta, produce los siguientes resultados:
在交换之前，a 的值：100 在交换之前，b 的值：200 在交换之后，a 的值：100 在交换之后，b 的值：200
Los resultados mostraron que, incluso dentro de la función cambia el valor, el valor de cualquier cambio había ocurrido.
Pasar parámetros por referencia
parámetro de referencia esuna referencia a la posicióndememoria variable.Cuando los parámetros pasados por referencia, con el valor del parámetro es diferente es que no crea una nueva ubicación de almacenamiento para estos parámetros. parámetro de referencia representa el parámetro real con el método tiene la misma ubicación de memoria.
En C #, usando la palabra claveref declarar un parámetro de referencia.El siguiente ejemplo ilustra este punto:
using System;
CalculatorApplication espacio de nombres
{
NumberManipulator clase
{
public void intercambio (ref int x, ref y int)
{
int temp;
temp = x; / * guardar el valor de x * /
x = y; / * y se asigna a la x * /
y = temp; / * la asignación temporal de y * /
}
static void main (String [] args)
{
NumberManipulator n = new NumberManipulator ();
/ * Definiciones de variables locales * /
int a = 100;
int b = 200;
Console.WriteLine ( "Antes del cambio, su valor es: {0}", a);
Console.WriteLine ( "Antes del cambio, los valores de b: {0}", b);
/ * Llame a la función al valor de cambio * /
n.swap (ref a, ref b);
Console.WriteLine ( "Después de un intercambio, un valor de: {0}", a);
Console.WriteLine ( "después de un intercambio, los valores de b: {0}", b);
Console.ReadLine ();
}
}
}
Cuando el código se compila y ejecuta, produce los siguientes resultados:
在交换之前，a 的值：100 在交换之前，b 的值：200 在交换之后，a 的值：200 在交换之后，b 的值：100
Los resultados mostraron que el valor de la función deintercambioen el cambio, y este cambio se pueden reflejar enlafunciónprincipal.
Paso de parámetros por Salida
sentencia de retorno sólo se puede utilizar para devolver un valor desde una función. Sin embargo, puede utilizar elparámetro de salidapara devolver dos valores de funciones. método de salida de datos de salida de parámetros asignará su propia, y otros parámetros de referencia similares.
El siguiente ejemplo ilustra este punto:
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();
}
}
}
Cuando el código se compila y ejecuta, produce los siguientes resultados:
在方法调用之前，a 的值： 100 在方法调用之后，a 的值： 5
Suministrada a las variables de parámetros de salida no requiere la asignación. Cuando tenga que devolver un valor desde el valor inicial de un parámetro no está especificado en el método, el parámetro de salida es particularmente útil. Considere el siguiente ejemplo para entender esto:
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();
}
}
}
Cuando el código se compila y ejecuta, produce el resultado siguiente (dependiendo de la entrada del usuario):
Por favor, introduzca un valor: 7 Por favor, introduzca el segundo valor: 8 Después de la llamada a un método, un valor: 7 Después de la llamada al método, los valores de b: 8