C polimorfismo #

polimorfismo estático

Em tempo de compilação, as funções de mecanismo de conexão e objetos é chamado ligação inicial, também conhecida como ligação estática. C # oferece duas técnicas para implementar o polimorfismo estático. Eles são:

• sobrecarga de função
• sobrecarga de operadores

Operador sobrecarga irá discutir na próxima seção, vamos discutir o seguinte sobrecarga de função.

sobrecarga de função

Pode ser no mesmo intervalo para o mesmo nome de função tem várias definições. funções definidas devem ser diferentes um do outro, pode ser uma lista de parâmetros tipos de parâmetros, pode ser também um certo número de parâmetros diferentes. Você não pode ser sobrecarregado apenas pelo tipo de retorno da declaração da função.

O exemplo a seguir demonstra vários da mesma funçãoprint (), para a impressão de diferentes tipos de dados:

using System;
PolymorphismApplication namespace
{
   classe Printdata
   {
      vazio de impressão (int i)
      {
         Console.WriteLine ( "Impressão int: {0}", i);
      }

      void print (double f)
      {
         Console.WriteLine ( "Impressão float: {0}", f);
      }

      vazio de impressão (string s)
      {
         Console.WriteLine ( "string Impressão: {0}", s);
      }
      static void Main (string [] args)
      {
         p Printdata = new Printdata ();
         // Invoca impressão para imprimir um p.print inteiro (5);
         // Invoca impressão para imprimir p.print float (500,263);
         // Invoca imprimir na p.print seqüência de impressão ( "Olá C ++");
         Console.ReadKey ();
      }
   }
}

Quando o código acima é compilado e executado, ele produz os seguintes resultados:

int Impressão: 5
flutuador Impressão: 500,263
seqüência de impressão: Olá C ++

polimorfismo dinâmico

C # permite que você use a palavra-chaveabstract para criar uma classe abstrata, implementação de interface prevê parte da classe.Quando uma classe derivada herda da classe abstrata para alcançar completa.Abstract classe contém métodos abstratos, métodos abstratos pode ser implementado como uma classe derivada.As classes derivadas têm funções mais especializadas.

Por favor, note que a seguir estão algumas regras para classes abstratas:

• Você não pode criar uma instância de uma classe abstrata.
• Você não pode declarar um método abstrato fora uma classe abstrata.
• Ao colocar na frente das palavras-chave de definição de classefechados, a classe pode ser declarada como classes seladas.Quando uma classe é declaradoselado, ele não pode ser herdada.Uma classe abstrata não pode ser declarado como selado.

O programa a seguir demonstra uma classe abstrata:

using System;
PolymorphismApplication namespace
{
   abstract class Shape
   {
      pública área int abstrato ();
   }
   classe Retângulo: Forma
   {
      length int privado;
      width int privado;
      Retângulo pública (int a = 0, int b = 0)
      {
         comprimento = a;
         width = b;
      }
      área int override pública ()
      { 
         Console.WriteLine ( "área de classe Retângulo:");
         retorno (comprimento, largura *); 
      }
   }

   classe RectangleTester
   {
      static void Main (string [] args)
      {
         Retângulo r = new Rectangle (10, 7);
         double a = r.area ();
         Console.WriteLine ( "Tamanho: {0}", a);
         Console.ReadKey ();
      }
   }
}

Quando o código acima é compilado e executado, ele produz os seguintes resultados:

Retângulo Classe Tamanho:
Área: 70

Quando uma função é definida nas necessidades da classe a ser implementada em uma classe derivada, você pode usarmétodos virtuais.método virtual é declarado usando a palavra-chavevirtual.Métodos virtuais pode ser implementado de forma diferente em diferentes classes herdadas. Chamadas para métodos virtuais ocorre em tempo de execução.

polimorfismo dinâmico é alcançado através declasses abstratas e métodos virtuais.

O programa a seguir demonstra este ponto:

using System;
PolymorphismApplication namespace
{
   Forma classe 
   {
      width int protegida, altura;
      Forma pública (int a = 0, int b = 0)
      {
         largura = A;
         height = b;
      }
      pública área int virtual ()
      {
         Console.WriteLine ( "área de pai:");
         return 0;
      }
   }
   classe Retângulo: Forma
   {
      Retangular pública (int a = 0, b = 0 int): base (a, b)
      {

      }
      área int override pública ()
      {
         Console.WriteLine ( "área de classe Retângulo:");
         retornar (largura * altura); 
      }
   }
   classe Triangle: Forma
   {
      Triângulo pública (int a = 0, b = 0 int): base (a, b)
      {
      
      }
      área int override pública ()
      {
         Console.WriteLine ( "área de classe Triangle:");
         retornar (largura * altura / 2); 
      }
   }
   class Caller
   {
      CallArea public void (sh Shape)
      {
         int a;
         um sh.area = ();
         Console.WriteLine ( "Tamanho: {0}", a);
      }
   }  
   Tester classe
   {
      
      static void Main (string [] args)
      {
         Caller c = new chamador ();
         Retângulo r = new Rectangle (10, 7);
         Triângulo t = new Triângulo (10, 5);
         c.CallArea (R);
         c.CallArea (t);
         Console.ReadKey ();
      }
   }
}

Quando o código acima é compilado e executado, ele produz os seguintes resultados:

Retângulo Classe Tamanho:
Área: 70
área de classe Triangle:
Área: 25