public class Produto //Nome da classe
{
private int codigo; //Atributo da classe
private string nome; //Atributo da classe
private decimal preco; //Atributo da classe
public int Codigo { get => codigo; set => codigo = value; } //Propriedade da classe
public string Nome { get => nome; set => nome = value; } //Propriedade da classe
public decimal Preco { get => preco; set => preco = value; } //Propriedade da classe
}public class Assinatura : Produto
{
... //Demais propriedade e métodos da classe filha
}
3º Slide: Exemplo de interface em C#.
Em C# no nome das interfaces começam sempre com I.
public interface IExpiravel
{
TimeSpan GetTempoRestante(); //Métodos(somente assinatura)
}
public class Assinatura : IExpiravel
{
public TimeSpan GetTempoRestante()
{
return dataExpiracao - DateTime.Today; //Implementação do método definido na interface
}
}
public class Assinatura : Produto, IExpiravel
{
public TimeSpan GetTempoRestante()
{
return dataExpiracao - DateTime.Today; //Implementação do método definido na interface
}
}
A definição de classes na linguagem C# é feita com uma sintaxe simples, de fácil compreensão e nos permite criar atributos, propriedades e métodos. Por exemplo, na Figura 1 temos a representação de uma classe chamada Produto com seus campos e logo em seguida vemos como essa classe seria implementada em C#:
public class Produto
{
private int codigo;
private string nome;
private decimal preco;
public int Codigo { get => codigo; set => codigo = value; }
public string Nome { get => nome; set => nome = value; }
public decimal Preco { get => preco; set => preco = value; }
}Linha 1: Nessa linha temos os seguintes termos: public define a visibilidade da classe como pública; class define que estamos criando uma classe; e Produto é o nome da classe.
Linhas 3 a 5: Aqui temos o que chamamos de atributos. São variáveis privadas que representam as características da classe. Note o modificador de acesso private, o tipo e o nome de cada atributo;
Linhas 7 a 9: Já aqui temos as propriedades da classe, que são públicas e encapsulam os atributos. Observe que para cada atributo há uma propriedade e que no corpo delas definimos os métodos get e set. O get retorna o atributo correspondente e o set recebe um valor e o repassa para o atributo.
No corpo de cada propriedade usamos expressões lambda para definir os métodos get e set. Essa sintaxe é equivalente à seguinte:
public int Codigo
{
get { return codigo; }
set { codigo = value; }
}O parâmetro value possui o mesmo tipo da propriedade e é recebido de forma implícita no método get, sem que seja necessário declará-lo. Isso é equivalente a criar, por exemplo, os métodos getCodigo e setCodigo, como fazemos em outras linguagens:
public int getCodigo
{
return codigo;
}
public void setCodigo(int value)
{
codigo = value;
}Herança
Herança é um tipo de relacionamento muito comum na orientação a objetos e ocorre quando uma classe descende da outra e herda suas características e comportamentos, além de implementar os seus próprios. Por exemplo, considere o diagrama de classes da Figura 2 em que Assinatura herda de Produto.
Nesse cenário a classe Assinatura herda de Produto e também define uma propriedade e método próprios. Em C# essa classe seria implementada da seguinte forma:
public class Assinatura : Produto
{
private DateTime dataExpiracao;
public DateTime DataExpiracao { get => dataExpiracao;
set => dataExpiracao = value; }
public TimeSpan GetTempoRestante()
{
return dataExpiracao - DateTime.Today;
}
}Linha 1: A herança em C# é representada pelos dois pontos na definição da classe, seguido do nome da classe que está sendo herdada. Nesse caso, Assinatura herda de Produto;
Linhas 3 a 6: Nesse trecho temos o atributo e propriedade que dizem respeito apenas à assinatura;
Linhas 8 a 11: Aqui temos o método GetTempoRestante da assinatura, que retorna um TimeSpan representando o tempo que falta até a assinatura expirar;
Interfaces
Na Orientação a Objetos as interfaces funcionam como contratos, ou seja, elas definem comportamentos que devem ser cumpridos pelas classes. Quando uma classe atende a uma interface, dizemos que ela implementa essa interface. Na Figura 3 temos um diagrama que mostra uma nova configuração para as classes que representamos anteriormente:
Nesse cenário a interface IExpiravel define que toda classe que representa um produto cuja data de expiração ou validade chega ao fim (expira) deve implementar o método GetTempoRestante. Por exemplo, se tivéssemos outra classe Voucher ou Desconto, por exemplo, ela poderia implementar essa classe e definir o comportamento desse método.
Em C# a interface IExpiravel seria escrita da seguinte forma:
public interface IExpiravel
{
TimeSpan GetTempoRestante();
}Linha 1: Note o uso da palavra reservada interface e também no nome da interface: IExpiravel. Em C# convenciona-se iniciar o nome das interfaces com I (maiúsculo);
Linha 3: As interfaces definem apenas a assinatura do método, não seu comportamento. A implementação do método fica por conta da classe que implementar essa interface.
Agora, considerando que a classe Assinatura implementa essa interface, seu código seria modificado da seguinte forma:
public class Assinatura : Produto, IExpiravel
{
private DateTime dataExpiracao;
public DateTime DataExpiracao { get => dataExpiracao;
set => dataExpiracao = value; }
public TimeSpan GetTempoRestante()
{
return dataExpiracao - DateTime.Today;
}
}Linha 1: A sintaxe para implementar uma interface em C# é a mesma que para herdar de outra classe: usando dois pontos;
Linhas 8 a 11: Como a classe implementa a interface IExpiravel, ela deve obrigatoriamente definir o comportamento do método GetTempoRestante.
A partir desses conceitos podemos criar diversas outras classes e interfaces, com seus atributos, propriedades e métodos específicos.
Sugestão de conteúdo
- Guias de Tecnologia
- Cursos
- Exercícios
- Projetos completos
- DevCasts
- Artigos
- Suporte em tempo real
