C# | Clase y Objeto

Clase y Objeto son los conceptos básicos de la Programación Orientada a Objetos que giran en torno a las entidades de la vida real. Una clase es un proyecto o prototipo definido por el usuario a partir del cual se crean objetos. Básicamente, una clase combina los campos y métodos (función miembro que define acciones) en una sola unidad. En C#, las clases admiten polimorfismo, herencia y también proporcionan el concepto de clases derivadas y clases base.

Declaración de clase

Generalmente, una declaración de clase contiene solo una palabra clave class , seguida de un identificador (nombre) de la clase. Pero hay algunos atributos opcionales que se pueden usar con la declaración de clase según los requisitos de la aplicación. En general, las declaraciones de clase pueden incluir estos componentes, en orden:

• Modificadores: una clase puede ser pública o interna, etc. Por defecto, el modificador de la clase es interno .
• Clase de palabra clave: una palabra clave de clase se utiliza para declarar la clase de tipo.
• Identificador de clase: se proporciona la variable de tipo clase. El identificador (o nombre de la clase) debe comenzar con una letra inicial que debe escribirse en mayúscula por convención.
• Clase base o Superclase: el nombre del padre de la clase (superclase), si lo hay, precedido por : (dos puntos) . Esto es opcional.
• Interfaces: una lista separada por comas de las interfaces implementadas por la clase, si las hay, precedida por : (dos puntos) . Una clase puede implementar más de una interfaz. Esto es opcional.
• Cuerpo: el cuerpo de la clase está rodeado por { } (llaves).

Los constructores en clase se utilizan para inicializar nuevos objetos. Los campos son variables que proporcionan el estado de la clase y sus objetos, y los métodos se utilizan para implementar el comportamiento de la clase y sus objetos.
Ejemplo:

// declaring public class
public class Geeks
{

    // field variable
    public int a, b;

      // member function or method
      public void display()
      {
          Console.WriteLine(“Class & Objects in C#”);
      }
}

Objetos

Es una unidad básica de Programación Orientada a Objetos y representa entidades de la vida real. Un programa típico de C# crea muchos objetos que, como sabe, interactúan invocando métodos. Un objeto consta de: 

• Estado: Está representado por los atributos de un objeto. También refleja las propiedades de un objeto.
• Comportamiento: Está representado por los métodos de un objeto. También refleja la respuesta de un objeto con otros objetos.
• Identidad: Da un nombre único a un objeto y permite que un objeto interactúe con otros objetos.

Considere Dog como un objeto y vea el siguiente diagrama para conocer su identidad, estado y comportamiento.

Los objetos corresponden a cosas que se encuentran en el mundo real. Por ejemplo, un programa de gráficos puede tener objetos como «círculo», «cuadrado», «menú». Un sistema de compras en línea puede tener objetos como «carrito de compras», «cliente» y «producto».
 

Declaración de objetos (también llamada instanciación de una clase)

Cuando se crea un objeto de una clase, se dice que la clase está instanciada. Todas las instancias comparten los atributos y el comportamiento de la clase. Pero los valores de esos atributos, es decir, el estado son únicos para cada objeto. Una sola clase puede tener cualquier número de instancias.
Ejemplo:
 

Como declaramos variables como (type name;). Esto notifica al compilador que usaremos el nombre para referirnos a datos cuyo tipo es tipo. Con una variable primitiva, esta declaración también reserva la cantidad adecuada de memoria para la variable. Entonces, para la variable de referencia, el tipo debe ser estrictamente un nombre de clase concreto. 

Dog tuffy;

Si declaramos una variable de referencia (tuffy) como esta, su valor será indeterminado (nulo) hasta que se cree un objeto y se le asigne. Simplemente declarar una variable de referencia no crea un objeto.
 

Inicializar un objeto

El operador new instancia una clase asignando memoria para un nuevo objeto y devolviendo una referencia a esa memoria. El operador new también invoca al constructor de clases.
Ejemplo:

// C# program to illustrate the
// Initialization of an object
using System;
 
// Class Declaration
public class Dog {
 
    // Instance Variables
    String name;
    String breed;
    int age;
    String color;
 
    // Constructor Declaration of Class
    public Dog(String name, String breed,
                  int age, String color)
    {
        this.name = name;
        this.breed = breed;
        this.age = age;
        this.color = color;
    }
 
    // Property 1
    public String GetName()
    {
        return name;
    }
 
    // Property 2
    public String GetBreed()
    {
        return breed;
    }
 
    // Property 3
    public int GetAge()
    {
        return age;
    }
 
    // Property 4
    public String GetColor()
    {
        return color;
    }
 
    // Method 1
    public String ToString()
    {
        return ("Hi my name is " + this.GetName()
                + ".\nMy breed, age and color are " + this.GetBreed()
                + ", " + this.GetAge() + ", " + this.GetColor());
    }
 
// Main Method
public static void Main(String[] args)
    {
         
        // Creating object
        Dog tuffy = new Dog("tuffy", "papillon", 5, "white");
        Console.WriteLine(tuffy.ToString());
    }
}

Producción: 

Hi my name is tuffy.
My breed, age and color are papillon, 5, white

Explicación: Esta clase contiene un solo constructor. Podemos reconocer un constructor porque su declaración usa el mismo nombre que la clase y no tiene tipo de retorno. El compilador de C# diferencia los constructores según el número y el tipo de argumentos. El constructor de la clase Perro toma cuatro argumentos. La siguiente declaración proporciona «tuffy», «papillon», 5, «white» como valores para esos argumentos:

Dog tuffy = new Dog("tuffy", "papillon", 5, "white");

El resultado de ejecutar esta declaración se puede ilustrar como: