bem vindo ao curso c

Bem vindo ao curso C# e Orientação a Objetos da Caelum. Nesse curso, aprenderemos como utilizar conceitos de orientação a objetos junto com uma das linguagens de programação mais poderosas para desenvolver sistemas complexos e de fácil manutenção. Antes de começarmos o curso, configuraremos o ambiente de desenvolvimento. Entre no site http://www.microsoft.com/visualstudio/eng/downloads#d-2010-express, escolha a

opção Visual C# 2010 Express e em seguida no link Install Now. O navegador fará

automaticamente o download do instalador do Visual C# 2010 Express Edition. Na janela inicial, clique no botão next para começar o processo de instalação.

No próximo passo, o instalador nos informa quais são os componentes do Visual C# que serão instalados no computador.

Quando clicarmos no botão next, o instalador começará a fazer o download e a instalação do Visual C#

Agora a instalação está concluída!

O primeiro programa em C# Agora que já instalamos o Visual C#, vamos criar nossa primeira aplicação.

Abra o Visual C# 2010 e aperte Ctrl+Shift+N.

Na janela de novo projeto, escolha a opção Windows Forms Application e dê um nome para

o seu projeto inicial. O Visual Studio criará automaticamente um projeto com uma janela vazia.

Queremos inicialmente colocar um botão no formulário que, quando clicado, abrirá uma caixa de mensagem do Windows.

Para criar o botão, precisamos apenas usar o atalho Ctrl+W, X e arrastar um button para o

formulário.

Agora dê um clique duplo no botão que acabamos de adicionar para programarmos o que deve acontecer quando o botão for clicado. O Visual Studio abrirá o código do formulário. Não se preocupe com todo o código complicado que está escrito nesse arquivo, entenderemos o significado de cada uma dessas linhas mais a frente no curso.

1

2

3

4

5

6

7

8

9

10

11

12

13

14

using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms;

namespace form { public partial class Form1 : Form { public Form1() { InitializeComponent(); }

15

16

17

18

19

20

21

22

23

private void button1_Click(object sender, EventArgs e) { } } }

O trecho de código que nos interessa no momento é:

1

2

3

private void button1_Click(object sender, EventArgs e) { }

Todo código que for colocado dentro das chaves será executado quando o botão for clicado. No clique do botão, queremos executar o comando que mostra uma caixa de mensagens para o usuário.

1 MessageBox.Show(mensagem)

No C#, todo comando deve ser terminado pelo caractere ';'. Portanto, o código para mostrar a caixa de mensagem fica da seguinte forma:

1 MessageBox.Show(mensagem);

Queremos que, ao clicar no botão, a mensagem Hello World seja exibida em uma caixa de

mensagens. Então, utilizaremos o seguinte código:

1

2

3

4

private void button1_Click(object sender, EventArgs e) { MessageBox.Show(Hello World); }

Como a mensagem é somente um texto, o compilador do C# nos força a colocá-la entre aspas duplas. Portanto, o código do clique do botão ficará assim:

1

2

3

4

private void button1_Click(object sender, EventArgs e) { MessageBox.Show("Hello World"); }

O código completo fica da seguinte forma:

1

2

3

using System; using System.Collections.Generic; using System.ComponentModel; using System.Data;

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms;

namespace form { public partial class Form1 : Form { public Form1() { InitializeComponent(); }

private void button1_Click(object sender, EventArgs e) { MessageBox.Show("Hello World"); } } }

Não se preocupe com as linhas de código que não foram explicadas. Entenderemos o que elas

fazem durante o curso.

Aperte F5 para executar o código do formulário. O resultado deve ser algo parecido com a

imagem abaixo:

Na maioria dos programas que escrevemos, não estamos interessados em apenas mostrar uma caixa de mensagens para o usuário. Queremos também armazenar e processar informações. Em um sistema bancário, por exemplo, estaríamos interessados em armazenar o saldo de uma conta e o nome do correntista. Para armazenar esses dados, precisamos pedir para o C# reservar regiões de memória que serão utilizadas para armazenar informações. Essas regiões de memória são conhecidas como variáveis.

As variáveis guardam informações de um tipo específico. Podemos, por exemplo, guardar um número inteiro representando o número da conta, um texto para representar o nome do correntista ou um número real para representar o saldo atual da conta. Para utilizar uma variável, devemos primeiramente declará-la no texto do programa. Na declaração de uma variável, devemos dizer seu tipo (inteiro, texto ou real, por exemplo) e, além disso, qual é o nome que usaremos para referenciá-la no texto do programa. Para declarar uma variável do tipo inteiro que representa o número de uma conta, utilizamos o seguinte código:

1 int numeroDaConta;

Repare no ';' no final da linha. Como a declaração de uma variável é um comando da linguagem C#, precisamos do ';' para terminá-lo. Além do tipo int (para representar inteiros), temos também os tipos double e float (para números reais), string (para textos), entre outros. Depois de declarada, uma variável pode ser utilizada para armazenar valores. Por exemplo, se estivéssemos interessados em guardar o valor 1 na variável "numeroDaConta" que declaramos anteriormente, utilizaríamos o seguinte código:

1 numeroDaConta = 1;

Lê-se "numeroDaConta recebe 1". Quando, no momento da declaração da variável, sabemos qual será seu valor, podemos utilizar a seguinte sintaxe para declarar e atribuir o valor para a variável.

1 double saldo = 100.0;

Operações com variáveis Agora que já sabemos como guardar informações no programa, estamos interessados em executar operações nesses valores. Pode ser interessante para um correntista saber qual será o saldo de sua conta após um saque de 10 reais. Para realizar essa operação, devemos subtrair 10 reais do saldo da conta:

1

2

double saldo = 100.0; double valorAposOSaque = saldo - 10.0;

Podemos ainda guardar o valor do saque em uma variável:

1

2

3

double saldo = 100.0; double valorDoSaque = 10.0; double valorAposSaque = saldo - valorDoSaque;

Depois de realizar o saque, queremos mostrar para o usuário qual é o saldo atual da conta. Para

mostrarmos essa informação, utilizaremos novamente o MessageBox.Show: 1 MessageBox.Show("O saldo da conta após o saque é: " + valorAposSaque);

Tomando decisões no código Voltando para nosso exemplo de aplicação bancária, queremos permitir um saque somente se o valor a ser retirado for menor ou igual ao saldo da conta, ou seja, se o saldo da conta for maior ou igual ao valor do saque, devemos permitir a operação, senão não podemos permitir o saque. Precisamos fazer execução condicional de código.

No C#, podemos executar código condicional utilizando a construção if:

1

2

3

4

if (condicao) { // Esse código será será executado somente se a condição for verdadeira }

No nosso exemplo, queremos executar a lógica de saque apenas se o saldo for maior ou igual ao valor do saque:

1

2

3

4

5

6

double saldo = 100.0; double valorSaque = 10.0; if (saldo >= valorSaque) { // código do saque. }

O código do saque deve diminuir o saldo da conta e mostrar uma mensagem para o usuário indicando que o saque ocorreu com sucesso:

1

2

3

4

5

6

7

double saldo = 100.0; double valorSaque = 10.0; if (saldo >= valorSaque) { saldo = saldo - valorSaque; MessageBox.Show("Saque realizado com sucesso"); }

Repare que, se a conta não tiver saldo suficiente para o saque, o usuário não é avisado. Então estamos na seguinte situação: "Se a conta tiver saldo suficiente, quero fazer o saque, senão, quero mostrar a mensagem Saldo Insuficiente para o usuário". Para fazer isso, podemos usar

o else do C#:

1

2

3

4

5

6

7

if (saldo >= valorSaque) { // código do saque } else { MessageBox.Show("Saldo Insuficiente"); }

8

Mais sobre condições

Repare na expressão que passamos para o if: saldo >= valorSaque. Nele utilizamos o

operador "maior ou igual". Além dele, há outros operadores de comparação que podemos utilizar: maior (>), menor (<), menor ou igual (<=), igual (==) e diferente (!=). E ainda existem mais opções

que podemos passar como condição para o if.

Na aula anterior, vimos que um valor tem um tipo associado em C#: 10 é um int, "mensagem" é

uma string. Da mesma forma, a expressão saldo >= valorSaque também tem um tipo

associado: o tipo bool, que pode assumir os valorestrue (verdadeiro) ou false (falso).

Podemos inclusive guardar um valor desse tipo numa variável:

1 bool podeSacar = (saldo >= valorSaque);

Também podemos realizar algumas operações com valores do tipo bool. Podemos, por

exemplo, verificar se duas condições são verdadeiras ao mesmo tempo usando o

operador && (AND):

1 bool realmentePodeSacar = (saldo >= valorSaque) && (valorSaque > 0);

Assim, podemos construir condições mais complexas para um if. Por exemplo, podemos usar a

variávelrealmentePodeSacar declarada acima no if que verifica se o cliente pode sacar ou

não:

1

2

3

4

5

6

7

8

if (realmentePodeSacar) { // código do saque } else { MessageBox.Show("Saldo Insuficiente"); }

Repetindo um bloco de código De volta ao exemplo da aula anterior, suponha agora que o cliente desse mesmo banco queira saber quanto ele ganhará, ao final de 1 ano, caso ele invista um valor fixo todo mês. O investimento paga 1% do valor investido ao mês. Por exemplo, se o cliente investir R$ 1000,00, ao final de 12 meses, terá por volta de R$ 1126,82: no primeiro mês, R$ 1000,00 + R$1000,00 * 1% = R$ 1010,00; no segundo mês, R$ 1010,00 + R$1010,00 * 1% = R$ 1020,10; e assim por diante. Ou seja, para calcular o quanto ele terá ao final de um ano, podemos multiplicar o valor investido 12 vezes por 1%. Para resolvermos esse problema, precisamos fazer uso de uma estrutura de controle que repete

um determinado bloco de código até que uma condição seja satisfeita. Essa estrutura recebe o nome de loop.

Para fazer um loop no c#, utilizaremos, inicialmente, a instrução for. O for é uma instrução que

possui três partes: - A primeira parte é a inicialização, onde podemos declarar e inicializar uma variável que será utilizada no for; - A segunda parte é a condição do loop. Enquanto a condição do loop for verdadeira, o loop continuará executando; - A terceira parte é a atualização, onde podemos atualizar as variáveis que são utilizadas pelo for

Cada uma das partes do for é separada por um ;

1

2

3

4

for (inicialização; condição; atualização) { // Esse código será executado enquanto a condição for verdadeira }

Veja o código abaixo, por exemplo, onde usamos um for que repetirá o cálculo 12 vezes:

1

2

3

4

5

6

double valorInvestido = 1000.0; for (int i = 1; i <= 12; i += 1) { valorInvestido = valorInvestido * 1.01; } MessageBox.Show("Valor investido agora é " + valorInvestido);

Veja que nosso for começa inicializando a variável i com 1 e repete o código de dentro dele

enquanto o valor de i for menor ou igual a 12, ou seja, ele só para no momento em que i for

maior do que 12. E veja que, a cada iteração desse loop, o valor de i cresce (i += 1). No fim, o

código de dentro do for será repetido 12 vezes, como precisávamos.

O mesmo programa poderia ser escrito utilizando-se um while, em vez de um for:

1

2

3

4

5

6

7

8

double valorInvestido = 1000.0; int i = 1; while (i <= 12) { valorInvestido = valorInvestido * 1.01; i += 1; } MessageBox.Show("Valor investido agora é " + valorInvestido);

Neste momento, queremos representar diversas contas em nosso banco. Uma conta bancária é geralmente composta por um número, nome do titular e saldo. Podemos guardar essas informações em variáveis:

1

2

3

int numeroDaConta1 = 1; string titularDaConta1 = "Joaquim José"; double saldoDaConta1 = 1500.0;

Para representar outros correntistas, precisamos de novas variáveis:

1

2

3

int numeroDaConta2 = 2; string titularDaConta2 = "Silva Xavier"; double saldoDaConta2 = 2500.0;

Sempre que formos criar um novo correntista, precisamos lembrar de criar essas 3 variáveis. Então, por que não criamos um "modelo" para isso? Ou seja, dizemos apenas ao nosso programa que queremos criar uma "Conta" e ele se encarrega de criar essas 3 variáveis automaticamente? Para fazer isso, criaremos o que é conhecido por classe. Uma classe representa uma entidade, um conceito de domínio da nossa aplicação. Vamos representar uma Conta (em um arquivo Conta.cs). Ela tem número, nome do titular e saldo:

1

2

3

4

5

6

class Conta { public int numero; public string titular; public double saldo; }

Repare na sintaxe. Para cada atributo, definimos seu tipo e seu nome. Também precisamos colocar a palavra public na frente de cada atributo para que possamos acessá-lo de fora dessa classe.

Podemos agora criar infinitas Contas, e todas elas terão número, titular e saldo. Vamos

experimentar.

Para criar uma nova Conta, basta usarmos a palavra new e guardarmos o resultado em uma

variável:

1 Conta umaConta = new Conta();

Com essa instância de Conta em mãos (umaConta), podemos modificar os valores dos

atributos:

1

2

3

4

Conta umaConta = new Conta(); umaConta.numero = 1; umaConta.titular = "Joaquim José"; umaConta.saldo = 1500.0;

Se quisermos outra conta, basta repetir o procedimento:

1

2

3

4

Conta outraConta = new Conta(); outraConta.numero = 2; outraConta.titular = "Silva Xavier"; outraConta.saldo = 2500.0;

Muito mais prático! Resumindo, uma classe nos ajuda a centralizar todas as informações de

nossas entidades, facilitando a reutilização dela!

Veja como ficou a memória: temos dois objetos (ou instâncias) e duas referências

(umaConta e outraConta) que apontam para esses objetos. Repare que umaConta não é um

objeto, mas sim uma referência (uma seta) para o objeto! O objeto é o que está na memória.

Agora vamos analisar um outro exemplo: a transferência de dinheiro entre duas contas, isto é, pegar o dinheiro de uma instância e passar para a outra.

1

2

3

4

5

6

7

8

9

10

// criando duas contas Conta mauricio = new Conta(); Conta guilherme = new Conta(); mauricio.saldo = 1000.0; guilherme.saldo = 2000.0; // transferindo dinheiro entre elas double valorASerTransferido = 100.0; mauricio.saldo -= valorASerTransferido; guilherme.saldo += valorASerTransferido;

Veja que a implementação de uma transferência é bem simples! Agora, sempre que precisarmos transferir dinheiro em nosso sistema, basta colocarmos essas 3 linhas de código. Mas será que isso pode virar um problema? Sempre que precisarmos fazer uma transferência, são apenas 3 linhas de código! O problema aparece quando precisamos dar manutenção nesse código. Imagine que a regra de negócio mude e toda transferência passe a custar R$0,10. Ou seja, em uma transferência de R$ 10,00, a conta origem perderá R$ 10,10. Imagine em quantos pontos diferentes precisaremos mudar isso. Será que saberemos todos esses pontos? Será que os encontraremos de maneira fácil? Um bom design orientado a objetos é aquele que facilita as alterações, a sua manutenção. Uma solução para isso é colocar esse comportamento em algum lugar que seja fácil de ser

encontrado e de ser reutilizado. Um bom lugar para ele é dentro da própria classe Conta. Uma classe pode conter, além de atributos, métodos que manipulam esses atributos. Vamos começar por um comportamento mais simples: um saque. Em uma operação de saque,

devemos receber o valor a ser sacado. Veja o método Saca, dentro da classe Conta. Ele recebe

um parâmetro do tipo double:

1

2

3

4

5

6

7

8

9

10

class Conta { public int numero; public string titular; public double saldo;

public void Saca(double valorASerSacado) {

} }

O método Saca() deve tirar o valor recebido do saldo da conta:

1

2

3

public void Saca(double valorASerSacado) { this.saldo -= valorASerSacado; }

Repare o uso do this. Estamos dizendo que saldo é um atributo da classe. Observe também o

uso do public para que possamos chamar esse método em outros trechos de código. Vamos fazer uso desse nosso novo comportamento:

1

2

3

4

Conta mauricio = new Conta(); mauricio.saldo = 1000.0; mauricio.Saca(150.0); MessageBox.Show(mauricio.saldo); // imprimirá 850.0!

A instrução mauricio.Saca() invoca o método Saca() para a instância mauricio, ou seja, o

saque acontecerá nessa conta! Podemos sacar de outras contas também, de maneira análoga:

1 2

3

4

Conta guilherme = new Conta(); guilherme.saldo = 500.0; guilherme.Saca(100.0); MessageBox.Show(guilherme.saldo); // imprimirá 400.0!

Vamos ao próximo comportamento: depósito. Análogo ao método Saca(), devemos receber o

valor a ser depositado e somar esse valor no saldo da conta:

1

2

3

public void Deposita(double valorASerDepositado) { this.saldo += valorASerDepositado; }

O próximo comportamento é mais interessante. Vamos modelar uma operação de transferência. Para transferir, precisamos ter 2 contas em mãos: a conta de origem e a conta de destino. Uma primeira alternativa seria criar um método então que recebe 3 parâmetros: o valor a ser transferido, a conta origem e a conta destino:

1

2

3

public void Transfere(double valor, Conta origem, Conta destino) {

}

Mas, se fossemos utilizar esse método, faríamos algo como:

1

2

3

4

Conta mauricio = new Conta(); Conta guilherme = new Conta(); mauricio.Transfere(100, mauricio, guilherme);

Veja que repetimos a variável "mauricio" duas vezes. Como nossos métodos são sempre

disparados a partir de instâncias de objetos (mauricio.Transfere(..), por exemplo), não

precisamos da origem: a origem é o próprio objeto!

1

2

3

4

public void Transfere(double valor, Conta destino) { this.saldo -= valor; destino.saldo += valor; }

Veja o código acima: tiramos do saldo desse (this) objeto e repassamos para o outro. Para

experimentá-lo, podemos fazer:

1

2

3

4

Conta mauricio = new Conta(); Conta guilherme = new Conta();

mauricio.Transfere(100, guilherme);

Podemos melhorar ainda mais esse código. Veja que acabamos de escrever um trecho de código

repetido, pois a linhathis.saldo -= valor; é exatamente o método Saca(). Vamos

reutilizar esses métodos:

1

2

3

4

public void Transfere(double valor, Conta destino) { this.Saca(valor); destino.Deposita(valor); }

Veja que agora estamos produzindo código orientado a objetos. Dados e comportamentos devem

viver perto. Se um dia a regra de negócio de transferência mudar, mudaremos apenas dentro do

método Transfere(), e essa mudança será automaticamente propagada para todas as

transferências.

Quando abrimos uma conta no banco, temos que fornecer uma série de informações: nome, cpf, rg e

endereço.

Vimos que quando queremos armazenar informações em uma classe, devemos criar atributos. Mas em qual

classe colocar esses novos atributos? Claramente essas informações não pertencem a uma conta. Esses dados

pertencem ao titular da conta, ou seja, essas informações pertencem ao cliente do banco.

Então devemos armazená-las em uma classe Cliente.

1

2

3

4

5

6

7

class Cliente { public string nome; public string cpf; public string rg; public string endereco; }

Sabemos também que toda conta está associada a um cliente, ou seja, a conta guarda uma referência ao

cliente associado.

1

2

3

4

5

class Conta { // outros atributos da Conta

public Cliente cliente;

6

7

8

// comportamentos da conta }

Agora, quando vamos criar uma conta, podemos também colocar um cliente.

1

2

3

4

5

Cliente victor = new Cliente(); victor.nome = "victor";

Conta umaConta = new Conta(); umaConta.cliente = victor;

Vimos também que a variável cliente guarda uma referência(seta) para uma instância de Cliente(objeto na

memória). Logo, a atribuição umaConta.cliente = victor está copiando a referência da variável victor para o atributo cliente.

Podemos modificar os atributos do cliente através da referência guardada no atributo cliente da Conta.

1

2

3

4

5

6

7

8

9

Cliente victor = new Cliente(); victor.nome = "victor"; Conta umaConta = new Conta(); umaConta.cliente = victor;

umaConta.cliente.rg = "12345678-9"; MessageBox.show(umaConta.cliente.nome);

Até o momento, nós temos duas classes que representam o nosso sistema: Conta e Cliente.

1

2

3

4

5

6

class Conta { public int numero; public double saldo; public Cliente cliente; }

1

2

3

4

5

6

7

class Cliente { public string nome; public string cpf; public string rg; public string endereco; }

Com base nessas duas classes, vamos por a mão na massa novamente. Lembre-se de escrever o código mais bonito que conseguir e de testar o seu programa antes de enviar!