Todo o código em POO é colocado dentro de classes. Um bloco de código que define uma classe é semelhante ao seguinte

1
2
3
4

class Class1
{
      // os membros são definidos aqui.
}

A palavra chave “class” define a criação de uma nova classe. Em seguida colocamos o nome a ser dado a essa classe, no caso, Class1.

Para criarmos ou “instanciarmos” objetos de uma determinada classe, utilizamos o operador new.

1

Class1 obj = new Class1();

No código acima, estamos criando um novo objeto da classe Class1 nomeado de “obj”. A partir desta instrução, os membros deste objeto tornam-se disponíveis para uso.

A título de exemplo, vamos criar uma classe simples com alguns membros e utilizá-los para verificar seu funcionamento.

Vamos iniciar escrevendo aplicativos em um editor de texto comum, no caso, o Notepad (Bloco de Notas) do Windows. Para compilar os aplicativos, vamos utilizar o compilador csc.exe (C Sharp Compiler) que acompanha a instalação do .NET Framework. Facilitaremos o acesso ao compilador através do Prompt do Visual Studio. Acione Iniciar->Programas->Microsoft Visual Studio .NET 2003->Visual Studio .NET Tools-> Visual Studio .NET 2003 Command Prompt:

Aponte o prompt para C:\Treinamento com o comando “cd C:\Treinamento”. Crie um arquivo texto com a extensão “.cs” dentro da pasta Treinamento. A extensão “.cs” identifica o arquivo como um “arquivo de código C#” (C# Source File). Para facilitar a criação do arquivo, entre com o comando “notepad exemplo1.cs” no prompt e confirme a criação do arquivo. Entre com o seguinte código:

1
2
3
4
5
6
7
8

class Class1
{
      static void Main()
      {
            // Escreve o texto no Console
            System.Console.WriteLine("Olá mundo!");
      }
}

Como o C# é case sensitive, é preciso tomar atenção às letras maiúsculas e minúsculas pois estas são diferenciadas, exceto textos e strings .Salve e feche o arquivo. Ainda no prompt, digite o comando “csc exemplo1.cs”. Esse comando executa a compilação do arquivo exemplo1.cs usando o compilador csc. Se o código tiver sido digitado corretamente, será impressa a mensagem padrão do compilador e o arquivo executável de nosso aplicativo será criado. Por padrão, o nome do executável é o mesmo do arquivo fonte, portanto, para executar o aplicativo, digite “exemplo1” no prompt:

Veja a saída do aplicativo no Console. Agora que temos as ferramentas, vamos construir nossa primeira classe com alguns membros usando o Notepad. Crie um novo arquivo chamado exemplo2.cs e insira o seguinte código:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

// cria um alias para facilitar o acesso aos membros do System
using System;
 
// Cria a nossa classe de exemplo
class MinhaClasse
{
int n1 = 2, n2 = 4;
 
      // Função para somar e retonar os valores declarados anteriormente
      public int soma()
      {
            return n1 + n2;
      }
}
 
// classe para execução do aplicativo
class Class1
{
      static void Main()
      {
            // cria uma nova instância da classe MinhaClasse
            MinhaClasse obj = new MinhaClasse();
            // cria uma variável para receber a soma dos valores n1 e n2 da classe
            int result = obj.soma();
            // Coloca o resultado na tela
            Console.WriteLine("{0}", result.ToString());
      }
}

O entendimento do programa acima é intuitivo e simples. Algumas curiosidades são:

• O termo using System;

usado como um atalho para facilitar a referência a membros e funções. No primeiro exemplo usamos a chamada completa à função WriteLine como comando “System.Console.WriteLine”. No segundo exemplo, o alias nos permite resumir a chamada a apenas “Console.WriteLine”. Consequentemente, se tivéssemos feito um alias para “using System.Console”, a chamada poderia ser resumida para “WriteLine”.

• A função soma

para termos acesso à função, declaramos com o modificador “public”. Por padrão, os membros declarados sem modificadores são “private”. A função soma é do tipo “int” e a instrução “return” devolve o valor para a função chamadora, no nosso caso, a instrução “int result = obj.soma()”.

Compile o arquivo com a instrução “csc exemplo2.cs”, execute e veja a saída na console:

Vamos agora testar o acesso às variáveis n1 e n2. Modifique o método Main para o seguinte:

1
2
3
4
5
6
7
8
9
10
11

...
static void Main()
      {
            // cria uma nova instância da classe MinhaClasse
            MinhaClasse obj = new MinhaClasse();
            // declara as variáveis para receber os valores de n1 e n2
            int N1 = obj.n1, N2 = obj.n2;
            // Coloca os valores na tela
            Console.WriteLine("N1 = {0} e N2 = {1}", N1.ToString(), N2.ToString());
      }
...

Compile o código e veja o resultado:

Corretamente o compilador acusa erro de nível de acesso à variável da classe MinhaClasse, pois como elas não possuem modificadores, são “private” por padrão. Para que o aplicativo compile sem problemas, bastaria alterar as declarações das variáveis n1 e n2 para public conforme a seguir:

1
2
3
4
5
6

...
class MinhaClasse
{
      public int n1 = 2, n2 = 4;
}
...

Compile novamente e veja o resultado:

Tornar os campos públicos não é a maneira mais aconselhável de obter acesso direto aos campos de uma classe, apesar de prática. O motivo é garantir o funcionamento de uma classe que dependa do valor de um campo e que porventura você precise acessá-lo até para saber seu valor. Isso nos relembra o conceito de “Encapsulamento” onde tínhamos que garantir o correto funcionamento da classe. As linguagens do .NET fornecem o uso de propriedades para contornar essa situação. Abordaremos o conceito de propriedades no decorrer do curso.