Interfaces (introdução) e implementação de várias interfaces
Defina interfaces como contratos, implemente várias interfaces em uma classe, use polimorfismo baseado em interfaces e aprenda os conceitos básicos da implementação explícita de interfaces.
Interfaces (introdução) e implementação de várias interfaces é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 2 de 3. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C# Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C# Academy inclui 3 aulas no total.
Visão geral das interfaces
Objetivo: programe voltado para interfaces e escreva código flexível.
- As interfaces declaram o quê, não como
- Implemente várias interfaces
- Passe interfaces para funções
- A implementação explícita resolve conflitos de nomes
Implementação de várias interfaces
As interfaces definem um contrato. Uma classe pode implementar várias interfaces para expressar papéis diferentes.
using System;
public interface IPlayable
{
void Play();
}
public interface IHasDuration
{
int DurationSeconds { get; }
}
public class Song : IPlayable, IHasDuration
{
private readonly string _title;
private readonly int _seconds;
public Song(string title, int seconds)
{
_title = title;
_seconds = seconds;
}
public int DurationSeconds { get { return _seconds; } }
public void Play()
{
Console.WriteLine("Playing " + _title + " (" + _seconds + "s)");
}
}
public class Program
{
public static void Main(string[] args)
{
Song s = new Song("Hello", 5);
s.Play();
Console.WriteLine("Duration = " + s.DurationSeconds);
}
}
Polimorfismo de interfaces
Aceite um tipo de interface nos métodos. Quem chama o código pode passar qualquer implementação.
using System;
public interface IPrintable
{
void Print();
}
public class Report : IPrintable
{
private readonly string _text;
public Report(string text) { _text = text; }
public void Print() { Console.WriteLine("Report: " + _text); }
}
public class Label : IPrintable
{
private readonly string _text;
public Label(string text) { _text = text; }
public void Print() { Console.WriteLine("Label: " + _text); }
}
public class Program
{
// Works with any IPrintable (polymorphism)
static void PrintAll(IPrintable item)
{
item.Print();
}
public static void Main(string[] args)
{
PrintAll(new Report("Sales Q1"));
PrintAll(new Label("Fragile"));
}
}
Implementação explícita
A implementação explícita elimina ambiguidades entre membros com o mesmo nome e os oculta da superfície da classe.
using System;
public interface ILogger { void Write(string msg); }
public interface IFileWriter { void Write(string msg); }
public class DualWriter : ILogger, IFileWriter
{
// Explicit implementations: only visible via the interface reference
void ILogger.Write(string msg) { Console.WriteLine("[LOG] " + msg); }
void IFileWriter.Write(string msg) { Console.WriteLine("[FILE] " + msg); }
public void Demo()
{
Console.WriteLine("DualWriter ready");
}
}
public class Program
{
public static void Main(string[] args)
{
DualWriter dw = new DualWriter();
dw.Demo();
ILogger log = dw;
IFileWriter file = dw;
log.Write("started");
file.Write("saved");
}
}
Coleções de interfaces
Armazene implementações diferentes em uma lista do tipo da interface e percorra-as de maneira uniforme.
using System;
using System.Collections.Generic;
public interface ITask
{
void Run();
}
public class EmailTask : ITask
{
public void Run() { Console.WriteLine("Send email"); }
}
public class BackupTask : ITask
{
public void Run() { Console.WriteLine("Run backup"); }
}
public class Program
{
public static void Main(string[] args)
{
List<ITask> tasks = new List<ITask>();
tasks.Add(new EmailTask());
tasks.Add(new BackupTask());
foreach (ITask t in tasks)
{
t.Run(); // calls the right implementation
}
}
}
Dicas sobre interfaces
Dicas:
- Prefira interfaces pequenas que descrevam um único papel.
- Use interfaces para testes (troque as implementações).
- Em C# 6, as interfaces não têm fields nem corpos de métodos.
- Implemente várias interfaces para compor comportamentos.
Conceito de interfaces
Recapitulação
Recapitulação: as interfaces são contratos e permitem a implementação múltipla por classe. Passe interfaces para funções, mantenha-as pequenas e use a implementação explícita para resolver conflitos.
Perguntas Frequentes
A aula “Interfaces (introdução) e implementação de várias interfaces” é grátis?
Sim — o texto completo de “Interfaces (introdução) e implementação de várias interfaces” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C# Academy, atualize para CoddyKit PRO. O curso de C# Academy inclui 3 aulas no total.
O que vou aprender em “Interfaces (introdução) e implementação de várias interfaces”?
Defina interfaces como contratos, implemente várias interfaces em uma classe, use polimorfismo baseado em interfaces e aprenda os conceitos básicos da implementação explícita de interfaces. Você pratica C# Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar C# Academy?
Nenhuma experiência prévia é necessária. C# Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 3.
Quanto tempo leva a aula “Interfaces (introdução) e implementação de várias interfaces”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de C# Academy?
Sim. Cada aula de C# Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- virtual/override/sealed; classes abstratas
- Interfaces (introdução) e implementação de várias interfaces
- Polimorfismo e despacho dinâmico