Herança C#
Herança C#
Neste tutorial, aprenderemos sobre herança C# e seus tipos com a ajuda de exemplos.
Em C#, a herança nos permite criar uma nova classe a partir de uma classe existente. É um recurso chave da Programação Orientada a Objetos (OOP).
A classe a partir da qual uma nova classe é criada é conhecida como classe base (pai ou superclasse). E, a nova classe é chamada de classe derivada (filho ou subclasse)
A classe derivada herda os campos e métodos da classe base. Isso ajuda na reutilização de código em C#.
Como fazer herança em C#?
Em C#, usamos o
: símbolo para realizar herança. Por exemplo,
class Animal {
// fields and methods
}
// Dog inherits from Animal
class Dog : Animal {
// fields and methods of Animal
// fields and methods of Dog
} Aqui, estamos herdando a classe derivada Dog da classe base Animal . O Cão classe agora pode acessar os campos e métodos de Animal classe.
Exemplo:herança C#
using System;
namespace Inheritance {
// base class
class Animal {
public string name;
public void display() {
Console.WriteLine("I am an animal");
}
}
// derived class of Animal
class Dog : Animal {
public void getName() {
Console.WriteLine("My name is " + name);
}
}
class Program {
static void Main(string[] args) {
// object of derived class
Dog labrador = new Dog();
// access field and method of base class
labrador.name = "Rohu";
labrador.display();
// access method from own class
labrador.getName();
Console.ReadLine();
}
}
} Saída
I am an animal My name is Rohu
No exemplo acima, derivamos uma subclasse Dog da superclasse Animal . Observe as afirmações,
labrador.name = "Rohu";
labrador.getName(); Aqui, estamos usando labrador (objeto de Dog) para acessar o nome e exibir() do Animal classe. Isso é possível porque a classe derivada herda todos os campos e métodos da classe base.
Além disso, acessamos o name campo dentro do método do Dog classe.
é-um relacionamento
Em C#, a herança é um relacionamento é-um. Usamos herança apenas se houver um relacionamento é-um entre duas classes. Por exemplo,
- Cão é um Animal
- Maçã é uma fruta
- Carro é um veículo
Podemos derivar Cão de Animais classe. Da mesma forma, a Apple de Frutas classe e Carro de veículo classe.
Membros protegidos na herança C#
Quando declaramos um campo ou método como
protected , ele só pode ser acessado da mesma classe e suas classes derivadas. Exemplo:membros protegidos na herança
using System;
namespace Inheritance {
// base class
class Animal {
protected void eat() {
Console.WriteLine("I can eat");
}
}
// derived class of Animal
class Dog : Animal {
static void Main(string[] args) {
Dog labrador = new Dog();
// access protected method from base class
labrador.eat();
Console.ReadLine();
}
}
} Saída
I can eat
No exemplo acima, criamos uma classe chamada Animal . A classe inclui um método protegido eat() .
Nós derivamos o Cão classe do Animal classe. Observe a afirmação,
labrador.eat(); Desde o
protected pode ser acessado a partir de classes derivadas, podemos acessar o eat() método do Cão classe. Tipos de herança
Existem os seguintes tipos de herança:
1. Herança única
Na herança simples, uma única classe derivada herda de uma única classe base.
2. Herança multinível
Na herança multinível, uma classe derivada herda de uma base e, em seguida, a mesma classe derivada atua como uma classe base para outra classe.
3. Herança hierárquica
Na herança hierárquica, várias classes derivadas herdam de uma única classe base.
4. Herança múltipla
Na herança múltipla, uma única classe derivada herda de várias classes base. C# não suporta herança múltipla. No entanto, podemos obter herança múltipla por meio de interfaces.
5. Herança híbrida
A herança híbrida é uma combinação de dois ou mais tipos de herança. A combinação de herança multinível e hierárquica é um exemplo de herança híbrida.
Substituição de método na herança C#
Se o mesmo método estiver presente na classe base e na classe derivada, o método na classe derivada substituirá o método na classe base. Isso é chamado de substituição de método em C#. Por exemplo,
using System;
namespace Inheritance {
// base class
class Animal {
public virtual void eat() {
Console.WriteLine("I eat food");
}
}
// derived class of Animal
class Dog : Animal {
// overriding method from Animal
public override void eat() {
Console.WriteLine("I eat Dog food");
}
}
class Program {
static void Main(string[] args) {
// object of derived class
Dog labrador = new Dog();
// accesses overridden method
labrador.eat();
}
}
} Saída
I eat Dog food
No exemplo acima, o eat() O método está presente tanto na classe base quanto na classe derivada.
Quando chamamos eat() usando o Cão objeto labrador ,
labrador.eat(); o método dentro de Dog é chamado. Isso ocorre porque o método dentro de Dog substitui o mesmo método dentro de Animal .
Observe que usamos
virtual e substituir com métodos da classe base e da classe derivada, respectivamente. Aqui, virtual- permite que o método seja substituído pela classe derivadaoverride- indica que o método está substituindo o método da classe base
Palavra-chave base em herança C#
No exemplo anterior, vimos que o método na classe derivada substitui o método na classe base.
No entanto, e se também quisermos chamar o método da classe base?
Nesse caso, usamos o
base palavra-chave para chamar o método da classe base da classe derivada. Exemplo:palavra-chave base na herança C#
using System;
namespace Inheritance {
// base class
class Animal {
public virtual void eat() {
Console.WriteLine("Animals eat food.");
}
}
// derived class of Animal
class Dog : Animal {
// overriding method from Animal
public override void eat() {
// call method from Animal class
base.eat();
Console.WriteLine("Dogs eat Dog food.");
}
}
class Program {
static void Main(string[] args) {
Dog labrador = new Dog();
labrador.eat();
}
}
} Saída
Animals eat food. Dogs eat Dog food.
No exemplo acima, o eat() está presente tanto na classe base Animal e a classe derivada Cão . Observe a afirmação,
base.eat(); Aqui, usamos o
base palavra-chave para acessar o método de Animal classe do Cão classe. Importância da herança em C#
Para entender a importância da herança, vamos considerar uma situação.
Suponha que estamos trabalhando com polígonos regulares, como quadrados, retângulos e assim por diante. E, temos que encontrar o perímetro desses polígonos com base na entrada.
1. Como a fórmula para calcular o perímetro é comum para todos os polígonos regulares, podemos criar um RegularPolygon classe e um método calculatePerimeter() para calcular o perímetro.
class RegularPolygon {
calculatePerimeter() {
// code to compute perimeter
}
} 2. E herde Quadrado e Retângulo classes do RegularPolygon classe. Cada uma dessas classes terá propriedades para armazenar o comprimento e o número de lados, pois são diferentes para todos os polígonos.
class Square : RegularPolygon {
int length = 0;
int sides = 0;
} Passamos o valor do comprimento e lados para calcularperímetro() para calcular o perímetro.
É assim que a herança torna nosso código reutilizável e mais intuitivo.
Exemplo:importância da herança
using System;
namespace Inheritance {
class RegularPolygon {
public void calculatePerimeter(int length, int sides) {
int result = length * sides;
Console.WriteLine("Perimeter: " + result);
}
}
class Square : RegularPolygon {
public int length = 200;
public int sides = 4;
public void calculateArea() {
int area = length * length;
Console.WriteLine("Area of Square: " + area);
}
}
class Rectangle : RegularPolygon {
public int length = 100;
public int breadth = 200;
public int sides = 4;
public void calculateArea() {
int area = length * breadth;
Console.WriteLine("Area of Rectangle: " + area);
}
}
class Program {
static void Main(string[] args) {
Square s1 = new Square();
s1.calculateArea();
s1.calculatePerimeter(s1.length, s1.sides);
Rectangle t1 = new Rectangle();
t1.calculateArea();
t1.calculatePerimeter(t1.length, t1.sides);
}
}
} Saída
Area of Square: 40000 Perimeter: 800 Area of Rectangle: 20000 Perimeter: 400
No exemplo acima, criamos um RegularPolygon classe que possui um método para calcular o perímetro do polígono regular.
Aqui, o Quadrado e Retângulo herdar de RegularPolygon .
A fórmula para calcular o perímetro é comum para todos, então reutilizamos o calculatePerimeter() método da classe base.
E como a fórmula para calcular a área é diferente para formas diferentes, criamos um método separado dentro da classe derivada para calcular a área.
Linguagem C