Curso de Programación C #: Miembros estáticos y miembros de instancia

Miembros estáticos versus instancias
+ Los miembros estáticos los comparten todas las instancias de una clase
+ Los miembros de instancia pertenecen a instancias específicas de una clase
Es decir cuando declaramos una variable estática todos los objetos creados a partir de esa clase tendrán esa variable en común esto es útil por ejemplo en los sistemas bancarios, no es practico ni comodo el hecho de que cada objeto almacene el tipo de cambio es más practico que se declare estático y sea compartido por todos los objetos, ya que el tipo de cambio es el mismo para todos ellos, ejemplo:
class Cliente
{
static decimal tipoCambio;
}
Esto quiere decir que en lugar de declarar la variable tipoCambio a nivel de objeto la estamos declarando a nivel de clase, en un lenguaje estructurado esto lo convertiría en una variable global, con sus respectivas ventajas y desventajas, que es accesible a todos, pero a cambio una variable global no puede ser encapsulada, sin embargo los lenguajes orientados a objetos no permiten las variables globales, sin embargo tienen lo que se conoce como variables estáticas. Los datos estáticos se declaran dentro de clase beneficiandose de la encapsulación de la clase, pero están asociados con la clase misma y no con cada objeto, es decir que aunque nunca se genere un objeto esa variable ocupará espacio. Puede haber tanto variables como métodos estáticos y son compartidos por todas las instancias de la clase, es decir, son comunes a todos los objetos generados a partir de dicha clase. Ahi que tomar en cuenta algo muy importante Cuando un método se declara estático, dicho método SOLO es accesible a travéz de la clase y no a travéz de las instancias de la clase los métodos estáticos solo pueden ser accesados por los datos estáticos y por otros métodos estáticos, además debido a que son parte de la clase pueden ser accesados sin crear una instancia de la misma. En C# no se puede acceder a un método estático desde una instancia.
public class Cliente
{
public string nombreCliente;
public void consultaNombreCliente()
{
Console.WriteLine(nombreCliente);
}
public static string nombreBanco;
public static void consultaNombreBanco()
{
Console.WriteLine(nombreBanco);
}
}
Cliente miCliente = new Cliente();
miCliente.nombreCliente = "Alejandro Velazquez"; //Definó el nombre del cliente
miCliente.consultaNombreCliente(); //Esto imprimirá el nombre del cliente
Cliente.nombreBanco = "BANAMEX"; //Definó el nombre del banco
Cliente.consultaNombreBanco(); //Esto imprimirá el nombre del banco
El nombre del banco y la consulta al nombre del banco se realizan directamente a travéz de la clase, no pueden realizarse a travéz de las instancias de la clase, esto debido a que son variables estáticas, sin embargo el nombre del cliente y la consulta al nombre del cliente se realizan a travéz de las instancias de la clase, esto es especialmente útil debido a que en este ejemplo el nombre del banco es algo común a todos los clientes, porque todos son clientes del mismo banco, sin embargo, cada cliente tiene su propio nombre, así que lo que hicimos es declarar el nombre del banco y la consulta al nombre del banco estáticas con esto el dato se guarda una única vez en la clase y solo puede ser accedida a travéz de la clase, así mismo declaramos normalmente el nombre del cliente y la consulta al nombre del cliente ya que cada que creemos un objeto cliente será una persona diferente con un nombre diferente y por lo tanto el valor del campo cambiará en cada instancia.
Ahora veamos, hemos visto distintas formas de encapsular y manipular los datos, pero ¿Qué pasa si necesitamos acceder a un método o dato privado desde afuera?, bueno para eso existen las propiedades y son realmente utiles, las propiedades nos permiten manipular datos privados desde afuera de la clase, ejemplo:
class Persona
{
public string nombreCompleto()
{
Console.WriteLine(Nombre+" "+Apellido);
}
public string nombre
{
get{ return Nombre; }
set{ Nombre = value ; }
}
public string apellido
{
get{ return Apellido; }
set{ Apellido = value; }
}
private string Nombre,Apellido;
}
En este ejemplo se declaran dos variables privadas, Nombre y Apellido si intentaramos acceder a dichas variables desde el exterior de la siguiente manera:
Persona Alejandro = new Persona(); //Ja, ja, ja he vuelto a nacer... ;-)
Alejandro.Nombre = "Alejandro";
Alejandro.Apellido = "Velazquez";
Esto nos marcaría un error ya que dichos datos han sido declarados como privados y por tanto son invisibles desde afuera de la clase, lo que podemos hacer en cambio es accederlos a travéz de propiedades de la siguiente manera:
Alejandro.nombre = "Alejandro";
Alejandro.apellido = "Velazquez";
Alejandro.nombreCompleto();
El ejemplo se ve muy similar al anterior, pero ahí una sútil diferencia.
public string nombre //El nombre de la propiedad se parece al de la variable, solo cambia la primera letra, esto la hace fácil de recordar
{
get{ return Nombre; } //get nos permite recuperar el valor de la variable privada
set{ Nombre = value ; } //set nos permite modificar el valor de la variable privada
}
La propiedad llamada nombre nos permite modificar el valor de la variable privada llamada Nombre, pero va mas alla de eso, gracias a las propiedades podemos validar los datos y asegurarnos que son confiables antes de volcarlos sobre nuestras variables privadas y viceversa, asegurarnos que va a recibir el valor de la variable privada alguien que nosotros queremos que reciba el valor de la variable privada. Además las propiedades nos ayudan a proporcionar encapsulación. Ejemplo:
class Persona
{
public string nombreCompleto()
{
Console.WriteLine(Nombre+" "+Apellido);
}
public int edad
{
get
{
return Edad;
}
set
{
if( 0 < value && value < 100) //validamos que sea una Edad valida de acuerdo a nuestro criterio
Edad = value; //De ser asi modificamos el valor de la variable privada
}
}
public string nombre
{
get{ return Nombre; }
set{ Nombre = value ; }
}
public string apellido
{
get{ return Apellido; }
set{ Apellido = value; }
}
private int Edad;
private string Nombre,Apellido;
}
Utilizando el ejemplo anterior hemos agregado una variable nueva llamada Edad de tipo entero, ya que las edades no pueden ser negativas y como estamos asumiendo que ninguno de es casi imposible que nos topermos con una persona de 100 o mas años, pues condicionamos la propiedad para que solo acepte valores enteros que sean mayores que 0 y menores que 100, esta es un sencillo ejemplo de como utilizar las propiedades para validar las entradas suministradas por el usuario, esto es sumamente útil ya que nos ahorra muchos errores en tiempo de ejecución, así mismo nos permite tener una aplicación más segura.