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.");
    }
}

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.

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);

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

O básico do C#

Em uma série de posts irei cobrir os aspectos básicos do C sharp com exemplos simples e diretos:

• Tipos primitivos e operadores
• Uso do console
• Estruturas de controle
• Iterações
• Data usando DateTime
• Classes:
• Classes: encapsulamento
• Classes: herança
• Classes abstratas
• Classes seladas
• Classes: interfaces

Iterações - C#

Iterações em C# usando: while, do-while, for, for-each.

while

Console.Write("Escreva seu nome: ");
string nome = Console.ReadLine();
while (nome != "fim")
{
    Console.WriteLine("Seu nome eh {0}", nome);
    Console.Write("Escreva seu nome ou 'fim' para sair: ", nome);
    nome = Console.ReadLine();
}

do while

int soma = 0;
do
{
    Console.Write("Digite um numero inteiro ou 'fim' para sair: ");
    string s = Console.ReadLine();
    if (s == "fim")
    {
        break;
    }
    soma = soma + int.Parse(s);
    Console.WriteLine("A soma atual eh {0}", soma);
} while (true);

for

for (int i = 0; i < 10; i++)
{
    Console.WriteLine("i vale {0}", i);
}

for each

string[] nomes = {"lucas", "gisele", "terezinha"};
Console.WriteLine("Lista de nomes:");
foreach (string nome in nomes)
{
    Console.WriteLine(nome);
}

Estruturas de controle - C#

if

Console.Write("Escreva seu nome: ");
string nome = Console.ReadLine();
if (nome == "lucas")
{
    Console.WriteLine("Seu nome eh lucas");
}
else
{
    Console.WriteLine("Seu nome nao eh lucas");
}

switch

switch (nome)
{
    case "lucas":
        Console.WriteLine("Seu nome eh lucas");
        break;
    case "joao":
        Console.WriteLine("Seu nome eh joao");
        break;
    default:
        Console.WriteLine("Seu nome nao eh lucas nem joao");
        break;
}

O switch aceita os seguintes tipos de variáveis:

• sbyte
• byte
• short
• ushort
• int
• uint
• long
• ulong
• char
• string
• enumerations

Console - C#

// Escrevendo no console
Console.Write("Escreva seu nome: ");

// Lendo entrada do usuário
string nome = Console.ReadLine();

// Escrevendo novamente
Console.WriteLine("Seu nome eh: {0}", nome);

Tipos Primitivos e Operadores - C#

Tipos Primitivos

// integer
int intVar = 10;

// float
float floatVar = 0.50F;

// long
long longVar = 14L;

// double
double doubleVar = 3.14;

// decimal
decimal decimalVar = 0.15M;

// string
string stringVar = "texto";

// char
char charVar = 'a';

// boolean
bool boolVar = true;

Operadores

int num_1 = 20;
int num_2 = 10;

// Soma
int soma = num_1 + num_2;

// Subtracao
int sub = num_1 - num_2;

// Multiplicacao
int mult = num_1 * num_2;

// Divisao
int div = num_1 / num_2;

// Resto da divisao
int rest = num_1 % num_2;