http://milaneze.com.br/post/2009/06/28/C-Classes-abstratas.aspx
Uma classe abstrata é utilizada quando deseja-se fornecer uma interface comum a diversos membros de uma hierarquia de classes. Os métodos declarados na classe abstrata serão implementados em suas subclasses, através de polimorfismo.
É importante salientar que uma classe abstrata não pode ser instanciada. Uma classe que contenha métodos abstratos deve ser declarada como abstract mesmo que contenha métodos concretos.
Abaixo, temos um exemplo de classe abstrata com um método abstrato. Na linha 44 é definido o método abstrato. Esse método deverá ser implementado nas classes derivadas da classe Empregado.
1: abstract class Empregado
2: {3: private string primeiroNome;
4: private string ultimoNome;
5: private string numeroSeguroSocial;
6: 7: public Empregado(string primeiro, string ultimo, string nss)
8: { 9: primeiroNome = primeiro; 10: ultimoNome = ultimo; 11: numeroSeguroSocial = nss; 12: } 13: 14: public string PrimeiroNome
15: { 16: get 17: {18: return primeiroNome;
19: } 20: } 21: 22: public string UltimoNome
23: { 24: get 25: {26: return ultimoNome;
27: } 28: } 29: 30: public string NumeroSeguroSocial
31: { 32: get 33: {34: return numeroSeguroSocial;
35: } 36: } 37: 38: public override string ToString()
39: {40: return string.Format("{0} {1}\nNúmero do Seguro Social: {3}", PrimeiroNome, UltimoNome, NumeroSeguroSocial);
41: } 42: 43: // método abstrato que será implementado pela classe derivada
44: public abstract decimal Salario();
45: }Vamos utilizar como exemplo um sistema de folha de pagamento (exemplo do livro do Deitel) para implementar a classe Empregado utilizando polimorfismo. O código para implementação de uma classe abstrata é o mesmo da herança: ClasseAbstrata : ClasseDerivada.
Abaixo, o diagrama de classes do sistema de folha de pagamento (sem os métodos e atributos):
O código abaixo é da classe derivada EmpregadoAssalariado. Na linha 1 está o código que informa que a classe EmpregadoAssalariado implementa a classe Empregado.
1: class EmpregadoAssalariado : Empregado
2: {3: private decimal salarioSemanal;
4: 5: public EmpregadoAssalariado(string primeiro, string ultimo, string nss, decimal salario)
6: : base(primeiro, ultimo, nss)
7: { 8: SalarioSemanal = salario; 9: } 10: 11: public decimal SalarioSemanal
12: { 13: get 14: {15: return salarioSemanal;
16: } 17: 18: set 19: {20: salarioSemanal = (value >= 0) ? value : 0;
21: } 22: } 23: 24: public override decimal Salario()
25: {26: return SalarioSemanal;
27: } 28: 29: public override string ToString()
30: {31: return string.Format( "Empregado assalariado: {0}\n{1}: {2:C}", base.ToString(), "salário semanal", SalarioSemanal);
32: } 33: }Agora, a implementação da classe EmpregadoPagoPorHora
1: class EmpregadoPagoPorHora : Empregado
2: {3: private decimal salarioPorHora;
4: private decimal horas;
5: 6: public EmpregadoPagoPorHora(string primeiro, string ultimo, string nss, decimal salarioPorHora, decimal horasTrabalhadas)
7: : base(primeiro, ultimo, nss)
8: { 9: SalarioPorHora = salarioPorHora; 10: Horas = horasTrabalhadas; 11: } 12: 13: public decimal SalarioPorHora
14: { 15: get 16: {17: return salarioPorHora;
18: } 19: 20: set 21: {22: salarioPorHora = (value >= 0) ? value : 0;
23: } 24: } 25: 26: public decimal Horas
27: { 28: get 29: {30: return horas;
31: } 32: 33: set 34: {35: horas = (value >= 0) ? value : 0;
36: } 37: } 38: 39: public override decimal Salario()
40: {41: if (Horas <= 40) //sem horas extras
42: return SalarioPorHora * Horas;
43: else
44: return (40 * SalarioPorHora) + ((Horas - 40) * SalarioPorHora * 1.5M);
45: } 46: 47: public override string ToString()
48: {49: return string.Format("empregado pago por hora: {0}\n{1}: {2:C}; {3}: {4:F2}", base.ToString(), "salário por hora", SalarioPorHora, "horas trabalhadas", Horas);
50: } 51: }Em seguida, a implementação da classe EmpregadoComissionado:
1: class EmpregadoComissionado : Empregado
2: {3: private decimal vendaBruta;
4: private decimal taxaDeComissao;
5: 6: public EmpregadoComissionado(string primeiro, string ultimo, string nss, decimal vendas, decimal taxa)
7: : base(primeiro, ultimo, nss)
8: { 9: VendaBruta = vendas; 10: TaxaDeComissao = taxa; 11: } 12: 13: public decimal TaxaDeComissao
14: { 15: get 16: {17: return taxaDeComissao;
18: } 19: 20: set 21: {22: taxaDeComissao = (value > 0 && value < 1) ? value : 0;
23: } 24: } 25: 26: public decimal VendaBruta
27: { 28: get 29: {30: return vendaBruta;
31: } 32: 33: set 34: {35: vendaBruta = (value >= 0) ? value : 0;
36: } 37: } 38: 39: public override decimal Salario()
40: {41: return TaxaDeComissao * VendaBruta;
42: } 43: 44: public override string ToString()
45: {46: return string.Format( "{0}: {1}\n{2}: {3:C}\n{4}: {5:F2}", "empregado comissionado", base.ToString(), "venda bruta", VendaBruta, "taxa de comissão", TaxaDeComissao);
47: } 48: }A classe EmpregadoComissionadoMaisSalarioBase é uma classe derivada da classe EmpregadoComissionado e, por consequência, também implementa o método abstrato da classe Empregado.
1: class EmpregadoComissionadoMaisSalarioBase : EmpregadoComissionado
2: {3: private decimal salarioBase;
4: 5: public EmpregadoComissionadoMaisSalarioBase(string primeiro, string ultimo, string nss, decimal vendas, decimal taxa, decimal salario)
6: : base(primeiro, ultimo, nss, vendas, taxa)
7: { 8: SalarioBase = salario; 9: } 10: 11: public decimal SalarioBase
12: { 13: get 14: {15: return salarioBase;
16: } 17: 18: set 19: {20: salarioBase = (value >= 0) ? value : 0;
21: } 22: } 23: 24: public override decimal Salario()
25: {26: return base.Salario();
27: } 28: 29: public override string ToString()
30: {31: return string.Format( "{0} {1}; {2}: {3:C}", "com salário base", base.ToString(), "salário base", SalarioBase);
32: } 33: }Agora chegou a hora de implementar esse código para entender como ele irá funcionar.
1: class Program
2: {3: static void Main(string[] args)
4: {5: EmpregadoAssalariado empregadoAssalariado = new EmpregadoAssalariado("John", "Smith", "111-11-1111", 800.00M);
6: EmpregadoPagoPorHora empregadoPagoPorHora = new EmpregadoPagoPorHora("Karen", "Price", "222-22-2222", 16.75M, 40.0M);
7: EmpregadoComissionado empregadoComissionado = new EmpregadoComissionado("Sue", "Jones", "333-33-3333", 10000.00M, .06M);
8: EmpregadoComissionadoMaisSalarioBase empregadoComissionadoMaisSalarioBase = new EmpregadoComissionadoMaisSalarioBase("Bob", "Lewis", "444-44-4444", 5000.00M, .04M, 300.00M);
9: 10: Console.WriteLine("Empregados processados individualmente:\n");
11: Console.WriteLine("{0}\n{1}: {2:C}\n", empregadoAssalariado, "earned", empregadoAssalariado.Salario());
12: Console.WriteLine("{0}\n{1}: {2:C}\n", empregadoPagoPorHora, "earned", empregadoPagoPorHora.Salario());
13: Console.WriteLine("{0}\n{1}: {2:C}\n", empregadoComissionado, "earned", empregadoComissionado.Salario());
14: Console.WriteLine("{0}\n{1}: {2:C}\n", empregadoComissionadoMaisSalarioBase, "earned", empregadoComissionadoMaisSalarioBase.Salario());
15: 16: Empregado[] empregados = new Empregado[4];
17: empregados[0] = empregadoAssalariado; 18: empregados[1] = empregadoPagoPorHora; 19: empregados[2] = empregadoComissionado; 20: empregados[3] = empregadoComissionadoMaisSalarioBase; 21: 22: Console.WriteLine("Empregados processados polimorficamente:\n");
23: 24: foreach (Empregado empregadoAtual in empregados)
25: { 26: Console.WriteLine(empregadoAtual); 27: 28: if (empregadoAtual is EmpregadoComissionadoMaisSalarioBase)
29: { 30: EmpregadoComissionadoMaisSalarioBase empregado = (EmpregadoComissionadoMaisSalarioBase)empregadoAtual; 31: empregado.SalarioBase *= 1.10M;32: Console.WriteLine("Novo salário base com 10% de aumento: " + empregado.SalarioBase.ToString());
33: } 34: 35: Console.WriteLine("salário ganho: " + empregadoAtual.Salario() + "\n");
36: } 37: 38: for (int i = 0; i < empregados.Length; i++)
39: Console.WriteLine("Empregado " + i.ToString() + " é um " + empregados[i].GetType());
40: 41: Console.ReadLine(); 42: } 43: }
2 comentários:
Show de bola essa sua implementação.
Muito bom!!!
Postar um comentário