Juiz de Código

sábado, 12 de setembro de 2015

Classes: interfaces - C#

Interfaces são como classes mas sem a implementação de métodos, eventos, properties e indexers.

Interfaces não possuem campos, constantes, operadores e construtores.

Interfaces permitem dois tipos de modificadores de acesso: public e internal (padrão, caso não defina nenhum).

Uma convenção comum é nomear interfaces começando com a letra I.

Observe o exemplo da classe Automóvel:

public interface IAutomovel
{
   // Definindo duas properties
   string Modelo { get; }
   DateTime AnoDeFabricacao { get; set; }

   // Definindo um método
   void Ligar();
}

Uma classe pode implementar a interface acima como no exemplo a seguir:

public class Carro: IAutomovel
{
    // Implementação da primeira propertie
    private string _modelo;
    public string Modelo
    {
        get
        {
            return this._modelo;
        }
    }

    // Implementação da segunda propertie
    public DateTime AnoDeFabricacao { get; set; }

    // Implementação do método Ligar
    public void Ligar()
    {
        Console.WriteLine("Ligando o carro.");
    }
}

Classes seladas - C#

Classes seladas (palavra chave sealed) impedem que outras classes herdem da mesma.

class A {}    
sealed class B : A {}

No exemplo acima B herda de A, mas como B é selada nenhuma classe pode herdar de B.

Classes abstratas - C#

Classes abstratas não podem ser instanciadas.

Podem conter métodos virtuais (palavra chave virtual), que são métodos que possuem implementação mas que podem ser sobrecarregados pelas classes derivadas.

Podem conter também métodos abstratos (palavra chave abstract), que não possuem implementação e que devem ser implementados pelas classes derivadas.

Observe o exemplo da classe Automóvel:

abstract class Automovel
{
   private string modelo;
   private DateTime ano;

   ...

   public virtual void Ligar()
   {   
      // Implementação do método virtual
      ...
   }


   // Método abstrato, não possui implementação,
   // chaves e é terminado com ponto e vírgula
   public abstract void Mover();

}

Podemos criar um exemplo que herde de Automóvel contendo o mínimo necessário (o método abstrato):

public class Moto : Automovel
{
    public override void Mover()
    {
        Console.WriteLine("Movendo a moto.");
    }
}

sexta-feira, 11 de setembro de 2015

Herança - C#

Para representar herança em C# usamos os dois pontos na frente do nome da classe seguido da superclasse. No exemplo a seguir Carro herda de Automóvel:

class Carro : Automovel
{
    private int numero_de_portas;
}

C# não dá suporte direto a herança múltipla.

quinta-feira, 10 de setembro de 2015

Classes: encapsulamento - C#

O encapsulamento em C# é feito através de modificadores de acesso e properties.

Modificadores de Acesso

Modificador de Acesso	Descrição
public	Permite o acesso de qualquer código sendo executado em qualquer assembly.
internal	Permite o acesso de qualquer código no mesmo assembly.
private	Permite acesso somento dentro da classe. Esse é o modificador padrão caso você não especifique nenhum.
protected	Permite acesso dentro da classe e de classes derivadas.

O mais comum é criar campos de dados privados na classe para evitar a manipulação direta dos valores, e expor properties para prover acesso aos campos de forma indireta.

Properties

Properties são usadas para atribuir (setters) e retornar (getters) membros de uma classe. Observe o exemplo da classe Carro:

    public class Carro
    {

        // campos privados  
        private string campo_placa;
        private string campo_modelo;


        // properties públicas
        public string Placa
        {
            get
            {
                return campo_placa;
            }
            set
            {
                // Obersve o uso da keyword 'value' que representa
                // o valor a ser atribuído.
                // Aqui é possível adicionar lógica de validação.
                campo_placa = value;
            }
        }

        public string Modelo
        {
            get
            {
                return campo_modelo;
            }
            set
            {
                campo_modelo = value;
            }
        }

        // usando properties automaticas  
        public DateTime AnoDeFabricacao { get; set; }


        // Um construtor
        public Carro(string placa)
        {

            this.campo_placa = placa;

        }
    }

Foram criadas as properties Placa e Modelo que acessam os campos privados campo_placa e campo_modelo. Foi criado também uma propertie chamada AnoDeFabricacao que gera automaticamente o campo privado, o getter e o setter.

Um exemplo simples do uso da classe:

 // Criando um novo carro usando o construtor
Carro uno = new Carro("HGW 1122");

// Atribuindo alguns valores aos membros
uno.AnoDeFabricacao = new DateTime(2010,01,01);
uno.Modelo = "Fire";

// Acessando
Console.WriteLine("Placa: {0}", uno.Placa);

quarta-feira, 2 de setembro de 2015

Data usando DateTime - C#

Criando

Podemos criar uma data usando um dos construtores da classe:

// Criando a data 31/12/2015 18:30:00
DateTime data = new DateTime(2015, 12, 31, 18, 30, 0);

Esse construtor aceita os parâmetros na seguinte ordem:

Ano, Mês, Dia, Hora, Minuto, Segundo

Podemos também usar o construtor que possui somente a data:

// Criando a data 31/12/2015
DateTime data = new DateTime(2015, 12, 31);

Atribuindo

Existem várias maneiras de atribuir uma data a partir de outros tipos. A mais comum é a partir de uma string. Para isso usamos o método parse:

DateTime data = DateTime.Parse("01/01/1990");

Acessando

Podemos obter os dados de uma DateTime acessando diretamente cada campo:

DateTime data = new DateTime(2015, 12, 31);
Console.WriteLine(data.Year);
Console.WriteLine(data.Month);
Console.WriteLine(data.Day);
Console.WriteLine(data.Hour);
Console.WriteLine(data.Minute);
Console.WriteLine(data.Second);

Ou usando um formato:

Console.WriteLine(data.ToString("dd 'de' MMMM 'de' yyyy")); 
// 31 de dezembro de 2015

Console.WriteLine(data.ToString("dd/MM/yyyy")); 
// 31/12/2015

Console.WriteLine(data.ToString("dd/MM/yy")); 
// 31/12/15