Sexta .NET – Aula 7 – Orientação a Objeto – Parte III

Boa tarde pessoal, aqui vamos com a aula da semana.

O conteúdo que veremos hoje complementa o que estamos acompanhando nas útltimas semanas, volto a dizer que é muito importante que sigam e treinem bastante a orientação a objeto, pois ela é crucial e pode ser um diferencial em sua carreira.

Vamos ao que interessa?

Sexta .NET – Aula 7 – Orientação a Objeto – Parte III

Membros de Classe
Pertencem à classe e não às instâncias
Podem ser atributos, propriedades e métodos

public class Cliente
{
public static string tipoEntidade = “Teste”;
public static void Excluir(int identificacao)
{
/* excluir cliente com essa identificação */
}
}
...
Console.WriteLine(“Tipo de Entidade: {0}”, Cliente.tipoEntidade);
...
int clienteId = 5;
Cliente.Excluir(clienteId);

Construtores de classe – estáticos, compartilhados, globais
São executados antes do primeiro objeto do tipo em questão ser criado ou do primeiro método de classe ser invocado
Não possuem parâmetros
Não apresentam modificadores de acesso
Podem co-existir com construtores de instâncias
Utilizados para inicializar uma classe

Construtores de Classe

public class Cliente
{
private static Random numeroRandomico;
public int senhaCliente;

static Cliente()
{
numeroRandomico = new Random();
}

public void CarregarSenha()
{
senhaCliente = numeroRandomico.Next();
}
}

Classes Abstratas

Pode acontecer que ao escrever um método para uma classe base você não saiba como ele será implementado. Neste caso, a implementação será feita pela classe que herdar o método (a classe filha).

Pode acontecer também que você saiba que um determinado método será sobreposto com certeza na classe filha; então, por que definir sua implementação se ela não será usada?

Nestes casos você apenas define a assinatura do método e deixa a definição por conta da classe que irá herdar a classe pai.

Estas classes são então chamadas classes abstratas, o método que você não implementou é chamado de método abstrato.

As classes abstratas não podem ser instanciadas através da palavra chave New.

Uma classe abstrata é uma classe base genérica
Contém métodos abstratos que devem ser implementados nas classes que derivam dela
Um método abstrato não apresenta implementação na classe base

public abstract class Pessoa {
public abstract void Cadastrar();
public abstract string Nome { get; set; }
public abstract int Id { get; }
public virtual void Viajar() { /* Ação */ }
}

Pode conter membros não-abstratos

Derivando a classe abstrata e implementando os membros abstratos

public class Diretor : Pessoa
{
public override void Cadastrar()
{ /* Ações */ }
public override string Nome
{
get { /* Implementação get */ }
set { /* Implementação set */ }
}
public override int Id
{
get { /* Implementação get */ }
}
}

Interfaces

Uma interface é parecida com uma classe abstrata, a diferença é que uma classe abstrata pode possuir métodos que não estejam implementados e pode possuir métodos que estejam implementados.

Uma interface possui somente métodos que não estão implementados e que devem ser implementados pela classe que usar a interface.

Como o C# não suporta herança múltipla as interfaces permitem que uma classe estenda múltiplas interfaces contornando o problema.

Uma interface no C# não pode conter atributos, somente pode ter métodos, propriedades e eventos. Todos os membros de uma interface são públicos e não podem usar um modificador de acesso.

A classe que implementa a interface deve possuir a definição de todos métodos existentes na interface. Esta definição deve possuir o mesmo nome e a mesma assinatura, retorno e parâmetros, do método na interface.

O nome da classe e o nome da interface são separados por dois pontos(:).
Uma interface define a mesma funcionalidade e comportamento à classes não relacionadas diretamente

Declarando a interface

public interface IProduto
{
bool EPerecivel { get; }
Fornecedor RecuperarFornecedor();
void RegistrarVenda(Cliente cliente);
}

Implementando a interface

public class Computador : IProduto
{
private bool ePerecivel;
public bool EPerecivel
{
get { return ePerecivel; }
}
public Fornecedor RecuperarFornecedor()
{
return new Fornecedor();
}
public void RegistrarVenda(Cliente cliente)
{
// Rotina para registrar vendas
}
}

IS e AS

if (computador is IProduto)
{
// ações
}

IProduto produto = computador as IProduto;

if (produto != null)
{
Fornecedor fornecedor = produto.RecuperarFornecedor();
}

Pode tornar o comportamento de seus objetos semelhante ao comportamento dos objetos da .NET Framework
Exemplos:
ICollection
IComparer
IDictionary
IEnumerable

public class Cliente : Pessoa, IComparable
{
...
}

Estruturas de Repetição

foreach
Esta estrutura de repetição é uma variação do for.
Sua diferença está no fato de ser necessário apenas especificar uma variável e a coleção ou array cujos registros serão percorridos.

int[] i = { 1, 3, 5, 7, 9 };
foreach (int j in i)
{
Response.Write(j);
Response.Write("
");
}

Estruturas

Estruturas são tipos por valor, que podem conter:
Um construtor
Constantes
Atributos
Métodos
Propriedades
Uso recomendado para representar objetos leves e/ou que eventualmente podem constituir arrays de grande dimensão.
Não podem ser herdados, porem podem implementar Interfaces.

Exemplo de uma estrutura:

struct Circulo {
private int _raio; // Atributo

public double Circunferencia // Propriedade
{ get { return 2 * _raio * Math.PI; } }
// Regra específica para retornar um valor.

public Circulo(int raio) // Construtor com um argumento
{ this._raio = raio; } // Atribuição do valor do argumento
} // para o atributo do objeto.

… Dentro do evento Page_Load

Circulo meuCirculo = new Circulo(10);
// Instancia de uma estrutura.
Response.Write(meuCirculo.Circunferencia);
// Imprime o valor de uma propriedade

}

Exemplo de overload de métodos:

... Dentro da mesma estrutura do exemplo anterior:

public void DiminuirRaio(){ // Método simples sem argumentos
if (_raio > 1)
_raio–;
}

public void DiminuirRaio(int valor){// Overload do método anterior
if (_raio – valor > 1) // com um argumento
_raio -= valor;
}

… Dentro do evento Page_Load

meuCirculo.DiminuirRaio(); // Chamando o método sem argumentos
meuCirculo.DiminuirRaio(2); // Chamando o overload
// do método anterior

Bom, o conteúdo preparado para este tema é muito extenso.
Vamos parar por aqui e na semana que vem continuamos!

Com todo o apresentado nas últimas semanas finalizamos o ciclo de Orientação a Objeto.
O próximo tema que abordaremos será Desenvolvendo para internet -Parte I

Aguardo vocês e bons estudos!

Deixe uma resposta

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *