0% encontró este documento útil (0 votos)
41 vistas5 páginas

Clases y Métodos en C# Explicados

Cargado por

H D
Derechos de autor
© All Rights Reserved
Nos tomamos en serio los derechos de los contenidos. Si sospechas que se trata de tu contenido, reclámalo aquí.
Formatos disponibles
Descarga como DOCX, PDF, TXT o lee en línea desde Scribd
0% encontró este documento útil (0 votos)
41 vistas5 páginas

Clases y Métodos en C# Explicados

Cargado por

H D
Derechos de autor
© All Rights Reserved
Nos tomamos en serio los derechos de los contenidos. Si sospechas que se trata de tu contenido, reclámalo aquí.
Formatos disponibles
Descarga como DOCX, PDF, TXT o lee en línea desde Scribd

Las clases son los tipos más fundamentales de C#.

Una clase es
una estructura de datos que combina estados (campos) y acciones
(métodos y otros miembros de función) en una sola unidad. Una
clase proporciona una definición para instancias creadas
dinámicamente de la clase, también conocidas como objetos. Las
clases admiten herencia y polimorfismo, mecanismos por los que
las clases derivadas pueden extender y especializar clases base.

Las clases nuevas se crean mediante declaraciones de clase. Una


declaración de clase se inicia con un encabezado que especifica los
atributos y modificadores de la clase, el nombre de la clase, la clase
base (si se indica) y las interfaces implementadas por la clase. Al
encabezado le sigue el cuerpo de la clase, que consta de una lista
de declaraciones de miembros escritas entre los delimitadores { y }.

Clases base

Una declaración de clase puede especificar una clase base


colocando después del nombre de clase y los parámetros de tipo
dos puntos seguidos del nombre de la clase base. Omitir una
especificación de la clase base es igual que derivarla del
tipo object. En el ejemplo siguiente, la clase base
de Point3D es Point y la clase base de Point es object:

La instrucción switch nos va a facilitar mucho trabajo en


determinados programas. Supongamos que queremos hacer un
programa que dé un número entero y escriba por pantalla su valor
ordinal (primero, segundo, etc...).
Los operadores lógicos condicionales se utilizan para añadir
condiciones, tanto en los if como en cualquiera de las
instrucciones que lleven una condición (ya las veremos).

Vamos a suponer, tomando alguno de los ejemplos anteriores, que


queremos hacer algo si una variable vale 1 ó 5.

Lo haríamos así:

La instrucción "if" tiene un par de modificadores que ayudan a tener


mayor control del programa. Éstas son else y else if. Ambas son
opcionales.
La diferencia entre este ejemplo y el de la lección anterior con 3
instrucciones "if", es que esta sentencia está anidada. Quiere decir
que cambia la forma de actuación.
La instrucción "if " es algo básico en programación, y se utiliza para
el control de flujo del programa.

Vamos a empezar con una muy sencilla para ver si funcionamiento:

Declaramos una variable "a" que toma el valor de cinco (5). Con la
instrucción "if" comprobamos si "a" vale "5". Para comprobar si una
variable es igual a algún valor se utiliza el operador de
comparación de igualdad, que son dos signos de igual juntos
(==).

Las clases en C# se definen de forma parecida a los registros


(struct), sólo que ahora, además de variables (que representan sus
detalles internos, y que llamaremos sus "atributos"), también
incluirán funciones (las acciones que puede realizar ese objeto, que
llamaremos sus "métodos"). Atributos y métodos formarán parte de
"un todo", en vez de estar separados en distintas partes del
programa. Esto es lo que se conoce como "Encapsulación".

Así, una clase "Puerta" se podría declarar así:

Para hacer uso de los métodos creados, únicamente necesitamos


llamarlos desde donde lo utilicemos.

Para los métodos sin retorno de información únicamente colocamos


el nombre del método seguido de paréntesis.

1 MetodoUno();
Si el método no retorna información, pero si requiere parámetros,
hay que enviar esos parámetros entre los paréntesis.

1 MetodoUno(3);
Los métodos con retorno de datos requieren de una variable
previamente, para almacenar el dato devuelto por el método.

1 int respuesta = MetodoDos();


En caso de que el método necesite parámetros los colocamos entre
los paréntesis.

Veamos la estructura que debe tener un método simple.

1 public void MetodoUno(){}

Se define el permiso de acceso, public.

Establecemos si retornara o no algún resultado, void no regresa


información.

Agregamos un nombre (MetodoUno); seguido de paréntesis, entre


los paréntesis se pueden agregar parámetros.

Por ultimo se colocan llaves, entre estas llaves se realizan todas


las operaciones.

Veamos algunos ejemplos de métodos simples, para identificar los


que podemos ver en el código.

Un método es un bloque de código que contiene una serie de


instrucciones. Un programa hace que se ejecuten las instrucciones
al llamar al método y especificando los argumentos de método
necesarios. En C#, todas las instrucciones ejecutadas se realizan
en el contexto de un método. El método Main es el punto de
entrada para cada aplicación de C# y se llama mediante Common
Language Runtime (CLR) cuando se inicia el programa.

Los métodos se declaran en una class o struct al especificar:

Un nivel de acceso opcional, como, por ejemplo, public o private. El


valor predeterminado es private.

Modificadores opcionales, como, por ejemplo, abstract o sealed.

El valor devuelto o, si el método no tiene ninguno, void.

El nombre del método.


Los parámetros del método. Los parámetros de método se
encierran entre paréntesis y se separan por comas. Los paréntesis
vacíos indican que el método no requiere parámetros.

Los operadores de incremento (++) y decremento (--) sirven para


incrementar o disminuir el valor de una variable en una unidad. Por
ejemplo:

num++;

hará que num incremente su valor en una unidad, es decir, si valía


10 ahora vale 11. Los operadores de incremento y decremento se
pueden poner delante (preincremento ó predecremento) o bien
detrás (postincremento ó postdecremento), teniendo
comportamientos distintos. Me explico: si hay un postincremento o
postdecremento, primero se toma el valor de la variable y después
se incrementa o decrementa. En caso contrario, si lo que hay es un
preincremento o un predecremento, primero se incrementa o
decrementa la variable y después se toma el valor de la misma. En
una línea como la anterior esto no se ve claro, porque, además, el
resultado sería el mismo que poniendo ++num. Sin embargo,
veamos este otro ejemplo (num vale 10):

Los espacios de nombres son un modo sencillo y muy eficaz de


tener absolutamente todas las clases perfectamente organizadas,
tanto las que proporciona el .NET Framework como las que
podamos escribir nosotros. Podemos verlo verdaderamente claro
con echar un simple vistazo al explorador de objetos de Visual
[Link] (menú Ver...Otras ventanas...Examinador de objetos, o
bien la combinación de teclas Ctrl+Alt+J).

Lo que tenemos a la izquierda es toda la biblioteca de clases


del .NET Framework. Como ves están completamente organizadas
en árbol, de modo que toda ella está fuertemente estructurada.
Además, fíjate bien en la rama que está parcialmente desplegada.
No se trata de nada que esté dentro de la biblioteca de clases
del .NET Framework, sino de una aplicación diseñada en C#. Por lo
tanto, como ves, nosotros también podemos definir nuestros
propios espacios de nombres.

Las ventajas principales de estos espacios de nombres son su


fuerte estructuración y, sobre todo, la posibilidad de usar varias
clases distintas con el mismo nombre en un mismo programa si los
espacios de nombres son diferentes. No, no es el mismo perro con
distinto collar. Es relativamente fácil que varios fabricantes de
software den el mismo nombre a sus clases pues, al fin y al cabo,
solemos basarnos en nuestro idioma para nombrarlas. Sin embargo
es mucho menos probable que los espacios de nombres coincidan,
sobre todo si se tiene la precaución de seguir las recomendaciones
de Microsoft, que consisten en comenzar por llamar al espacio de
nombres igual que se llama la compañía, más luego lo que sea. Por
ejemplo, si mi compañía se llama NISU, y escribo un espacio de
nombres con clases que realizan complejos cálculos para la
navegación espacial, mi espacio de nombres podría llamarse
NISUNavegacionEspacial. Si, después, IBM desarrolla una
biblioteca similar, su espacio de nombres se llamaría
IBMNavegacionEspacial (venga, hombre, échame una mano...
imagínate que los de IBM hablan español). Aunque el nombre de
mis clases coincida en gran número con los de las clases de IBM,
cualquier desarrollador podría utilizar las dos sin problemas gracias
a los espacios de nombres.

Common questions

Con tecnología de IA

El propósito fundamental de una clase en C# es combinar estados (campos) y acciones (métodos y otros miembros de función) en una sola estructura de datos. Esto proporciona una definición para instancias dinámicas de la clase, conocidas como objetos, y permite la herencia y el polimorfismo de clases. La encapsulación se refiere a juntar atributos y métodos en una sola entidad, de modo que formen "un todo" en lugar de estar separados, permitiendo así un control más organizado y seguro del acceso a los datos .

El uso de herencia en C# permite a una nueva clase derivar de una clase base, heredando sus campos y métodos, lo cual facilita la reutilización del código y promueve la coherencia al permitir extender y especializar la funcionalidad existente. El polimorfismo, por otro lado, permite que las clases derivadas puedan ser tratadas como instancias de su clase base, permitiendo a los métodos ser llamados de manera uniforme y adaptativa dependiendo del objeto que los implemente, lo que resulta en un código más flexible y extensible .

El método Main es crucial en aplicaciones de C#, ya que actúa como el punto de entrada del programa, indicando a partir de dónde debe comenzar la ejecución del código. Esta definición clara de un punto de inicio permite a los desarrolladores controlar el flujo de control del programa ordenadamente. Además, el método Main es llamado por el Common Language Runtime (CLR) cuando el programa se inicia, lo que integra la aplicación con la infraestructura .NET, facilitando la gestión de la ejecución, incluyendo aspectos como el manejo de excepciones y la recolección de basura .

Los espacios de nombres en C# se utilizan para organizar y estructurar clases de manera que se puedan definir varias clases con el mismo nombre dentro de un programa, siempre que pertenezcan a espacios de nombres diferentes. Esto es particularmente útil en grandes bibliotecas de clases o cuando se integran diferentes aplicaciones, ya que evita conflictos al permitir que cada entidad esté identificada de forma única por su espacio de nombres, además de su nombre de clase. Microsoft recomienda practicar una convención de nombrado que comienza con el nombre de la compañía, seguido del propósito del espacio, para garantizar unicidad .

Los métodos en C# son bloques de código que contienen una serie de instrucciones que se ejecutan en secuencia cuando se llama al método. Un método es la unidad mínima de lógica ejecutable en un programa y se define especificando un nivel de acceso (como public o private), un tipo de retorno o 'void', el nombre del método y los parámetros si son necesarios, dentro de un bloque delimitado por llaves. El método Main es esencial como punto de entrada para un programa C#, inicializado por el Common Language Runtime. Todo esto asegura que las operaciones estén bien encapsuladas, permitiendo la modularidad y reutilización del código .

Un espacio de nombres efectivo en C# se caracteriza por su estructura clara y lógica, que refleja la organización del código en función de su propósito y uso dentro del proyecto. Estos espacios permiten que múltiples clases, incluyendo aquellas con el mismo nombre, coexistan sin conflictos, lo cual es crucial en proyectos a gran escala donde las colisiones de nombres podrían ser comunes al trabajar con múltiples equipos o integrando diferentes bibliotecas. Al estructurar el código de manera organizada y predecible, los espacios de nombres facilitan la colaboración, el mantenimiento y la escalabilidad del código al mejorar la claridad y reducir los riesgos de interferencias accidentales .

Definir el nivel de acceso de un método en C# es crucial para el control de acceso a la funcionalidad del programa. Un método declarado como 'public' significa que puede ser accedido por cualquier otra clase dentro del ensamblado o desde otros ensamblados que referencian el mismo, ofreciendo flexibilidad y potencial incremento en la interoperabilidad del código. Por otro lado, un método privado restringe su acceso solo dentro de la misma clase, lo que puede aumentar la seguridad y encapsulación de los datos .

La diferencia entre un preincremento y un postincremento en C# radica en el momento en que se incrementa el valor de una variable. En el preincremento (++num), la variable se incrementa antes de utilizar su valor en la operación. En el postincremento (num++), primero se utiliza el valor actual de la variable y luego se incrementa para operaciones futuras. Aunque ambos resultan en incrementar el valor de la variable en una unidad, la operación específica en que se realiza el incremento difiere .

El orden de declaración de clases e interfaces es crítico en C# porque define explícitamente la jerarquía y las capacidades de la clase derivada. Al declarar una clase, se debe mencionar primero el nombre de la clase seguido de dos puntos, y luego la clase base si existe, seguida de las interfaces que implementa. Esto determina qué comportamientos y características heredará la clase derivada de su clase base y qué contratos deberá cumplir a través de las interfaces, afectando su funcionalidad y cómo interactuará con otras clases y objetos dentro del ecosistema del programa .

El operador de comparación de igualdad '==' en C# se utiliza para verificar si dos operandos son iguales. Su uso es crucial al implementar lógica condicional ya que puede determinar el flujo de ejecución de un programa. Sin embargo, su uso incorrecto, como confundirlo con el operador de asignación '=', podría llevar a errores lógicos que hagan que el condicional se comporte inesperadamente, cambiando valores en lugar de compararlos. Estos errores pueden ser difíciles de detectar y depurar, especialmente en programas grandes .

También podría gustarte