Aprendiendo Objetos 2

Aprendiendo Objetos 2

Aprendiendo Objetos 2

Continuando con el post aprendiendo objetos, agregaremos más técnicas para poder conocer la programación de objetos. La explicación de cada uno de los subtemas es simplemente scratch, si deseas que amplié algún subtema, me lo pudes indicar y con gusto lo explicare.

 

Espacios de nombre o namespaces

Los namespaces permiten organizar el código y crear un nombre único de clase

 

namespace CompaniaA
{
   public class Elemento { ... }
}
 
namespace CompaniaB
{
   public class Elemento { ... }
}

Miembros estáticos ó static

Los miembros static permiten utilizar la funcionalidad sin crear un objeto, se puede usar en estructuras, clases y métodos.

 

public static class Rectangulo
{
   public static string Nombre { ... }
}

Valores y Referencias

Estructuras

Las estructuras consisten en tener un pequeño grupo de campos relacionados.

Las estructuras contienen elementos que las clases pueden contener, como constructores, métodos, propiedades, etc. Sin embargo las clases no pueden heredar desde otra clase o estructura.

public struct Point
{
  public double X, Y;
}
 
<span class="s1">Nota: se genera una estructura cuando es algo simple, si es algo complejo,  </span>es mejor utilizar clases.

Ubicación de memoria

Cuando se crea un tipo de dato este genera almacenamiento en memoria, si se crean 3 variables, estas 3 variables tendrán su propio espacio en memoria ( independientes ) al menos que existan referencias.

Las referencias apuntan al espacio en memoria de la variable que deseas referenciar.

Las variables string cuando son declaradas empty, no tienen referencia a una dirección de memoria, pero cuando cambias empty por una cadena de caracteres “ texto “ entonces esta tiene referencia a una dirección de memoria.

Cuando las variables no son utilizadas, el garbage collector pasa por esas variables para destruirlas.

Encapsulación

La encapsulación es un mecanismo para esconder la información haciendo el código fácil de mantener y entender.

La encapsulación brinda al diseño de clases la flexibilidad de cambiar sección de código cuando es necesario hacer sin necesidad de cambiar otros códigos que hacen funcional al código.

Además si escondes información, escondes la complejidad.

Un ejemplo de encapsulación es cuando a los miembros los haces private y se forzará a que se inicialice la información con el constructor.

Las propiedades ofrecen la mejor manera de encapsular los datos.

Modificación de accesos

Public: no tiene restricción.

Private: restringido, es uso de la clase.

Protected: restringido, es uso de la clase y la herencia.

Internal: restringido, sólo se usa en el mismo código compilado.

Protected Internal: es una combinación del protected y internal, restringido, sólo se usa en el mismo código compilado y de otros códigos compilados.

Herencia

Las herencias es una características de la programación orientada de objetos que permiten a programar una clase  y ser reutilizada una y otra vez.

La herencia habilita la creación de nuevas clases que reutilizan, extienden y modifican la funcionalidad delas clases existentes.

Una clase que hereda la funcionalidad es una clase base.

Nota: las estructuras no soportan herencia.

    class Figura
    {
        public int largo { get; protected set; }
        public int ancho { get; protected set; }
    }
 
    class MetodoHerencia : Figura
    {
        public MetodoHerencia(int largo, int ancho)
        {
            base.largo = largo;
            base.ancho = ancho;
        }
 
        public int GetArea
        {
            get { return base.ancho * base.largo; }
        }
    }

 

Clases abstractas y sellados o abstract and sealed

Una clase abstracta es una clase base que puede compartir con múltiples clases.

Las clases selladas, no pueden usarse como clases base.

No se puede crear instancias de una clase abstracta, C# no soporta más de una clase base.

Clase abstracta

 

    abstract class Historia
    {
        protected string epocaColonial;
        protected string personas;
        public abstract void Relato();
        public abstract string EpocaColonial { get; }
        public abstract string Personas { get; }
    }
    class MetodoAbstract : Historia
    {
        public override void Relato()
        {
            epocaColonial = "Esta era una vez ";
            personas = " un hombre alto ...";
        }
 
        public override string EpocaColonial
        {
            get { return "Historia: " + epocaColonial; }
        }
 
        public override string Personas
        {
            get { return personas; }
        }
    }
 
    class LaLeyenda
    {
        public string Inicia()
        {
            MetodoAbstract metodoAbstract = new MetodoAbstract();
            metodoAbstract.Relato();
            return metodoAbstract.EpocaColonial + metodoAbstract.Personas;
        }
    }

Clase sellado

    sealed class Animal
    {
        public void caminar()
        {
        }
    }
 
    class MetodoSealed : Animal //Error
    {
    }

Cast entre tipo

En c# en tiempo de ejecución permite cast un objeto a cualquiera del base de tipos.

Se puede castear ya sea implicitamente, explicitamente, es cuando se coloca un tipo de dato que pueda hacerse el casteo sin necesidad de colocar a que tipo se desea cambiar.

Por ejemplo:

byte y = 1;
 
int x = y;

Un casteo explicito es cuando se coloca a que se desea cambiar.

int x = ( int ) y;

Operador IS

Para evitar errores de compilación como un InvalidCastException el operador IS puede ser usado para checar si el cast funcionará.

If ( x is int )

 

Operador AS

Otro funcional casteo es el operador AS, al castear con el operador y este no sea posible, regresa un null si surge alguna excepción.

Rectangulo r = o as Rectangulo;
if (r != null) { ... }

Polimorfismo

El polimorfismo tiene como habilidad de compartir la funcionalidad que tiene la clase base pero teniendo su propio y único comportamiento.

    class Figuras
    {
        public virtual void Dibujar()
        {
            Console.WriteLine( "Dibujando una figura" );
        }
    }
 
    class Pentagono : Figuras
    {
        public override void Dibujar()
        {
            Console.WriteLine( "Dibujando: Pentagono" );
        }
    }
 
    class Triangulo : Figuras
    {
        public override void Dibujar()
        {
            Console.WriteLine( "Dibujando: Triangulo" );
        }
    }
 
    class MetodoPolimorfismo
    {
        public List listaDeFiguras = new List();
        public void Figuras()
        {
            listaDeFiguras.Add( new Pentagono() );
            listaDeFiguras.Add( new Triangulo() );
        }
    }

Al momento de ejecutar .Dibujar de la listaDeFiguras tendrá como resultado:

Dibujando : Pentagono

Dibujando : Triángulo

Sobrecarga y nuevo o Override and New

La override remplaza de la clase base los miembros que deriven de la clase. La palabra new hace lo mismo pero en este caso esconde la implementación de la clase base.

Cuando se realiza un override es posible ejecutar la funcionalidad de la clase base, mientras en new no.

Para utilizar override y new se necesita que se implemente el tipo de miembro, virtual o abstract.

Interfaces

Las interfaces son usadas para establecer contratos con los objetos

que pueden interactuar entre otros sin necesidad de conocer

los detalles de la implementación.

Una interface consiste en un conjunto de métodos, propiedades

delegados, eventos o indices. Las interfaces no tienen una

implementación detallada, son solo nombres sin funcionalidad

Al heredar de una interface todo el conjunto de  métodos, propiedades

delegados, eventos o indices con su funcionalidad.

    interface ITransporte
    {
        bool Encendido();
    }
    class MetodoInterface : ITransporte
    {
        public bool Encendido()
        {
            return true;
        }
    }

Leave a Reply

Your email address will not be published. Required fields are marked *