Você está na página 1de 12

S2B – Student to Business

Laboratório – Orientação a Objeto com C#


Índice

PARTE I – Estruturado 3
Introdução 3

Criação da Interface 3

Programando 4

PARTE II – Orientação a Objeto 5


Introdução 5

Criação da Classe 5

PARTE III – Herança 7


Introdução 7

Criação da Interface 7

Criação da Classe 7

PARTE IV – Tratando Exceções 10


Introdução 10

Entendendo a modificação 10

2
PARTE I – Estruturado

Introdução
Este laboratório tem como objetivo construir um simples sistema de
gerenciamento de porta, de forma estruturada, que será convertido para
POO posteriormente.

Criação da Interface
Para criar a interface deste exercício, primeiramente adicione as seguintes
imagens ao projeto:

Fig 1 – Imagens disponibilizadas

É possível adicionar alguns arquivos externos ao projeto para facilitar o seu uso.
São os Resources. Para adicionar um, dê um duplo clique em “Properties” no
Solution Explorer. Depois que aparecerem as propriedades do seu projeto,
clique na aba Resources, à esquerda e adicione as imagens (Fig 2):

Fig 2 – Add Resource

Agora as imagens fazem parte do seu projeto. Para acessá-las, basta acessar
o namespace GerenciamentoDePortas.Properties.Resources e todos os
resources que você acabou de adicionar estarão lá em forma de imagem.
Para facilitar o acesso, importe o namespace
GerenciamentoDePortas.Properties, assim o acesso ficará mais fácil.

Com as imagens inseridas, vamos à interface. O projeto consiste em um


gerenciador de porta, onde é possível abrir, fechar, trancar e destrancar uma
porta. Para isso usaremos as imagens que foram adicionadas anteriormente. A
interface deve ser parecida com a Fig 3:

3
Fig 3 – Interface do projeto

O único controle que precisa de explicação é o seguinte:

1. picPorta – PictureBox

a. Image: GerenciamentoDePortas.Properties.Resources.opened

b. SizeMode: StretchImage

Programando
Para gerenciar o estado da porta, crie duas variáveis: “aberta” e “trancada”
do tipo Bool. A porta deverá iniciar aberta e destrancada. Ou seja, no evento
Load do formulário, sete a variável “aberta” como True e a “trancada” como
False.

Agora crie 4 funções: Abrir(), Fechar(), Trancar() e Destrancar(). A única coisa


que cada botão vai fazer é chamar a função correspondente o botão
btnAbrir vai chamar a função Abrir(), e assim por diante).

Cada função deverá fazer uma verificação se é possível fazer o procedimento


desejado. Se for, alterar o estado da variável em questão e alterar a imagem
do picPorta. Por exemplo: se a porta já estiver aberta, não é possível abri-la
novamente. Só é possível abrir a porta se ela estiver fechada e destrancada.
Então o código da função Abrir() ficará assim:

public void Abrir()


{
if (!aberta && !trancada)
{
aberta = true;
picPorta.Image = Resources.opened;
}

4
}

Seguindo essa lógica, implemente as funções Fechar(), Trancar() e


Destrancar().

PARTE II – Orientação a Objeto

Introdução
Este laboratório pretende melhorar o exercício da porta começado
anteriormente, convertendo-o de uma forma simples para OO. A interface
será a mesma.

Criação da Classe
Essa versão do sistema terá apenas uma classe: Porta. A classe Porta será
responsável por gerenciar a porta, contendo as variáveis “aberta” e
“trancada” dentro dela, expondo somente os métodos Abrir(), Fechar(),
Trancar() e Destrancar().

A classe deve possuir os seguintes métodos e campos (Fig 4):

Fig 4 – Classe Porta

A diferença dessa classe para o exercício anterior é que dentro dela, há um


controle PictureBox, que é passado no construtor. Ou seja, quando for
instanciar um objeto da classe Porta, é necessário passar um PictureBox por

5
referência. No construtor da classe Porta, é necessário instanciar o objeto
_controleImagem com esse controle passado por referência.

Com a classe pronta, é só ir ao formulário e implementar dessa forma:

public partial class Form1 : Form


{
Porta porta; (1)
public Form1()
{
InitializeComponent();
porta = new Porta(this.picPorta); (2)
}

private void btnAbrir_Click(object sender, EventArgs e)


{
porta.Abrir(); (3)
}

//E assim por diante...


}

Nota (1) – Aqui você está criando um objeto da classe Porta. Você está
CRIANDO, mas NÃO está INSTANCIANDO.

Nota (2) – Agora sim você está INSTANCIANDO o objeto criado. Como a
classe Porta exige obrigatoriamente um objeto do tipo PictureBox, você deve
passar a PictureBox que está utilizando para mostrar as imagens.

Nota (3) – No evento Click de cada botão, apenas chame o método


correspondente ao que o botão faz.

6
PARTE III – Herança

Introdução
Este laboratório pretende melhorar o exercício da porta começado
anteriormente, colocando em prática os conhecimentos de herança. Será
feito o gerenciamento de uma porta e de uma porta de cofre ao mesmo
tempo. A peculiaridade da porta de cofre é que ela já começa fechada, e
para destrancá-la, é necessária uma senha.

Criação da Interface
A interface é parecida com a do exercício anterior, mas serão criados alguns
outros controles para gerenciar a porta de cofre (Fig 5).

Fig 5 – Interface da Parte III do projeto

Criação da Classe
Como descrito na introdução, agora criaremos uma porta de cofre. No mundo
real, uma porta de cofre tem todas as características de uma porta comum. A
única diferença é que para destrancá-la, é necessário ter a mesma senha que
foi inserida na tranca quando o cofre foi criado. Então a melhor forma de criar
uma classe PortaDeCofre seria herdando da classe Porta.

Então crie uma nova classe chamada PortaDeCofre e aplique a herança de


Porta:

7
Fig 6 – Diagrama de Classe

Ao aplicar a herança, provavelmente aparecerá uma mensagem de erro.


Essa mensagem acontece pelo seguinte motivo:

A classe Porta tem somente um construtor no qual é obrigado passar um


objeto do tipo PictureBox. Quando PortaDeCofre aplica a herança de
Porta, você ainda não definiu nenhum construtor para PortaDeCofre. E
como todas as classes filhas devem ter construtores que sejam
compatíveis com algum construtor da classe pai, portanto como o .NET
não encontrou nenhum construtor compatível, ele mostra tal erro.

Para arrumar a classe PortaDeCofre, crie um construtor que receba como


parâmetro um objeto do tipo PictureBox (assim como na classe Porta) e um
outro parâmetro do tipo string para poder definir a senha do cofre (como já
explicado acima).

Agora com o construtor de PortaDeCofre criado, ainda é necessário


especificar como acessar o construtor da classe Porta. Na linha abaixo da
declaração do construtor, acrescente a chamada ao construtor da classe
base e passe o parâmetro desejado, como mostra o trecho de código abaixo:

public PortaDeCofre(System.Windows.Forms.PictureBox Controle,


string Senha)
: base(Controle)
{
//O resto do código...
}

8
Crie um campo privado para guardar a senha passada no construtor. Como a
porta do cofre já começa fechada e trancada, indique isso também no
construtor. Se não conseguir, altere a visibilidade dos campos “aberta” e
“trancada” na classe Porta para que sejam visíveis em todas as classes filhas.

Sobrescreva o método Destrancar() da classe Porta. Não se esqueça de


alterar o que for necessário na classe Porta para poder sobrescrever tal
método. Crie uma sobrecarga desse método que receba uma string para
verificar se é a senha correta para abrir a porta. O método Destrancar() que
está sobrescrevendo deve apenas chamar o método Destrancar() que recebe
a string. Obtendo o seguinte código:

public override void Destrancar()

this.Destrancar("");

public void Destrancar(string Senha)

/*Verifica se a senha está correta.

* Se estiver, chame o método

* destrancar da classe base.*/

A implementação no formulário será feita da mesma forma que no exercício


anterior. A diferença é que para a porta de cofre deverá ser criado e
instanciado outro objeto da classe PortaDeCofre, mas a implementação
segue a mesma lógica.

9
PARTE IV – Tratando Exceções

Introdução
Este laboratório será a versão final do gerenciador de portas. Ele mostrará
como implementar o tratamento de erros e como criar erros personalizados.

Entendendo a modificação
A evolução desta etapa será criar erros personalizados para melhorar a
interface com o usuário. Parece ser estranho, mas no Visual Studio 2005 é muito
simples e útil.

Exception é uma classe que representa os erros que ocorrem durante a


execução da aplicação. Ao executar uma operação indevida nas classes do
.Net, ele automaticamente dispara uma exception. Por exemplo, se você tem
um vetor de 5 posições e tentar acessar a 10ª posição. Isso irá disparar uma
IndexOutOfRangeException. Essa exceção na verdade é uma classe que
herda a classe Exception.

Você pode fazer uma exceção personalizada também. Para fazê-la, crie uma
nova classe com o nome PortaAbertaException e faça a herança de
Exception. Agora crie um construtor que chame o construtor da classe base,
passando simplesmente a mensagem de erro como parâmetro (algo como “A
porta já está aberta”).

Pronto. A sua exceção personalizada está criada. Para dispará-la faça assim
em alguma outra classe:

throw new PortaAbertaException()

Rode o programa e aparecerá uma mensagem de erro típica do Visual Studio


2005, mas com a mensagem que você passou no construtor da classe base de
PortaAbertaException.

10
Fig 7 – Mensagem de erro

Para tratar o erro, utilize o Try/Catch:

try
{
throw new PortaAbertaException();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}

Aparecerá uma MessageBox com a mensagem do erro que você criou. É


muito simples e elegante utilizar Try/Catch.

Seguindo esta idéia, é possível melhorar a classe Porta. Em cada método, ao


invés de somente verificar se é possível realizar a ação desejada, seria melhor
se na impossibilidade de realizar a ação, fosse disparada uma exceção. Assim
ficaria até mais fácil mostrar para o usuário que a ação não pode ser realizada
e por qual motivo.

Por exemplo, o método Abrir() ficaria assim:

public void Abrir()


{
if (this._aberta)
throw new PortaAbertaException();

11
else if (this._trancada)
throw new PortaTrancadaException();
//O resto do código...
}

O método apenas dispara as exceções necessárias. O “form1” deve se


preocupar em tratar as exceções.

private void btnAbrir_Click(object sender, EventArgs e)


{
try
{
porta.Abrir();
}
catch (Exception ex)
{

MessageBox.Show(ex.Message);
}
}
Agora é possível mostrar ao usuário quando a ação desejada não ocorreu e o
porquê disso. Crie as seguintes classes: (todas elas serão filhas da classe
Exception e serão as exceções personalizadas do sistema)

1. Classe PortaFechadaException

• Exceção disparada ao fechar uma porta fechada.

2. Classe PortaAbertaException

• Exceção disparada ao abrir, trancar ou destrancar uma porta


aberta.

3. Classe PortaTrancadaException

• Exceção disparada ao trancar ou abrir uma porta trancada.

4. Classe PortaDestrancadaException

• Exceção disparada ao destrancar uma porta destrancada.

5. Classe PortaSenhaInvalidaException

• Exceção disparada ao abrir uma porta com senha, informando a


senha errada.

Todas as cinco classes devem possuir um construtor cada, chamando o


construtor de sua classe mãe, com um único parâmetro do tipo string (a
mensagem da qual a exceção trata).

12