Introducción a las clases

Introducción

En un lenguaje de procedimientos, no hay ningún enlace entre los datos y los procedimientos que los manejan. Por el contrario en un lenguaje orientado a objetos agrupamos los datos con el código que lo manejan. Las CLASES son la representación simbólica de los OBJETOS. Las CLASES describen campos, propiedades, métodos y eventos.

Haciendo una analogía con el trabajo de un ingeniero, la CLASE se correspondería con el plano de un motor y e OBJETO serían los diferentes motores que se construyen a partir de ese plano. Crear un OBJETO a partir de un una clase es lo que se llama INSTANCIAR.

Las tres propiedades de la ORIENTACIÓN A OBJETOS son:

ENCAPSULACIÓN: Agrupa datos y códigos en una única clase.
HERENCIA: Permite la creación de una nueva clase a partir de otra ya existente, de la cual se hereda todo y puede personalizarse añadiendo o modificando propiedades y métodos heredados. Las clases creadas a partir de otras existentes se llaman CLASES DERIVADAS.
POLIMORFISMO: Gracias a esta propiedad se pueden utilizar diferentes clases de forma intercambiable. Otros conceptos asociados al polimorfismo son la SOBRECARGA, SOBREESCRITURA y la OCULTACIÓN.

Ejemplo CLASE Persona con notación UML.

Declaración de una clase

Sintaxis general:

[atributos] [modificadores] [parcial] class NombreDeLaClase [ : clase base] [, interfaz1, interfaz2, ...] {
	Código de la clase
}

Para determinar la visibilidad el lenguaje cuenta con las siguientes palabras clave:

public: la clase puede ser utilizada en cualquier proyecto.
internal: la clase está limitada al proyecto en el cual está definida.
private: la clase sólo puede usarse en el módulo en la que está definida.
protected: la clase sólo puede ser utilizada en una subclase. Es decir sólo se puede utilizar protected para una clase declarada en otra clase.
protected internal: lo mismo que internal + protected.
abstract: no permite crear instancias de esta clase, sólo sirve para ser heredada como clase base. Suelen tener los métodos definidos pero sin ninguna operatividad con lo que se suele escribir estos métodos en las clases derivadas.
sealed: cuando una clase es la última de una jerarquía, por lo que no podrá ser utilizada como base de otra clase.

public class Persona {
  String Apellido;
  String Nombre;
  DateTime FechaNac;
}

Clase Parcial

Podemos definir una clase en varias declaraciones, pudiendo así utilizar varios archivos fuente para declarar una clase. Se utiliza normalmente para permitir la personalización de clases generadas automáticamente. el código generado suele colocarse en un archivo llamado .designer.cs; y durante la compilación se agrupan todas las definiciones parciales para obtener el código fuente de la clase.

public partial class Empleado {
    public void HacerTrabajo(){
      ... lo que sea ...
    }
}

public partial class Empleado {
    public void IrAComer() {
      ... lo que sea ...
    } 
}

Creación de propiedades privadas

public class Persona {
  private String elApellido;
  private String elNombre;
  private DateTime laFechaNac;
  public String Apellido {
    get {return elApellido;}
    set {elApellido=value.ToUpper();}
  }
  public String Nombre{
    get {return elNombre;}
    set {elNombre=value.ToLower();}
  }
  public DateTime FechaNac{
    get {return laFechaNac;}
    set { 
      if (value.Year >= 1900) {
        laFechaNac = value;}
    }
  }
}

Sólo lectura y sólo escritura

Se pueden restringir los accesos a una propiedad, si sólo incluimos la opción “get” lo que estamos haciendo es dando permisos de lectura; en cambio si incluimos la opción “set” lo que hacemos es dar permisos de escritura.

public class Persona {
  private String elApellido;
  private String elNombre;
  private DateTime laFechaNac;
  private String laClave;
  public String Apellido {
    get {return elApellido;}
    set {elApellido=value.ToUpper();}
  }
  public String Nombre{
    get {return elNombre;}
    set {elNombre=value.ToLower();}
  }
  public DateTime FechaNac{
    get {return laFechaNac;}
    set { 
      if (value.Year >= 1900) {
        laFechaNac = value;}
    }
  }
  public int Edad {
    get { return DateTime.Now.Year - laFechaNac.Year;}
  }  
  public String Clave {
    set { laClave = value;}
  }
}

Propiedades indexadas

public class Persona {
  private String elApellido;
  private String elNombre;
  private DateTime laFechaNac;
  private String laClave;
  private Persona[] losHijos = new Persona [10];
  public String Apellido {
    get {return elApellido;}
    set {elApellido=value.ToUpper();}
  }
  public String Nombre{
    get {return elNombre;}
    set {elNombre=value.ToLower();}
  }
  public DateTime FechaNac{
    get {return laFechaNac;}
    set { 
      if (value.Year >= 1900) {
        laFechaNac = value;}
    }
  }
  public int Edad {
    get { return DateTime.Now.Year - laFechaNac.Year;}
  }  
  public String Clave {
    set { laClave = value;}
  }
  public Persona this[int index] {
    get { return losHijos[index];}
    set { losHijos[index]=value;}
  }
}

La propiedad indexada esperará como parámetro un índice que permita especificar el “hijo” con el cual queremos trabajar. Veamos un ejemplo de instanciación de esta clase:

  private void button1_Click(object sender, EventArgs e)
        {
            Persona p = new Persona();
            Persona h1 = new Persona();
            Persona h2 = new Persona();
            p.Apellido = "Pedraza";
            p.Nombre = "Juanjo";
            p.FechaNac = new DateTime(1969, 3, 27);
            h1.Apellido = p.Apellido;
            h1.Nombre = "Juan";
            h1.FechaNac = new DateTime(2010, 3, 27);
            h2.Nombre = "Carla";
            h2.Apellido = p.Apellido;
            h2.FechaNac = new DateTime(2013, 8, 7);
            //Asignamos hijos a la persona
            p[0] = h1;
            p[1] = h2;
            MessageBox.Show(
                "Sr. "+p.Apellido+" "+p.Nombre+" nacido el "+p.FechaNac+" tiene 2 hijos\n"+
                "Hijo/a 1: "+p[0].Nombre+" nacido/a el "+p[0].FechaNac +"\n"+
                "Hijo/a 2: "+p[1].Nombre+" nacido/a el "+p[1].FechaNac +"\n");

        }