Classe abstrata e método C#

Classe e método abstratos C#

Neste tutorial, aprenderemos sobre a classe e o método abstratos do C# com a ajuda de exemplos.

Classe abstrata

Em C#, não podemos criar objetos de uma classe abstrata. Usamos o abstract palavra-chave para criar uma classe abstrata. Por exemplo,

// create an abstract class
abstract class Language {
  // fields and methods
}
...

// try to create an object Language
// throws an error
Language obj = new Language();

Uma classe abstrata pode ter métodos abstratos (método sem corpo) e métodos não abstratos (método com corpo). Por exemplo,

abstract class Language {

  // abstract method
  public abstract void display1();

  // non-abstract method
  public void display2() {
    Console.WriteLine("Non abstract method");
  }
}

Antes de avançar, certifique-se de conhecer a herança C#.

---

Herdar classe abstrata

Como não podemos criar objetos de uma classe abstrata, devemos criar uma classe derivada dela. Para que possamos acessar membros da classe abstrata usando o objeto da classe derivada. Por exemplo,

using System;
namespace AbstractClass {

  abstract class Language {

    // non-abstract method
    public void display() {
      Console.WriteLine("Non abstract method");
    }
  }

  // inheriting from abstract class
  class Program : Language {

    static void Main (string [] args) {
      
      // object of Program class
      Program obj = new Program();

      // access method of an abstract class
      obj.display();

      Console.ReadLine();
    }
  }
}

Saída

Non abstract method

No exemplo acima, criamos uma classe abstrata chamada Language . A classe contém um método não abstrato display() .

Criamos o Programa classe que herda a classe abstrata. Observe a afirmação,

obj.display();

Aqui, obj é o objeto da classe derivada Program . Estamos chamando o método da classe abstrata usando o objeto obj .

Observação :Podemos usar a classe abstrata apenas como uma classe base. É por isso que classes abstratas não podem ser seladas. Para saber mais, visite C# classe e método selados.

---

Método abstrato C#

Um método que não possui um corpo é conhecido como método abstrato. Usamos o abstract palavra-chave para criar métodos abstratos. Por exemplo,

public abstract void display();

Aqui, exibir() é um método abstrato. Um método abstrato só pode estar presente dentro de uma classe abstrata.

Quando uma classe não abstrata herda uma classe abstrata, ela deve fornecer uma implementação dos métodos abstratos.

Exemplo:Implementação do método abstrato

using System;
namespace AbstractClass {

  abstract class Animal {

    // abstract method
    public abstract void makeSound();
  }

  // inheriting from abstract class
  class Dog : Animal {

    // provide implementation of abstract method
    public override void makeSound() {

      Console.WriteLine("Bark Bark");

    }
  }
  class Program  {
    static void Main (string [] args) {
      // create an object of Dog class
      Dog obj = new Dog();
      obj.makeSound();    

      Console.ReadLine(); 
    }
  }
}

Saída

Bark Bark 

No exemplo acima, criamos uma classe abstrata chamada Animal . Temos um método abstrato makeSound() dentro da classe.

Temos um Cão classe que herda da classe Animal classe. Cão class fornece a implementação do método abstrato makeSound() .

// provide implementation of abstract method
public override void makeSound() {

  Console.WriteLine("Bark Bark");

}

Observe que usamos override com o makeSound() método. Isso indica que o método está substituindo o método da classe base.

Em seguida, usamos o objeto do Dog classe para acessar makeSound() .

Se o Cão class não forneceu a implementação do método abstrato makeSound() , Cão classe deveria ter sido marcada como abstrata também.

Observação :Ao contrário da herança C#, não podemos usar virtual com os métodos abstratos da classe base. Isso ocorre porque uma classe abstrata é implicitamente virtual.

---

Classe abstrata com acessadores get e set

Podemos marcar os acessadores get e set como abstratos. Por exemplo,

using System;
namespace AbstractClass {
  abstract class Animal {
    
    protected string name;
    // abstract method
    public abstract string Name {
      get;
      set;
    }
  }

  // inheriting from abstract class
  class Dog : Animal {

    // provide implementation of abstract method
    public override string Name {
      get {
        return name;
      }
      set {
        name = value; 
      }
    }
   
  }
  class Program  {
    static void Main (string [] args) {
      // create an object of Dog class
      Dog obj = new Dog();  
      obj.Name = "Tom";
      Console.WriteLine("Name: " + obj.Name); 

      Console.ReadLine();
    }
  }
}

Saída

Name: Tom

No exemplo acima, marcamos o acessador get e set como abstrato.

obj.Name = "Tom";
Console.WriteLine("Name: " + obj.Name);

Estamos definindo e obtendo o valor do name campo da classe abstrata Animal usando o objeto da classe derivada Dog .

---

Construtor de acesso de classes abstratas

Uma classe abstrata também pode ter construtores. Por exemplo,

using System;
namespace AbstractClass {
  abstract class Animal {
    
    public Animal() {
      Console.WriteLine("Animal Constructor");
    }
  }

  class Dog : Animal {
    public Dog() {
      Console.WriteLine("Dog Constructor");
    }   
  }

  class Program  {
    static void Main (string [] args) {
      // create an object of Dog class
      Dog d1 = new Dog();  

      Console.ReadLine();
    }
  }
}

Saída

Animal Constructor
Dog Constructor

No exemplo acima, criamos um construtor dentro da classe abstrata Animal .

Dog d1 = new Dog();

Aqui, quando criamos um objeto da classe derivada Dog o construtor da classe abstrata Animal também é chamado.

Observação :também podemos usar destruidores dentro da classe abstrata.

---

Abstração C#

As classes abstratas são usadas para obter a abstração em C#.

A abstração é um dos conceitos importantes da programação orientada a objetos. Ele nos permite ocultar detalhes desnecessários e mostrar apenas as informações necessárias.

Isso nos ajuda a gerenciar a complexidade ocultando detalhes com uma ideia mais simples e de nível superior.

Um exemplo prático de abstração pode ser o freio de moto. Sabemos o que um freio faz. Quando acionamos o freio, a moto para. No entanto, o funcionamento do freio é mantido escondido de nós.

A principal vantagem de ocultar o funcionamento do freio é que agora o fabricante pode implementar freios de maneira diferente para diferentes motocicletas. No entanto, o que o freio faz será o mesmo.

Exemplo:abstração C#

using System;
namespace AbstractClass {
  abstract class MotorBike {
    
    public abstract void brake();
  }

  class SportsBike : MotorBike {

    // provide implementation of abstract method
    public override void brake() {
      Console.WriteLine("Sports Bike Brake");
    }
   
  }

  class MountainBike : MotorBike {

    // provide implementation of abstract method
    public override void brake() {      
      Console.WriteLine("Mountain Bike Brake");
    }
   
  }
  class Program  {
    static void Main (string [] args) {
      // create an object of SportsBike class
      SportsBike s1 = new SportsBike();  
      s1.brake();

      // create an object of MountainBike class
      MountainBike m1 = new MountainBike();
      m1.brake();

      Console.ReadLine();
    }
  }
}

Saída

Sports Bike Brake
Mountain Bike Brake

No exemplo acima, criamos uma classe abstrata MotorBike . Tem um método abstrato brake() .

Como freio() é um método abstrato a implementação de brake() em Moto é mantido escondido.

Cada moto tem uma implementação diferente do freio. É por isso que SportsBike faz sua própria implementação de brake() e MountainBike faz sua própria implementação de brake() .

Observação :Usamos interfaces para obter abstração completa em C#. Para saber mais, visite Interface C#.