C# | clases abstractas – Part 1

La abstracción en C# es el proceso para ocultar los detalles internos y mostrar solo la funcionalidad. El modificador abstracto indica la implementación incompleta. La palabra clave resumen se usa antes de la clase o el método para declarar la clase o el método como resumen. Además, el modificador abstracto se puede usar con indexadores , eventos y propiedades . 

Ejemplo: 

public abstract void geek();
// this indicates the method 'geek()' is abstract
 
abstract class gfg
// this indicates the class 'gfg' is abstract

Método abstracto: un método que se declara abstracto, no tiene «cuerpo» y se declara solo dentro de la clase abstracta. Se debe implementar un método abstracto en todas las clases no abstractas utilizando la palabra clave override. Después de anular, el método abstracto está en la clase no abstracta. Podemos derivar esta clase en otra clase, y nuevamente podemos anular el mismo método abstracto con ella.

Sintaxis: 

public abstract void geek();
// the method 'geek()' is abstract

Clase Abstracta: Esta es la forma de lograr la abstracción en C#. Una clase abstracta nunca está destinada a ser instanciada directamente. También se puede crear una clase abstracta sin ningún método abstracto. Podemos marcar una clase como abstracta incluso si no tiene ningún método abstracto. Las clases abstractas se utilizan normalmente para definir una clase base en la jerarquía de clases . O, en otras palabras, una clase abstracta es una clase incompleta o una clase especial que no podemos instanciar. El propósito de una clase abstracta es proporcionar un modelo para las clases derivadas y establecer algunas reglas que las clases derivadas deben implementar cuando heredan una clase abstracta. Podemos usar una clase abstracta como clase base y todas las clases derivadas deben implementar definiciones abstractas. 

Sintaxis:  

abstract class gfg{}
// class 'gfg' is abstract

Puntos importantes: 

• Generalmente, usamos la clase abstracta en el momento de la herencia .
• Un usuario debe usar la palabra clave anular antes de que el método se declare como abstracto en la clase secundaria, la clase abstracta se usa para heredar en la clase secundaria.
• Una clase abstracta no puede ser heredada por estructuras.
• Puede contener constructores o destructores.
• Puede implementar funciones con métodos no abstractos.
• No puede admitir herencias múltiples.
• No puede ser estático.

Ejemplo 1: Programa para mostrar el funcionamiento de una clase abstracta

// C# program to show the
// working of abstract class
using System;
 
// abstract class 'GeeksForGeeks'
public abstract class GeeksForGeeks {
 
    // abstract method 'gfg()'
    public abstract void gfg();
     
}
 
// class 'GeeksForGeeks' inherit
// in child class 'Geek1'
public class Geek1 : GeeksForGeeks
{
 
    // abstract method 'gfg()'
    // declare here with
    // 'override' keyword
    public override void gfg()
    {
        Console.WriteLine("class Geek1");
    }
}
 
// class 'GeeksForGeeks' inherit in
// another child class 'Geek2'
public class Geek2 : GeeksForGeeks
{
 
    // same as the previous class
    public override void gfg()
    {
        Console.WriteLine("class Geek2");
    }
}
 
// Driver Class
public class main_method {
 
    // Main Method
    public static void Main()
    {
 
        // 'g' is object of class
        // 'GeeksForGeeks' class '
        // GeeksForGeeks' cannot
        // be instantiate
        GeeksForGeeks g;
 
        // instantiate class 'Geek1'
        g = new Geek1();
         
        // call 'gfg()' of class 'Geek1'
        g.gfg();
       
        // instantiate class 'Geek2' 
        g = new Geek2();
       
        // call 'gfg()' of class 'Geek2'
        g.gfg();
         
    }
}

class Geek1
class Geek2

Ejemplo 2: Programa para calcular el área de un cuadrado usando clase abstracta y método abstracto

// C# program to calculate the area
// of a Square using abstract class
// and abstract method
using System;
 
// declare class 'AreaClass'
// as abstract
abstract class AreaClass
{
    // declare method
    // 'Area' as abstract
    abstract public int Area();
}
 
// class 'AreaClass' inherit
// in child class 'Square'
class Square : AreaClass
{
    int side = 0;
 
    // constructor
    public Square(int n)
    {
        side = n;
    }
 
    // the abstract method
    // 'Area' is overridden here
    public override int Area()
    {
        return side * side;
    }
}
 
class gfg {
 
    // Main Method
    public static void Main()
    {
        Square s = new Square(6);
        Console.WriteLine("Area  = " + s.Area());
    }
}

Area  = 36

Las siguientes son algunas observaciones importantes sobre las clases abstractas en C# 
1) Una clase abstracta no significa que solo contenga métodos abstractos . Una clase abstracta también puede contener métodos no abstractos .

Sintaxis:  

abstract class gfg
{
    public void geek()
    {
        Console.WriteLine("'geek()' is non-abstract method");
    }
}

Ejemplo:

// C# program to show the working of
// the non-abstract method in the
// abstract class
using System;
 
abstract class AbstractClass {
 
    // Non abstract method
    public int AddTwoNumbers(int Num1, int Num2)
    {
        return Num1 + Num2;
    }
 
    // An abstract method which
    // overridden in the derived class
    public abstract int MultiplyTwoNumbers(int Num1, int Num2);
     
}
 
// Child Class of AbstractClass
class Derived : AbstractClass {
 
    // implementing the abstract
    // method 'MultiplyTwoNumbers'
    // using override keyword,
    public override int MultiplyTwoNumbers(int Num1, int Num2)
    {
        return Num1 * Num2;
    }
}
 
// Driver Class
class geek {
 
    // Main Method
    public static void Main()
    {
  
        // Instance of the derived class
        Derived d = new Derived();
 
        Console.WriteLine("Addition : {0}\nMultiplication :{1}",
                                          d.AddTwoNumbers(4, 6),
                                    d.MultiplyTwoNumbers(6, 4));
    }
}

Addition : 10
Multiplication :24

2) La clase abstracta también puede funcionar con accesores get y set .

Ejemplo:

// C# program to show the working
// of abstract class with the
// get and set accessors
using System;
 
abstract class absClass {
 
    protected int myNumber;
 
    public abstract int numbers
    {
        get;
        set;
    }
}
 
class absDerived : absClass {
 
    // Implementing abstract properties
    public override int numbers
    {
        get
        {
            return myNumber;
        }
        set
        {
            myNumber = value;
        }
    }
}
 
// Driver Class
class geek {
 
    // Main Method
    public static void Main()
    {
        absDerived d = new absDerived();
        d.numbers = 5;
        Console.WriteLine(d.numbers);
    }
}

5