EntradaClases y métodos. Métodos Descripción de métodos en c #
en la lección 16, Met habló sobre las clases, bueno, continuaré con este tema.
Declaró las variables públicas (públicas), en general no se recomienda declararlas públicas si solo los métodos funcionan con ellas. Estas variables de cualquier parte del código se llaman mediante objetos de clase. Bueno, en general, no solo existe este modificador (público), hay 3 más: interno - las variables están disponibles dentro de 1 espacio de nombres, privadas - las variables están disponibles solo dentro de la clase y protegidas - casi lo mismo que las privadas, pero solo las variables también están disponibles para clases heredadas. Y sobre los métodos, también pueden ser con los mismos modificadores (público, privado, etc.) y pueden devolver un valor (int, double, bool, etc.), y si el método devuelve un valor, debe tener parámetros (que el método entre paréntesis), se declaran como variables y se separan por comas, y cuando se llama al método, los valores para ellos se especifican en el orden en que se declaran. Y hagamos una calculadora de consola. Aquí está el código:
Usando el sistema; // conectar la clase de espacio de nombres Program (/ * * asignar 2 variables privadas * de tipo double el modificador no se puede * especificar porque es privado por defecto * / double FN = 0.0; double SN = 0.0; public void SetFNandSN () / / hacer método abierto no devuelve un valor (Console.WriteLine (); Console.Write ("Ingrese 1 número:"); FN = Convert.ToDouble (Console.ReadLine ()); Console.Write ("Ingrese 2 números:"); SN = Convert .ToDouble (Console.ReadLine ()); / * * llama al método SimpleCalculate * y no necesitas crear un objeto porque * un método en la misma clase * / SimpleCalculate ();) void SimpleCalculate () // crea un método privado porque se llama solo desde esta clase (Console.WriteLine (); Console.WriteLine ("Sum:" + (FN + SN)); Console.WriteLine ("Difference:" + (FN - SN)); Console .WriteLine ("Privado:" + (FN / SN)); Console.WriteLine ("Producto:" + (FN * SN)); Console.WriteLine ();)) clase DemoProgram (static int Main () (Programa ob = new Program (); // crear un nuevo objeto int int intvar1 = 0; Console.WriteLine ("¿Cuántas veces realizar cálculos?"); intvar1 = Convert.ToInt32 (Console.ReadLine ()); // convertir nuestro respuesta a int for (int i = 0; i< intvar1; i++) { ob.SetFNandSN(); //вызываем метод } Console.ReadKey(); //ожидаем нажатия любой клавиши return 0; //возвращаем значение 0 т.к Main() должен возвращать значение int } }
Y, por cierto, los valores se devuelven usando palabra clave regresar. Además, el método Main (), al igual que otros métodos, puede devolver un valor (hice esto para mostrar el uso de la declaración de retorno).
Métodos en Sea Sharp | C #
Los métodos son código escrito que se usa muchas veces (llamado muchas veces). Y para simplificar el código del programa, el uso del método es muy importante. Método es una palabra nueva en el lenguaje C Sharp, la palabra antigua es una función.
Los métodos son lógicos si código dado se realiza más de 2 veces. Entonces es más fácil declarar el nombre del método, qué valores acepta y escribir código que se ejecute correctamente para todos los valores que acepta el método.
Para declarar métodos en C #, debe escribir lo siguiente:
RETURN_VALUE_TYPE FUNCTION_NAME (VARIABLES) (METHOD_CODE)
Si no necesita devolver algo, puede escribir TYPE_RETURNED_VALUE - void.
1. Una función que no devuelve un valor y no acepta argumentos:
vacío printError ()
{
Console .Write ("¡Error! Presione la tecla ...");
Consola .ReadKey ();
}
2. Una función que no devuelve un valor, pero toma un argumento:
void printError (cadena s)
{
Console .Write ("¡Error!" + S + "Pulsar tecla ...");
Consola .ReadKey ();
}
3. Una función que no devuelve un valor, pero toma argumentos:
void printError (cadena s, int i)
{
Console .Write ("¡Error!" + S + "" + i + "Pulsar tecla ...");
Consola .ReadKey ();
}
3. Una función que devuelve valores y toma argumentos:
char shifr (char x, int shifr)
{
x = (carácter) (x + desplazamiento);
return x;
}
Aquí hay un programa de muestra que usa métodos: trabajar con métodos ...
También puede establecer el nivel de seguridad en el método: privado, público.
Por ejemplo:
char privado shifr (char x, int shifr)
{
x = (carácter) (x + desplazamiento);
return x;
}
public char shifr (char x, int shifr)
{
x = (carácter) (x + desplazamiento);
return x;
}
El uso y la creación de métodos en un programa C # es muy similar al enfoque de C ++ que ya conoce. Consideremos esto con más detalle. En C #, cualquier método es un método de alguna clase. Por ejemplo:
Usando el sistema; class Man (nombre de cadena pública; edad int pública; hombre público (cadena n, int a) (nombre = n; edad = a;) public void Show () (Console.WriteLine ("Nombre =" + nombre + "\ tAge = "+ edad);)) class Sample (static void Main () (try (Man obj = new Man (" Fire ", 56); obj.Show ();) catch (Exception er) (Console.WriteLine (er .Mensaje);) Console.Read ();))
En este ejemplo, tenemos una clase Man con un método Show y un constructor. La nota junto a Mostrar es el especificador de acceso público. Si no lo especifica, se establecerá privado de forma predeterminada y no podrá llamarlo desde la clase Sample. Para devolver valores y salir de un método, al igual que en C ++, se utiliza la declaración de retorno. El principio de uso se demuestra en un ejemplo:
Usando el sistema; class SomeClass (public float x; public float y; public SomeClass (float a, float b) (x = a; y = b;) public float Summa () (return x + y;) public void Test (float t) ( if (t == 0) (Console.WriteLine ("0 fue pasado para la división"); return;) Console.WriteLine ("Result =", (x + y) / t);)) class Sample (static void Main () (try (SomeClass obj = new SomeClass (2,3); Console.WriteLine ("Sum is =" + obj.Summa ()); obj.Test (0);) catch (Exception er) (Console.WriteLine (er.Message);) Console.Read ();))
Pasando parámetros
En C #, hay dos formas de pasar parámetros a un método por valor y por referencia. En el primer caso, no es la variable original la que ingresa al método. y su copia, que se destruye cuando el método sale, sin afectar la variable original. Al pasar valores de tipos comunes al método, como int, double, etc. se utiliza pasar por valor. Por lo tanto, cuando se cambia el parámetro, no se produce ningún efecto sobre la variable original. Por ejemplo:
Usando el sistema; class SomeClass (public float x; public SomeClass (float a) (x = a;) public void TryToSetTo99 (float res) (res = 99;) public float Mult (float res) (return res * x;)) class Sample ( static void Main () (try (SomeClass obj = new SomeClass (2); float test = 5; obj.TryToSetTo99 (test); Console.WriteLine (test); // 5 Console.WriteLine (obj.Mult (test)) ; // 10) catch (Exception er) (Console.WriteLine (er.Message);) Console.Read ();))
Es fácil ver que la variable de prueba no cambió su valor después de pasarla a TryToSetTo99 Ahora consideremos la segunda forma de pasar parámetros - por referencia. En este caso, no se pasa una copia del parámetro pasado, sino una referencia al objeto original, que le permite modificar el original. Los objetos de clase siempre se pasan automáticamente por referencia. Por ejemplo:
Usando el sistema; class SomeClass (public int x; public int y;) class SomeClass2 (public void Set (SomeClass obj) (obj.x = 1; obj.y = 2;)) class Sample (static void Main () (try (SomeClass obj = new SomeClass (); SomeClass2 obj2 = new SomeClass2 (); obj.x = 8; obj.y = 9; obj2.Set (obj); // pasado por referencia Console.WriteLine (obj.x + "" + obj . y); // 1 2) catch (Exception er) (Console.WriteLine (er.Message);) Console.Read ();))
En la siguiente sección se mostrará cómo cambiar el valor de una variable de tipo int o double al pasarlo dentro de un método. Tanto en C # como en C ++. los métodos pueden estar sobrecargados. Las reglas de sobrecarga son las mismas que en C ++.
Métodos estáticos
Un método estático es un método con el modificador estático. La diferencia entre un método de clase normal y otro es que se puede llamar a un método con un modificador estático sin crear ningún objeto de clase. Por ejemplo:
Usando el sistema; class Figure (public static void Draw () (Console.WriteLine ("FigureDraw");)) class Sample (static void Main () (try (Figure.Draw ();) catch (Exception er) (Console.WriteLine (er .Message);) Console.Read ();))
Diferencias entre métodos estáticos y ordinarios:
- Los métodos con el modificador estático no tienen esta referencia.
- Un método con el modificador estático puede llamar directamente (sin especificar un nombre de objeto) solo a otro método estático.
- Un método con el modificador estático solo tiene acceso directo a datos estáticos.
Métodos
Cabe señalar que la terminología oficial de C # distingue entre funciones y métodos. En esta terminología, el término "función miembro" incluye no solo métodos, sino también otros miembros que no son datos de una clase o estructura. Esto incluye indexadores, operaciones, constructores, destructores y, quizás de forma algo inesperada, propiedades. Contrastan con los miembros de datos: campos, constantes y eventos.
Declaración de método
En C #, la definición de un método consta de cualquier modificador (como una especificación de accesibilidad), un tipo de retorno seguido del nombre del método, luego una lista de argumentos entre paréntesis y luego el cuerpo del método entre llaves:
[modificadores] return_type MethodName ([parámetros]) (// Cuerpo del método)
Cada parámetro consta de un nombre de tipo de parámetro y un nombre con el que se puede hacer referencia a él en el cuerpo del método. Además, si el método devuelve un valor, la declaración de retorno debe usarse junto con el valor de retorno para indicar el punto de salida.
Si el método no devuelve nada, se especifica el tipo de retorno vacío ya que no es posible omitir el tipo de retorno en absoluto. Si no acepta argumentos, debe haber paréntesis vacíos después del nombre del método. En este caso, no es necesario incluir una declaración de retorno en el cuerpo del método; el método devuelve el control automáticamente cuando llega a la llave de cierre.
Volviendo de un método y devolviendo un valor
En general, la devolución de un método puede ocurrir bajo dos condiciones. Primero, cuando se encuentra una llave que encierra el cuerpo del método. Y en segundo lugar, cuando se ejecuta la declaración regresar... Hay dos formas de declaración de retorno: una para métodos de tipo void ( retorno del método), es decir. aquellos métodos que no devuelven valores, y el otro es para métodos que devuelven valores específicos ( valor de retorno).
Tomemos un ejemplo:
Usando el sistema; utilizando System.Collections.Generic; utilizando System.Linq; usando System.Text; namespace ConsoleApplication1 (class MyMathOperation (public double r; public string s; // Devuelve el área de un círculo public double sqrCircle () (return Math.PI * r * r;) // Devuelve la circunferencia public double longCircle () (return 2 * Math .PI * r;) public void writeResult () (Console.WriteLine ("Calcular área o longitud? S / l:"); s = Console.ReadLine (); s = s.ToLower (); if (s == "s") (Console.WriteLine ("El área del círculo es (0: #. ###)", sqrCircle ()); return;) else if (s == "l ") (Console.WriteLine (" La longitud del círculo es igual a (0: #. ##) ", longCircle ()); return;) else (Console.WriteLine (" Ingresaste el carácter incorrecto ");))) class Program (static void Main (string args) (Console. WriteLine ("Ingresar radio:"); string radius = Console.ReadLine (); MyMathOperation newOperation = new MyMathOperation (r = double.Parse (radius)); newOperation.writeResult (); Console.ReadLine ();)))
Usando parámetros
Al llamar a un método, puede pasarle uno o más valores. El valor pasado al método se llama argumento... Y la variable que toma un argumento se llama parámetro formal, o simplemente parámetro... Los parámetros se declaran entre paréntesis después del nombre del método. La sintaxis para declarar parámetros es la misma que para las variables. Y el alcance de los parámetros es el cuerpo del método. Excepto en el caso especial de pasar argumentos a un método, los parámetros actúan como cualquier otra variable.
En general, los parámetros se pueden pasar a un método por valor o por referencia. Cuando se pasa una variable por referencia, el método llamado obtiene la variable en sí, por lo que cualquier cambio que sufra dentro del método permanecerá vigente después de que se complete. Pero si una variable se pasa por valor, el método llamado obtiene una copia de esa variable, lo que significa que cualquier cambio que se le haga después de que finalice el método se perderá. Para tipos de datos complejos, pasar por referencia es más eficiente debido a la gran cantidad de datos que se deben copiar al pasar por valor.
Tomemos un ejemplo:
Usando el sistema; utilizando System.Collections.Generic; utilizando System.Linq; usando System.Text; espacio de nombres ConsoleApplication1 (class myClass (public void someMethod (double myArr, int i) (myArr = 12.0; i = 12;)) class Program (static void Main (string args) (double arr1 = (0, 1.5, 3.9, 5.1) ; int i = 0; Console.WriteLine ("Array Arr1 antes de llamar al método:"); foreach (doble d en arr1) Console.Write ("(0) \ t", d); Console.WriteLine ("\ nVariable i = (0) \ n ", i); Console.WriteLine (" Llamando al método someMethod ... "); myClass ss = new myClass (); ss.someMethod (arr1, i); Console.WriteLine (" Arr1 matriz después de la llamada al método: "); foreach (doble d en arr1) Console.Write (" (0) \ t ", d); Console.WriteLine (" \ nVariable i = (0) \ n ", i); Console .ReadLine ();)))