WebAula 1

Conceitos de classes abstratas e interfaces

O que é uma classe abstrata? (Abstract Class)

A classe abstrata é um tipo de classe que somente pode ser herdada e não

instanciada. De certa forma podemos  dizer que este tipo de classe é

conceitual, que pode definir funcionalidades para que as suas subclasses

possam implementá-las de forma não obrigatória, ou seja ao se definir um

conjunto de métodos na classe abstrata não é de total obrigatoriedade a

implementação de todos os métodos em suas    subclasses.

Em uma classe abstrata os métodos declarados podem ser abstratos ou não e

suas implementações devem ser obrigatórias na subclasse.

Quando criamos um método em uma classe abstrata sua implementação é

obrigatória pelas classes herdadas. Caso você não implemente o mesmo, o

compilador criará um erro em tempo de compilação.

                Exemplo de implementação retirado do books online em C#.

 

     abstract class formaClasse

{

    abstract public int Area();

}

class quadrado : formaClasse

{

    int x, y;

    // Se não for implementado o método Area()

    //  será gerado um compile-time error.

    public override int Area()

    {

        return x * y;

    }

}

Interface                                                                                                               

As interfaces são fundamentais em um sistema orientado a objetos. Quando

dizemos que um objeto é a instancia de uma classe, na verdade queremos

dizer que este objeto implementa a interface definida pela classe,  ou seja,

uma interface define as operações que um objeto será obrigado a implementar.

 Para cada operação declarada por um objeto deve ser especificado o nome da

operação, os objetos que esta operação aceita como parâmetro e o tipo de

valor retornado pela operação. Este conjunto de informações sobre uma

determinada operação tem o nome de assinatura da operação e a um conjunto

de assinaturas de operações dá-se o nome de interface.

É importante lembrar que uma interface nunca contém implementação, ou seja,

numa interface não se pode definir campos, pois o mesmo é uma

implementação de um atributo objeto. A interface também não permite

construtores, pois num construtor temos as instruções usadas para inicializar

campos. Para podermos usar uma interface devemos criar uma classe ou

estrutura e herdar da interface, com isso é obrigatório implementar todos os

métodos da interface.

 Exemplo de implementação.

      interface IExemploInterface

{

    void ExemploMetodo();

}

 class Implementacaoclasse : IExemploInterface

{

    // Implementação explicita da interface

    void IExemploInterface.ExemploMetodo()

    {

        // Implementação do método

    }

 static void Main()

    {

        // Declarando uma instancia de uma interface

        IExemploInterface obj = new Implementacaoclasse();

         // chame o método.

        obj.SampleMethod();

    }

}

Classes Abstratas X Interfaces

Uma classe abstrata pode conter métodos completos ou incompletos.

UmaInterface pode conter apenas a assinatura de um método,  mas nenhum

corpo ou implementação.

Portanto, em uma classe abstrata, pode-se implementar  métodos, mas em

uma Interface não.

Uma classe abstrata pode conter campos, construtores, ou destrutores e

aplicar propriedades. Uma interface não pode conter campos, construtores, ou

destrutores; pode possuir apenas a propriedade da assinatura, mas não a

implementação.

Uma classe abstrata não suporta múltiplas heranças, mas uma interfacepode

suportar múltiplas heranças, assim uma classe pode herdar váriasinterfaces,

mas apenas uma classe abstrata e uma classe que implementa

uma interface tem de obrigatoriamente implementar todos os métodos

dainterface, mas o mesmo não é exigido no caso de uma classe abstrata, que

são mais rápidas que as interfaces.

 Então, quando devo utilizar o quê?

Classes Abstratas podem adicionar mais funcionalidades sem destruir as

funcionalidades das classes filhos que poderiam estar usando uma versão mais

antiga. Classes abstratas fornecem uma maneira simples e fácil

paraversionar nossos componentes e através da atualização da classe base,

todas as classes que herdam são atualizadas automaticamente com a

mudança.

Em uma interface a criação de funções adicionais terá um efeito sobre suas

classes filhos, devido à necessidade de implementação dos Métodos criados

na interface. Então, classes abstratas deveriam ser usadas principalmente para

objetos que estão estritamente relacionados, enquanto o uso de interfaces é

mais adequado para fornecer funcionalidade comum a classes independentes.

Digamos que existem duas classes, de pássaros e de aviões, e nas duas

existam os métodos chamados voar(). Seria estranho para uma classe avião

herdar a classe pássaro apenas porque necessita do método voar(). Em vez

disso, o método voar() deve ser definido em uma interface e em ambas as

classes pássaro e avião  devem implementar a interface. Se quisermos

proporcionar uma funcionalidade em comum para os componentes, devemos

utilizar uma classe abstrata.

Classes abstratas nos permitem implementar parcialmente uma classe,

enquanto a interface não contem a implementação de qualquer membro, por

isso a seleção de interface ou classes abstratas depende das necessidades

e design do nosso projeto.

Podemos fazer uma classe abstrata, interface, ou até uma  combinação de

ambas, dependendo de nossas necessidades.

Conclusão

Devemos utilizar classes abstratas quando queremos compartilhar

funcionalidades em comum entre classes e utilizar interfaces quando

desejamos que uma classe possua as mesmas assinaturas porém a

implementação de cada método não precisa ser a mesma.

Agora que já temos a interface e a classe que a implementa, para fazer uso

da interface o que o cliente precisa fazer é instanciar um objeto que

implemente essa interface e assinalar esse objeto á uma variável do

tipointerface. Então vejamos uma construção de código usando interface:

IminhaInterface obj:obj = new MinhaClasse():obj.Metodo2():

Apesar do uso de interface prover certa “indireção” relativa à classe que a

implementa, o cliente ainda precisa instanciar a classe, como pode ser visto no

exemplo anterior. Deste modo, não há uma completa separação entre

a interface e a sua implementação. 

Como os métodos de MinhaClasse são públicos, pode-se também utilizar o

seguinte código para acessar os métodos:

MinhaClasse obj;obj = new MinhaClasse();obj.Metodo2();

Como essa construção é correta e, como já foi visto, mesmo quando fazemos

uso de interface o cliente ainda precisa instanciar a classe que a implementa.

Acredito que seja essa uma das razões pelas quais os desenvolvedores não

dêem muita atenção ao uso de interfaces, principalmente aqueles que vêm do

mundo não OOP e tem uma maior dificuldade em abstrair conceitos, ou seja,

para que utilizar interfaces se podemos fazer acesso direto aos métodos

utilizando apenas a classe? 

Bem, existe aí o principio das "boas práticas". Se você quiser levar a sério o

conceito de projeto de software baseado em componentes, então há a

necessidade de aderir a algumas regras práticas e uma delas é, sempre que

possível, procurar separar a interface de sua implementação e, fazendo o uso

de interfaces, prover um máximo de “desacoplamento” entre cliente e o

provedor de serviços. 

Uma maneira de evitar o acesso direto aos método é a utilização da

implementação explicita dainterface no servidor, em que cada membro

da interface é implementado utilizando o nome dainterface.

public class MinhaClasse() : IMinhaInterface{    void IminhaInterface.Metodo1()

{....}    void IminhaInterface.Medoto2(){....}}

Note que nesse caso, as implementações dos métodos não mais utilizam a

palavra public. 

Desse modo, o cliente só poderá fazer o acesso aos métodos, via interface:

IminhaInterface obj;obj = new MinhaClasse();obj.Metodo2();

Se no cliente o desenvolvedor tentar instanciar a classe e assinalar o objeto â

uma variável que não seja do tipo da interface, o compilador mostrará um erro,

dizendo que a classe não contém o método em questão.

Web Aula 2 

Criando Classes - Interface 

O que é interface?

Para quem não domina OOP, quando se fala em interface a primeira coisa que

vem a mente é ainterface com o usuário, ou seja, telas, botões, caixas de texto,

etc. Bem, isso não deixa de ser umainterface mas, em OOP, o conceito

de interface é bem diferente. 

No MSDN você vai verificar que interfaces, da mesma maneira que classes,

definem um conjunto de propriedades, métodos e eventos, porém,

diferentemente das classes, interfaces não provêem implementações. Pode-se

dizer que uma interface é semelhante a uma classe abstrata.

Então, poderíamos ter:

public interface IminhaInterface{   void Metodo1();   void Metodo2();}

que seria semelhante a

public abstract class MinhaInterface{   abstract public void Metodo1();   abstract

public void Metodo2();}

Note que tanto a interface como a classe abstrata não implementam os dois

métodos. Surge então a pergunta: então qual a diferença?

Podemos citar algumas pequenas diferenças:

Classe abstrata

- Pode ter ou não alguma implementação. Pode também ter variáveis

membros, métodos não abstratos ou propriedades.

- Pode derivar de apenas uma classe base, mesmo que essa classe base seja

abstrata, mas pode derivar de quantas interfaces for necessário.

- Pode ter métodos e propriedades não públicos, ou seja, private ou protected.

- Pode ter métodos e membros estáticos (static) e definir constantes.

Interface

- Não tem implementações ou variáveis membros.

- Só pode derivar de interfaces.

- Todos os membros são públicos.

- Não pode ter nenhum desses itens.

Por que essas pequenas diferenças?

Uma comparação bastante utilizada para a definição de interfaces é que elas

atuam como um contrato entre o cliente e o provedor do serviço (a classe que

implementa a interface) no qual o cliente está interessado. Num contrato, todas

as regras têm que estar muito bem definidas, ou seja, tudo tem que ser

mostrado publicamente e nada pode ser escondido. Imagine só um contrato em

que algumas informações estivessem escondidas ou mesmo escritas com as

famosas "letras miúdas". Desse modo, quando se fala em uma interface, ou

contrato, o cliente pode seguramente se basear no que está escrito no contrato

(interface) porque tudo o que está lá escrito será cumprido pelo provedor dos

serviços. Pensando dessa maneira, agora fica claro porque todos os membros

de umainterface são públicos e muito bem definidos e porque na interface não

consta nenhum detalhe da implentação. Mesmo que haja alterações na

implementação não afeta o cliente que se baseia numa interface que, por

definição, é imutável. Isso também permite um alto grau de “desacoplamento”

entre o cliente e o provedor, uma vez que a interface não tem nenhum

conhecimento das implementações que ficam “encapsuladas” atrás

da interface, ou seja, no provedor (classes).

O provedor fica livre para levar a efeito as implementações, contanto que o

conteúdo do contrato (interface) seja respeitado. Obviamente que o provedor

pode fornecer muito mais do que consta no contrato, o que não faz diferença

para o cliente, pois não afeta a interface, mas nunca menos para que não haja

quebra de contrato.

Surge então a pergunta: caso seja necessário, como estender as facilidades da

interface? Uma vez que a interface pode estar sendo utilizada por outros

clientes, a saída seria a utilização de outrasinterfaces ou, em outras palavras, o

cliente fazer uso de múltiplos contratos.

Implementando uma interface

Para implementar uma interface, o que a classe tem que fazer é derivar

da interface e implementar todos os métodos definidos na interface.

Então teremos:

public interface IMinhaInterface{   void Metodo1();   void Metodo2();}

Note que o nome de interface deve iniciar com um I maiúsculo. 

Então, ao implementar a interface na classe, teremos:

public class MinhaClasse : IMinhaInterface{   public void Metodo1(){......}  

public void Metodo2(){.....}    // outras implementacoes   int Medoto3(){.......}}

Perceba que os métodos implementados na classe devem ser explicitamente

declarados como públicos, uma vez que, por definição, todos os métodos

da interface também o são.

Agora que já temos a interface e a classe que a implementa, para fazer uso

da interface o que o cliente precisa fazer é instanciar um objeto que

implemente essa interface e assinalar esse objeto á uma variável do

tipo interface. Então vejamos uma construção de código usando interface:

IminhaInterface obj:obj = new MinhaClasse():obj.Metodo2():

Apesar do uso de interface prover certa “indireção” relativa à classe que a

implementa, o cliente ainda precisa instanciar a classe, como pode ser visto no

exemplo anterior. Deste modo, não há uma completa separação entre

a interface e a sua implementação.

Como os métodos de MinhaClasse são públicos, pode-se também utilizar o

seguinte código para acessar os métodos:

MinhaClasse obj;obj = new MinhaClasse();obj.Metodo2();

Como essa construção é correta e, como já foi visto, mesmo quando fazemos

uso de interface o cliente ainda precisa instanciar a classe que a implementa.

Acredito que seja essa uma das razões pelas quais os desenvolvedores não

dêem muita atenção ao uso de interfaces, principalmente aqueles que vêm do

mundo não OOP e tem uma maior dificuldade em abstrair conceitos, ou seja,

para que utilizar interfaces se podemos fazer acesso direto aos métodos

utilizando apenas a classe?

Bem, existe aí o principio das "boas práticas". Se você quiser levar a sério o

conceito de projeto desoftware baseado em componentes, então há a

necessidade de aderir a algumas regras práticas e uma delas é, sempre que

possível, procurar separar a interface de sua implementação e, fazendo o uso

de interfaces, prover um máximo de “desacoplamento” entre cliente e o

provedor de serviços.

Uma maneira de evitar o acesso direto aos método é a utilização da

implementação explicita dainterface no servidor, em que cada membro

da interface é implementado utilizando o nome dainterface.

public class MinhaClasse() : IMinhaInterface{    void IminhaInterface.Metodo1()

{....}    void IminhaInterface.Medoto2(){....}}

Note que nesse caso, as implementações dos métodos não mais utilizam a

palavra public. 

Desse modo, o cliente só poderá fazer o acesso aos métodos, via interface:

IminhaInterface obj;obj = new MinhaClasse();obj.Metodo2();

Se no cliente o desenvolvedor tentar instanciar a classe e assinalar o objeto â

uma variável que não seja do tipo da interface, o compilador mostrará um erro,

dizendo que a classe não contém o método em questão.

WebAula 1

Implementação de classes abstratas e interfaces

 Classes Abstratas 

Existem ocasiões nas quais as classes seguem um padrão para que no futuro

outras classes herdem desta classe base. Neste caso já se tem a herança em

mente. Imagine que ao criar uma classe você perceba que, ao invés dela servir

a um único propósito, possa ser generalizada e usada para outros objetivos. 

Imagine que você esta criando uma classe e que pretende usá-la para efetuar

processos, por exemplo, cálculos para retângulos, quadrados, paralelogramos

e triângulos. O primeiro pensamento que vem é que todos estes objetos têm

algo em comum, portanto pode-se criar uma classe que atenda a todos,

mesmo que os processos (no caso algum cálculo) sejam diferentes em cada

um.

Esta classe seria uma Classe Base para eles. Como são objetos geométricos e

cada um tem uma forma diferente, pode-se criar uma classe que tenha

atributos e métodos que sirvam para todos, porém podem existir métodos que

sejam comuns a todos, mas que o trabalho realizado seja diferente para cada

objeto.

Para atender a este problema, existem as classes abstratas e métodos

abstratos, além de propriedades, eventos e indexadores abstratos. A

implementação deste tipo de classe é diferente das chamadas  Classes

Concretas.

Se cada objeto geométrico é uma classe, pode-se criar uma que seja a classe

base para elas, por exemplo, Classe Forma. Neste caso, não se faz necessária

a implementação de métodos particulares, apenas especificações, permitindo

que a criação de apenas o protótipo de métodos, isto é, métodos que não têm

bloco de comando, somente seu escopo.  Estes métodos recebem o nome de

métodos abstratos.

O código de cada um destes métodos é feito somente nas classes derivadas

da classe abstrata. Entretanto, existem duas implicações:

a) não é possível instanciar objetos da classe, uma vez que os métodos são

incompletos;

b) há a obrigatoriedade da implementação de todos os métodos abstratos para

que se possa instanciar a classe derivada.  Esta segunda exigência cria um

tipo de contrato futuro, isto é, faz com que todas as classes que derivarem

desta classe base implementem, obrigatoriamente, os métodos abstratos.

A definição de uma classe abstrata e método abstrato ficam da seguinte forma:

abstract class Forma{       abstract double area()

}

Qualquer classe derivada da classe forma, seja ela a classe círculo, retângulo, triângulo ou qualquer outra do gênero terá que implementar o método area( ), obviamente elas farão o seu próprio código de cálculo de uma área.

Interfaces

Interfaces são modelos para a construção de outras classes. Diferentemente

das classes abstratas, as interfaces não carregam código algum dentro de sua

estrutura, elas apenas definem métodos, propriedades e permitem a

declaração de constantes. Implicitamente os métodos das interfaces têm seus

acessos declarados como public e abstract.

Então, como se pode ver, uma interface não tem aplicação sozinha. Ela contém

apenas as definições de eventos, indexadores, métodos e/ou propriedades. A

razão pela qual as interfacesfornecem apenas as definições é porque elas são

implementadas por classes e estruturas, as quais devem proporcionar uma

aplicação para cada membro definido dentro desta interface.

Para exemplificar a construção de uma interface e classe derivada, utilizou-se a

idéia de impressão e edição, isto é, serão construídas duas interfaces. Veja o

exemplo a seguir:

interface Interf1{   public void mostrar();   public void mostrarnoConsole();

}

Veja que os métodos não têm codificação, apenas definições. Logo, qualquer

classe que implementar a interface terá o compromisso de criar o corpo dos

métodos definidos na interface. O escopo de uma classe que herda

da interface Interf1 fica da seguinte forma:

class Pessoa: Interf1

Como já citado, em CSharp não existe herança múltipla, contudo é possível

implementar as operações de múltiplas interfaces. Não é contraditório dizer que

não existe herança múltipla, mas pode implementar múltiplas interfaces?

Quando se diz que não há herança múltipla, é devido à impossibilidade de uma

classe herdar características de duas ou mais classes ou classes abstratas.

Todas as classes e classes abstratas contêm implementações, isto é, seus

métodos são criados dentro da sua classe, com exceção, é claro, dos métodos

abstratos em classes abstratas.

Nas interfaces não existem corpos para os métodos, apenas seus escopos

(assinaturas), e não existem atributos com valores variáveis, apenas as

chamadas constantes, nas quais o valor nunca muda durante a execução do

programa.

Qualquer classe derivada da classe forma, seja ela a classe círculo, retângulo, triângulo ou qualquer outra do gênero terá que implementar o método area( ), obviamente elas farão o seu próprio código de cálculo de uma área.

Interfaces

Interfaces são modelos para a construção de outras classes. Diferentemente

das classes abstratas, as interfaces não carregam código algum dentro de sua

estrutura, elas apenas definem métodos, propriedades e permitem a

declaração de constantes. Implicitamente os métodos das interfaces têm seus

acessos declarados como public e abstract.

Então, como se pode ver, uma interface não tem aplicação sozinha. Ela contém

apenas as definições de eventos, indexadores, métodos e/ou propriedades. A

razão pela qual as interfacesfornecem apenas as definições é porque elas são

implementadas por classes e estruturas, as quais devem proporcionar uma

aplicação para cada membro definido dentro desta interface.

Para exemplificar a construção de uma interface e classe derivada, utilizou-se a

idéia de impressão e edição, isto é, serão construídas duas interfaces. Veja o

exemplo a seguir:

interface Interf1{   public void mostrar();   public void mostrarnoConsole();

}

Veja que os métodos não têm codificação, apenas definições. Logo, qualquer

classe que implementar a interface terá o compromisso de criar o corpo dos

métodos definidos na interface. O escopo de uma classe que herda

da interface Interf1 fica da seguinte forma:

class Pessoa: Interf1

Como já citado, em CSharp não existe herança múltipla, contudo é possível

implementar as operações de múltiplas interfaces. Não é contraditório dizer que

não existe herança múltipla, mas pode implementar múltiplas interfaces?

Quando se diz que não há herança múltipla, é devido à impossibilidade de uma

classe herdar características de duas ou mais classes ou classes abstratas.

Todas as classes e classes abstratas contêm implementações, isto é, seus

métodos são criados dentro da sua classe, com exceção, é claro, dos métodos

abstratos em classes abstratas.

Nas interfaces não existem corpos para os métodos, apenas seus escopos

(assinaturas), e não existem atributos com valores variáveis, apenas as

chamadas constantes, nas quais o valor nunca muda durante a execução do

programa.

Em resumo, quando uma classe herda outra, pode reaproveitar ou especificar

comportamentos de objetos em uma hierarquia. Quando uma classe

implementa uma interface, ela não reaproveita código, uma vez que não

existem tais códigos, todavia ela se vê obrigada a seguir os comportamentos

ditados pela interface.

 Veja como fica a declaração de uma classe que implementa duas interfaces:

    interface Idemonstra 

   { 

      void Mostrar();

   }

    interface Idemonstra1

   { 

      void Mostrar();

   }

 class Implementa:Idemonstra,Idemonstra1

{

  void Idemonstra.Mostrar()

  {

      Console.WriteLine("Show() method Implemented");

  }

  void Idemonstra1.Mostrar()

  {

      Console.WriteLine("Display() method Implemented");

  }

  public static void Main(string[] args)

  {

      Implementa InstClasse = new Implementa();

      IsntClasse.Idemonstra.Mostrar();

      IsntClasse.Idemonstra1.Mostrar(); 

  }

}

Conclusão

Nesta unidade foi abordado o conceito de herança, classes abstrata

e interfaces. Portanto, é importante que você compreenda bem e passe a

utilizar tal conceito de forma coerente.

Resumo

Em algumas ocasiões as classes seguem um padrão para que no futuro outras

classes herdem desta classe, que será chamada de Classe Base. Uma classe

base pode ter mais de uma classe derivada, porém uma classe que derivará de

uma base só poderá herdar dela, isto é, uma classe derivada tem apenas uma

classe base.

Nas classes chamadas abstratas existem métodos que não contêm corpo, são

os chamados métodos abstratos. O código destes métodos abstratos é feito

somente nas classes derivadas da classe abstrata.

Foram apresentadas duas regras para estas classes abstratas:

a) não é possível instanciar objetos da classe, uma vez que os métodos são

incompletos;

b) há a obrigatoriedade da implementação de todos os métodos abstratos para

que se possa instanciar a classe derivada.

Existem ainda as interfaces, que tem similaridades com o escopo de uma classe, porém não são classes. As interfaces são um tipo de modelo para a construção de outras classes e diferenciam-se das classes abstratas por não carregarem código algum dentro de sua estrutura. Apenas definem métodos, propriedades e permitem a declaração de constantes. Implicitamente os métodos dasinterfaces têm seus acessos declarados como public e abstract.

Implementando com interfaces

A sintaxe do uso de interfaces pode parecer muito estranha, à primeira vista.

Vamos começar com um exercício para praticar a sintaxe:

1. Crie um projeto novo no C# com o nome UsandoInterfaces2. Adicione uma classe ao seu projeto clicando com o botão direito sobre o nome

do projeto (UsandoInterfaces) e de o nome de IFigurasGeometricas.3. No arquivo troque a palavra Class por interface

 Ficando então o nosso arquivo desta forma:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace UsandoInterfaces

{

    interface IFormasGeometricas

    {

        double CalcularArea()

    }

}

Agora vamos criar uma classe herdando da interface IFormasGeometricas

Novamente clique com o botão direito no projeto e adicione mais uma classe e

de o nome de FormasGeometricas.

Agora vamos criar as classes que herdaram da interface IFormasGeometricas.

Renomeie a classe FormasGeometricas para _Quadrado e faça a herança

da interface da seguinte forma:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace UsandoInterfaces

{

    class _Quadrado: IFormasGeometricas

    {

        public int Base { get; set; }

 

        public double CalcularArea()

        {

            return Base * Base;

        }

    }

} 

Web Aula 2 

Classes Abstratas

 Vamos testar a nossa classe, monte o form da aplicação da seguinte forma:

 Agora crie um atributo no seu form deste maneira:

     public partial class Form1 : Form

    {

        private _Quadrado Quadrado;

Agora no form_Load (duplo clique no formulário) do seu formulário codifique da

seguinte forma:

        private void Form1_Load(object sender, EventArgs e)

        {

            Quadrado = new _Quadrado();

        }

De um duplo clique no botão que você inseriu no form e codifique desta forma:

        private void button1_Click(object sender, EventArgs e)

        {

            Quadrado.Base = int.Parse(textBox1.Text);

            textBox2.Text = Quadrado.CalcularArea().ToString();

        }

Execute a aplicação e teste o cálculo, digitando o valor da base do quadrado a

ser calculado.

Vamos criar mais uma classe usando esta interface. Crie então a classe

Circulo, veja a codificação abaixo:

    class _Circulo : IFormasGeometricas

    {    

        public double Diametro { get; set; }

        public double CalcularArea()

        {

            // Formula da area de um circulo:

            // pi * raio ao quadrado (O raio e a metade do diâmetro ou seja

           // diâmetro dividido por 2)

           // Math.Pow é o método que calcula potencia ex: 102

           // em c# se escreve assim: Math.Pow(10,2)

            double RaioAoQuadrado = Math.Pow(Diametro / 2, 2);

            return (Math.PI * RaioAoQuadrado);

        }

    }

Agora acrescente mais alguns componentes no seu form desta forma:

 No clique do botão Calcular Área do Circulo codifique desta forma:

         {

            Circulo.Diametro = double.Parse(textBox3.Text);

            textBox4.Text    = Circulo.CalcularArea().ToString();

        }

 Agora teste a classe circulo.

 Repare que se você tivesse usado herança, não ia ganhar muita coisa, já que

cada implementação é totalmente diferente da outra: um Quadrado, um

Retangulo e um Circulo têm atributos e métodos bem diferentes. Mas, mesmo

que eles tivessem atributos em comum, utilizar interfaces é uma

maneira muito mais elegante de modelar suas classes. Todas as classes que

herdarem da InterfaceIFormasGeometricas possuirão o mesmo método

chamado CalcularArea porém cada classes efetua uma calculo diferente

acontecendo neste momento uma característica chamada polimorfismo.

Como trabalhar com classes abstratas

            Para criar uma classe abstrata precisamos usar a

declaração abstract cuja sintaxe segue abaixo:

    abstract class Util

    {

    }

            Para entendermos as classes abstract, vamos criar os mesmos

exercícios acima com classes abstratas. Vamos lá:

1. Crie um projeto novo no C# com o nome UsandoClassesAbstratas2. Adicione uma classe ao seu projeto clicando com o botão direito sobre o nome

do projeto (UsandoClassesAbstratas) e de o nome de AFigurasGeometricas.3. No arquivo adicione a clausula abstract antes da palavra Class

Ficando então o nosso arquivo desta forma:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace UsandoClassesAbstrata

{

    abstract class AFormasGeometricas

    {

        public abstract double CalcularArea();

    }

}

Agora vamos criar uma classe herdando das classes abstrata

AFormasGeometricas.

Novamente clique com o botão direito no projeto e adicione mais uma classe e

de o nome de FormasGeometricas.

Agora vamos criar as classes que herdaram da classe abstrata

AFormasGeometricas.

Renomeie a classe FormasGeometricas para _Quadrado e faça a herança da

classes abstrata da seguinte forma:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace UsandoClassesAbstrata

{

    class _Quadrado: AFormasGeometricas

    {

        public int Base { get; set; }

        public override double CalcularArea()

        {

            return Base * Base;

        }

    }

Veja que para implementar uma classe com classe abstrata, os métodos

precisam ser definidos com a cláusula override. Essa foi a única diferença com

relação a implementação com interfaces.

Vamos testar a nossa classe, monte o form da aplicação da seguinte forma:

Agora crie um atributo no seu form deste maneira:

    public partial class Form1 : Form

    {

        private _Quadrado Quadrado;

Agora no form_Load (duplo clique no formulario) do seu formulário codifique da

seguinte forma:

       private void Form1_Load(object sender, EventArgs e)

        {

            Quadrado = new _Quadrado();

        }

De um duplo clique no botão que você inseriu no form e codifique desta forma:

        private void button1_Click(object sender, EventArgs e)

        {

            Quadrado.Base = int.Parse(textBox1.Text);

            textBox2.Text = Quadrado.CalcularArea().ToString();

        }

Execute a aplicação e teste o cálculo, digitando o valor da base do quadrado a

ser calculado.

Vamos criar mais uma classe usando esta classes abstrata. Crie então a classe

Círculo. Veja a codificação abaixo:

    class _Circulo : AFormasGeometricas

    {    

        public double Diametro { get; set; }

        public override double CalcularArea()

        {

            // Formula da area de um circulo:

            // pi * raio ao quadrado (O raio e a metade do diâmetro ou seja

           // diâmetro dividido por 2)

           // Math.Pow é o método que calcula potencia ex: 102

           // em c# se escreve assim: Math.Pow(10,2)

            double RaioAoQuadrado = Math.Pow(Diametro / 2, 2);

            return (Math.PI * RaioAoQuadrado);

        }

    }

Agora acrescente mais alguns componentes no seu form desta forma:

No clique do botão Calcular Área do Circulo codifique desta forma:

        {

            _Circulo Circulo = new _Circulo();

            Circulo.Diametro = double.Parse(textBox3.Text);

            textBox4.Text    = Circulo.CalcularArea().ToString();

        }

Agora teste a classe circulo.