Tutorial Básico C#

Tutorial Avançado C#

C# Orientado a Objetos (OOP)

Sobrecarga de Operadores do C#Herança do C#

Polimorfismo do C#

O polimorfismo é a capacidade de um comportamento ter várias表现形式 ou formas diferentes.

Polimorfismoisto significa que há várias formas. No paradigma de programação orientada a objetos, o polimorfismo geralmente se manifesta como "um interface, várias funcionalidades".

O polimorfismo pode ser estático ou dinâmico. EmPolimorfismo estáticoem que a resposta da função ocorre no tempo de compilação. Empolimorfismo dinâmicoem que a resposta da função ocorre no tempo de execução.

No C#, todos os tipos são polimórficos, pois todos os tipos, incluindo os tipos definidos pelo usuário, herdam de Object.

O polimorfismo é a capacidade de uma interface executar diferentes operações com diferentes exemplos, conforme mostrado na figura:

Na realidade, por exemplo, quando pressionamos F1 a ação de tecla:

Se você estiver na interface do Flash, ao clicar, é exibida a AS 3 da documentação de ajuda;
Se você estiver no Word, ao clicar, é exibida a ajuda do Word;
No Windows, ao clicar, é exibida a ajuda e suporte do Windows.

O mesmo evento ocorrendo em diferentes objetos pode gerar resultados diferentes.

Polimorfismo estático

No tempo de compilação, o mecanismo de ligação entre funções e objetos é chamado de ligação early binding, também conhecido como ligação estática. O C# oferece duas técnicas para implementar a polimorfismo estático. São elas:

sobre carga de funções
Sobrecarga de operadores

A sobrecarga de operadores será discutida no próximo capítulo, e a seguir discutiremos a sobrecarga de funções.

sobre carga de funções

Você pode ter várias definições de funções com o mesmo nome no mesmo escopo. As definições das funções devem ser diferentes umas das outras, podem ser diferentes tipos de parâmetros na lista de parâmetros ou diferentes números de parâmetros. Não é permitido sobrecarregar declarações de funções que differem apenas no tipo de retorno.

O exemplo a seguir demonstra várias funções idênticas Add()usada para somar diferentes números de argumentos:

Exemplo

using System;
namespace PolymorphismApplication
{}}
　　　　public class TestData　　
　　　　{}}　　
　　　　　　　　public int Add(int a, int b, int c)　　
　　　　　　　　{}}　　
　　　　　　　　　　　　return a　+　b　+　c;　　
　　　　　　　　}　　
　　　　　　　　public int Add(int a, int b)　　
　　　　　　　　{}}　　
　　　　　　　　　　　　return a　+　b;　　
　　　　　　　　}　　
　　　　}　　
　　　　class Program　　
　　　　{}}　　
　　　　　　　　void Main(string[] args)　　
　　　　　　　　{}}　　
　　　　　　　　　　　　TestData dataClass = new TestData();
　　　　　　　　　　　　int add1　= dataClass.Add(1,　2);　　
　　　　　　　　　　　　int add2　= dataClass.Add(1,　2,　3);
　　　　　　　　　　　　Console.WriteLine("add1　:"　+　add1);
　　　　　　　　　　　　Console.WriteLine("add2　:"　+　add2);　　
　　　　　　　　}　　
　　　　}　　
}

O exemplo a seguir demonstra várias funções idênticas print()usada para imprimir diferentes tipos de dados:

Exemplo

using System;
namespace PolymorphismApplication
{}}
　　　class Printdata
　　　{}}
　　　　　　void print(int i)
　　　　　　{}}
　　　　　　　　　Console.WriteLine("saída de número inteiro: {0}", i);
　　　　　　}
　　　　　　void print(double f)
　　　　　　{}}
　　　　　　　　　Console.WriteLine("saída de número decimal: {0}", f);
　　　　　　}
　　　　　　void print(string s)
　　　　　　{}}
　　　　　　　　　Console.WriteLine("saída de string: {0}", s);
　　　　　　}
　　　　　　void Main(string[] args)
　　　　　　{}}
　　　　　　　　　Printdata p = new Printdata();
　　　　　　　　　//　chamar print para imprimir um número inteiro
　　　　　　　　　p.print(1);
　　　　　　　　　//　chamar print para imprimir um número decimal
　　　　　　　　　p.print(1.23);
　　　　　　　　　//　chamar print para imprimir uma string
　　　　　　　　　p.print("Hello w3codebox");
　　　　　　　　　Console.ReadKey();
　　　　　　}
　　　}
}

Quando o código acima for compilado e executado, ele produzirá os seguintes resultados:

saída de número inteiro:　1
saída de número decimal:　1.23
saída de string: Hello w3codebox

polimorfismo dinâmico

O C# permite que você use a palavra-chave abstract criar classes abstratas, que fornecem a implementação parcial de uma interface. Quando uma classe derivada herda dessa classe abstrata, a implementação é completada.classe abstrataque contêm métodos abstratos, que podem ser implementados pelas classes derivadas. As classes derivadas têm funcionalidades mais especializadas.

Atenção, aqui estão algumas regras sobre classes abstratas:

Não é possível criar uma instância de uma classe abstrata.
Não é possível declarar um método abstrato fora de uma classe abstrata.
colocando a palavra-chave antes da definição da classe sealedpode-se declarar a classe comoclasse selada. Quando uma classe é declarada como sealed em tempo de execução, ela não pode ser herdada. A classe abstrata não pode ser declarada como sealed.

O seguinte programa demonstra uma classe abstrata:

Exemplo

using System;
namespace PolymorphismApplication
{}}
　　　classe abstrata Shape
　　　{}}
　　　　　　　abstract public int area();
　　　}
　　　class Rectangle : Shape
　　　{}}
　　　　　　private int length;
　　　　　　private int width;
　　　　　　public Rectangle(int a=0, int b=0)
　　　　　　{}}
　　　　　　　　　length = a;
　　　　　　　　　width = b;
　　　　　　}
　　　　　　public override int area()
　　　　　　{}}　
　　　　　　　　　Console.WriteLine("Área da classe Retângulo:");
　　　　　　　　　return (width　*　length);　
　　　　　　}
　　　}
　　　class RectangleTester
　　　{}}
　　　　　　void Main(string[] args)
　　　　　　{}}
　　　　　　　　　Rectangle r = new Rectangle(10,　7);
　　　　　　　　　double a = r.area();
　　　　　　　　　Console.WriteLine("Área: {0}", a);
　　　　　　　　　Console.ReadKey();
　　　　　　}
　　　}
}

Quando o código acima for compilado e executado, ele produzirá os seguintes resultados:

Área da classe Rectangle:
Área:　70

Quando há uma função definida na classe que precisa ser implementada na classe derivada, pode-se usarMétodo virtual.

O método virtual é usado com a palavra-chave virtual declarado.

O método virtual pode ter diferentes implementações em diferentes classes derivadas.

a chamada do método virtual ocorre no tempo de execução.

A polimorfismo dinâmico é através de classe abstrata e Método virtual implementado.

O exemplo a seguir cria a classe base Shape, cria classes derivadas Circle, Rectangle, Triangle, a classe Shape fornece um método virtual chamado Draw, que é sobrescrito em cada classe derivada para desenhar a forma específica da classe.

Exemplo

using System;
using System.Collections.Generic;
public class Shape
{}}
　　　　public int X { get; private set; }
　　　　public int Y { get; private set; }
　　　　public int Height { get; set; }
　　　　public int Width { get; set; }
　　　
　　　　//　Método virtual
　　　　public virtual void Draw()
　　　　{}}
　　　　　　　　Console.WriteLine("Executar a tarefa de desenho da classe base");
　　　　}
}
class Circle : Shape
{}}
　　　　public override void Draw()
　　　　{}}
　　　　　　　　Console.WriteLine("Desenhar um círculo");
　　　　　　　　base.Draw();
　　　　}
}
class Rectangle : Shape
{}}
　　　　public override void Draw()
　　　　{}}
　　　　　　　　Console.WriteLine("Desenhar um retângulo");
　　　　　　　　base.Draw();
　　　　}
}
class Triangle : Shape
{}}
　　　　public override void Draw()
　　　　{}}
　　　　　　　　Console.WriteLine("Desenhar um triângulo");
　　　　　　　　base.Draw();
　　　　}
}
class Program
{}}
　　　　void Main(string[] args)
　　　　{}}
　　　　　　　　//　Criar um objeto List<Shape> e adicionar Circle, Triangle e Rectangle a ele
　　　　　　　　var shapes = new List<Shape>
　　　　　　　　{}}
　　　　　　　　　　　　new Rectangle(),
　　　　　　　　　　　　new Triangle(),
　　　　　　　　　　　　new Circle()
　　　　　　　　};
　　　　　　　　//　Usar loop foreach para percorrer a lista de subclasses e chamar o método Draw de cada objeto Shape　
　　　　　　　　foreach (var shape in shapes)
　　　　　　　　{}}
　　　　　　　　　　　　shape.Draw();
　　　　　　　　}
　　　　　　　　Console.WriteLine("Pressione qualquer tecla para sair.");
　　　　　　　　Console.ReadKey();
　　　　}
}

Quando o código acima for compilado e executado, ele produzirá os seguintes resultados:

Desenhar um retângulo
Executar a tarefa de desenho da classe base
Desenhar um triângulo
Executar a tarefa de desenho da classe base
Desenhar um círculo
Executar a tarefa de desenho da classe base
Pressione qualquer tecla para sair.

O seguinte programa demonstra como calcular a área de diferentes figuras geométricas através do método virtual area():

Exemplo

using System;
namespace PolymorphismApplication
{}}
　　　class Shape　
　　　{}}
　　　　　　protected int width, height;
　　　　　　public Shape(int a = 0, int b = 0)
　　　　　　{}}
　　　　　　　　　width = a;
　　　　　　　　　height = b;
　　　　　　}
　　　　　　public virtual int area()
　　　　　　{}}
　　　　　　　　　Console.WriteLine("Área da classe pai:");
　　　　　　　　　return 0;
　　　　　　}
　　　}
　　　class Rectangle: Shape
　　　{}}
　　　　　　public Rectangle(int a = 0, int b = 0): base(a, b)
　　　　　　{}}
　　　　　　}
　　　　　　public override int area()
　　　　　　{}}
　　　　　　　　　Console.WriteLine("Área da classe Retângulo:");
　　　　　　　　　return (width　*　height);　
　　　　　　}
　　　}
　　　class Triangle: Shape
　　　{}}
　　　　　　public Triangle(int a = 0, int b = 0): base(a, b)
　　　　　　{}}
　　　　　　
　　　　　　}
　　　　　　public override int area()
　　　　　　{}}
　　　　　　　　　Console.WriteLine("Área da classe Triangle:");
　　　　　　　　　return (width　*　height　/　2);　
　　　　　　}
　　　}
　　　class Caller
　　　{}}
　　　　　　public void CallArea(Shape sh)
　　　　　　{}}
　　　　　　　　　int a;
　　　　　　　　　a = sh.area();
　　　　　　　　　Console.WriteLine("Área: {0}", a);
　　　　　　}
　　　}　　
　　　class Tester
　　　{}}
　　　　　　
　　　　　　void Main(string[] args)
　　　　　　{}}
　　　　　　　　　Caller c = new Caller();
　　　　　　　　　Rectangle r = new Rectangle(10,　7);
　　　　　　　　　Triangle t = new Triangle(10,　5);
　　　　　　　　　c.CallArea(r);
　　　　　　　　　c.CallArea(t);
　　　　　　　　　Console.ReadKey();
　　　　　　}
　　　}
}

Quando o código acima for compilado e executado, ele produzirá os seguintes resultados:

Área da classe Rectangle:
Área:70
Área da classe Triangle:
Área:25

Sobrecarga de Operadores do C#Herança do C#