Programação Orientada a Objetos II

Unidade II
Iniciaremos os nossos estudos apresentando técnicas de programação aplicando‑se a plataforma
desktop. Iremos aprender como segregar a estrutura de código C# para que possamos garantir qualidade
de desenvolvimento e performance de manutenção.

Entendendo as aplicações, torna‑se fácil entender os passos necessários para dar suporte a
aplicações e identificar as diversas maneiras pelas quais essas aplicações Windows Form são fornecidas
ou implementadas.

3 Linguagem de Programação C#

A linguagem de programação C# foi criada para que desenvolvedores pudessem atuar de maneira
mais ágil com aplicações web. Dentre os pontos da linguagem, podemos destacar os seguintes:

• Linguagem de programação orientada a objetos ideal para desenvolvimento de aplicações web.

• É considerada uma evolução do C++, do qual são utilizadas algumas características, como
declarações, expressões e operadores.

• Utiliza muitas regras de programação para reduzir a possibilidade de erros.

• C# também tem como objetivo permitir o desenvolvimento de qualquer tipo de aplicação: web
service, aplicação Windows convencional, aplicações para serem executadas num palmtop ou
handheld, aplicações para internet etc.

3.1 Histórico e curiosidades

• Criada pela Microsoft especificamente para a plataforma .NET.

• Iniciada em 1999 por Anders Hejlsberg e equipe, com nome de Cool.

• .NET é apresentada em 2000 e linguagem Cool é renomeada para C#.

• O símbolo real seria o ♯, e não o #. Porém, devido a limitação de telas, fontes, teclados e alguns
navegadores, no momento da normalização junto à ECMA, foi feita a opção pelo #.

• Foi criada com base nas linguagens C++ e Java.

• Tem como um dos principais editores o Visual Studio.

23
 Unidade II

Saiba mais

Para saber mais a respeito do tema, sugerimos a leitura do seguinte artigo:

ARAÚJO, E. C. Introdução à linguagem C#. DevMedia, Rio

de Janeiro, [s.d.]. Disponível em: <http://www.devmedia.com.br/
introducao‑a‑linguagem‑c/27711>. Acesso em: 9 jun. 2015.

3.2 Microsoft Visual Studio

O Microsoft Visual Studio é um pacote de programas da Microsoft para desenvolvimento,

dedicado ao framework .NET e às linguagens Visual Basic (VB), C, C++, C# e J#. Trata também de
desenvolvimento web na plataforma do ASP.NET, tendo como linguagens mais frequentes VB.NET
(Visual Basic .Net) e C#.

3.3 Herança

Trata-se da característica mais poderosa e importante da orientação a objetos, pois permite o

reaproveitamento de atributos e de métodos, otimizando o tempo de desenvolvimento. Com isso,
podemos reduzir significativamente a linha de código.

O conceito de herança trabalha com o conceito de superclasse e subclasse. A superclasse é uma

classe que possui classes derivadas a partir dela, chamadas de subclasses. Estas, ao serem derivadas de
uma superclasse, herdam seus atributos e métodos.

Figura 9 – Diagrama de Classe

24
Programação Orientada a Objetos II

A seguir podemos observar alguns exemplos que contextualizam a explicação de herança:

Exemplo 1

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{

Console.WriteLine (“ Instancia da Classe Pessoa, {0}!”, Console.

ReadLine());
__________.__________ pessoa = new Heranca.______________();
pessoa._______ = “professor unip”;
______.idade = 40;

Console.WriteLine (“Pessoa: Nome={0},Idade={1}”, __________.nome,

pessoa.__________);
Console.WriteLine();
Console.WriteLine();

Console.WriteLine(“ Instancia da Classe Aluno, {0}!”, Console.Read‑

Line());
Heranca.___________ __________ = new Heranca.Aluno();
_____________.nome = “Joaquim”;
_____________.idade = 30;
aluno.___________________ = “AX3601223‑1”;

Console.WriteLine(“Aluno: Nome={0},Idade={1}, Matricula={2}”, alu‑

no._____, ____._____, _____._____);
Console.WriteLine();
Console.WriteLine(“ Fim, {0}!”, Console.ReadLine());
}
}
}
namespace Heranca
{
public class _____________
{
//atributos
public string __________;
public int _____________;

//construtor
public _____________()
{
Console.WriteLine(“Construção do objeto Pessoa.”);
}
}

25
 Unidade II

public class _____________ : _____________

{
//atributo
public String __________________;

//construtor
public Aluno()
{
Console.WriteLine(“Construção do objeto Aluno.”);
}
}
}

Exemplo 2

using System;

namespace ConsoleApplication2
{
class Program
{
static void Main(string[] args)
{

//Início-com base na herança

Console.WriteLine(“ Instancia da Classe Pessoa, {0}!”, Console.Read‑
Line());
____________.___________ _________ = new ___________.______(“Joa‑
quim”);
Console.WriteLine (“Pessoa: Nome {0}”,_________.__________);
Console.WriteLine();

Console.WriteLine(“ Instancia da Classe Aluno com base na herança,

{0}!”, Console.ReadLine());
__________.________ aluno = new HerancaBase.__________(“090909-x”,
“Silva”);
Console.WriteLine(“Aluno com nome {0} e matrícula {1}», aluno.nome,
aluno.matricula);

//Fim-com base na herança

Console.WriteLine(“ Fim, {0}!”, Console.ReadLine());

}
}
}

namespace HerancaBase
{
public class __________
{
//atributos
public string _________;

26
Programação Orientada a Objetos II

public int ____________;

//construtor
public __________()
{
//nada
}

public Pessoa(string n)
{
this.nome = n;
Console.WriteLine(“Construção do objeto Pessoa com parâmetro.”);
}

public class _________ : ___________

{
//atributo
public String ____________;

//construtor com base na herança

public Aluno(string m, string n)
: base(n)
{
this.matricula = m;
Console.WriteLine(“Construção do objeto Aluno com base na herança.”);
}
}
}

3.4 Polimorfismo

O conceito está associado à herança e trabalha com a redeclaração de métodos previamente herdados
por uma classe. O ponto principal é evitar ter de modificar o código-fonte; inserindo uma chamada
em um método com um nome diferente, redeclara‑se o método com o mesmo nome declarado na
superclasse.

A seguir podemos observar alguns exemplos que contextualizam a explicação de polimorfismo:

Exemplo 1

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConsoleApplication3
{
class ProgramP
{
static void Main(string[] args)
{

27
 Unidade II

Console.WriteLine(“ Instancia da Classe Familia, {0}!”, Console.

ReadLine());
_________._________ familia = new _____________.__________();
familia.pais();
Console.WriteLine(“ Instancia da Classe Continente, {0}!”, Console.
ReadLine());
______________.Continente ____________ = new Polimorfismo.
_______________();
continente.________();
Console.WriteLine(“ Instancia da Classe Hemisferio, {0}!”, Console.
ReadLine());
Polimorfismo.Hemisferio ______________ = new Polimorfismo.Hemisferio();
____________.pais();
Console.ReadLine();
}
}
}
namespace Polimorfismo
{
public class ______________
{
public virtual void ___________()
{
Console.WriteLine(“ Método ‘pais’ do objeto ‘Familia’ “);
}
}
//utilizando o método com o mesmo nome em classes diferentes
class ____________ : Familia
{
public override void ________()
{
Console.WriteLine(“ Método ‘pais’ do objeto ‘Continente’ “);
}
}
//utilizando o método com o mesmo nome em classes diferentes
class Hemisferio : _____________
{
public override void _________()
{
Console.WriteLine(“ Método ‘pais’ do objeto ‘Hemisferio’ “);
}
}
}

Figura 10 – Tela Windows Form

28
Programação Orientada a Objetos II

Figura 11 – Tela Windows Form: Label

Figura 12 – Tela Windows Form: CheckBox selecionado

Exemplo 2

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 WindowsFormsApplication1
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
checkBox1.Checked = false;
label1.Text = “”;
}

private void button1_Click(object sender, EventArgs e)

{
Polimo.Movimenta __________ = new Polimo.Movimenta();
if (this.checkBox1.Checked){
_________.carro_em_movimento(new Polimo._______());
label1.Text = “O Carro está acelerando.”;
}
else

29
 Unidade II

{
movimenta.carro_em_movimento(new Polimo.________());
label1.Text = “O Carro está freando.”;
}
}
}
}
namespace Polimo
{
//Classe
public abstract class Carro
{
public abstract bool __________();
}
//Classe
public class Acelerar:Carro
{
//Usa o mesmo nome do método da Classe Carro
public ______________ bool _________()
{
Console.WriteLine(“O Carro está acelerando.”);
return true;
}
}

//Classe
public class Frear:Carro
{
//Usa o mesmo nome do método da Classe Carro
public override bool acao()
{
Console.WriteLine(“O Carro está freando.”);
return true;
}
}

//Classe
public class Movimenta
{
public bool carro_em_movimento(_________ car)
{
return car.___________();
}
}
}

Exemplo 3

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConsoleApplication2
{
class Programh

30
Programação Orientada a Objetos II

{
static void Main(string[] args)
{
//Início‑com base na herança
Console.WriteLine(“ Instancia da Classe Pessoa, {0}!”, Console.Read‑
Line());
HerancaBase.Pessoa pessoa = new HerancaBase.Pessoa(“LUIZ”);
Console.WriteLine(“Pessoa: Nome {0}”, pessoa.nome);
Console.WriteLine();
Console.WriteLine(“ Instancia da Classe Aluno com base na herança,
{0}!”, Console.ReadLine());
HerancaBase.Aluno aluno = new HerancaBase.Aluno(“090909‑x”, “Lui‑
gi”);
Console.WriteLine(“Aluno com nome {0} e matícula {1}”, aluno.nome,
aluno.matricula);
//Fim‑com base na herança
Console.WriteLine(“ Fim, {0}!”, Console.ReadLine());
}
}
}
namespace HerancaBase
{
public class Pessoa
{
//atributos
public string nome;
public int idade;
//construtor
public Pessoa()
{
//nada
}
public Pessoa(string n)
{
this.nome = n;
Console.WriteLine(“Construção do objeto Pessoa com parâmetro.”);
}
}
public class Aluno : Pessoa
{
//atributo
public String matricula;
//construtor com base na herança
public Aluno(string m, string n)
: base(n)
{
this.matricula = m;
Console.WriteLine(“Construção do objeto Aluno com base na her‑
ança.”);
}
}
}

31
 Unidade II

Exemplo 4

using System;
namespace ConsoleApplication3
{
class ProgramP
{
static void Main(string[] args)
{
Console.WriteLine (“ Instancia da Classe Familia, {0}!”, Console.
ReadLine());
Polimorfismo.Familia familia = new Polimorfismo.Familia();
familia.pais();
Console.WriteLine(“ Instancia da Classe Continente, {0}!”, Console.
ReadLine());
Polimorfismo.Continente continente = new Polimorfismo.Continente();
continente.pais();
Console.WriteLine(“ Instancia da Classe Hemisferio, {0}!”, Console.
ReadLine());
Polimorfismo.Hemisferio hemisferio = new Polimorfismo.Hemisferio();
hemisferio.pais();
Console.ReadLine();
}
}
}
namespace Polimorfismo
{
public class Familia
{
//método pais [País ou Pais]
public virtual void pais()
{
Console.WriteLine (“ Método ‘pais’ do objeto ‘Familia’ “);
}
}
//utilizando o método com o mesmo nome em classes diferentes
class Continente : Familia
{
public override void pais()
{
Console.WriteLine (“ Método ‘pais’ do objeto ‘Continente’ “);
}
}
//utilizando o método com o mesmo nome em classes diferentes
class Hemisferio : Familia
{
public override void pais()
{
Console.WriteLine (“ Método ‘pais’ do objeto ‘Hemisferio’ “);
}
}

32
Programação Orientada a Objetos II

Figura 13 – Tela Windows Form – Label

Figura 14 – Tela Windows Form – CheckBox selecionado

Exemplo 5

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 WindowsFormsApplication1
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
checkBox1.Checked = false;
label1.Text = “”;
}
private void button1_Click(object sender, EventArgs e)
{
Polimo.Movimenta movimenta = new Polimo.Movimenta();
if (this.checkBox1.Checked)
{

33
 Unidade II

movimenta.carro_em_movimento(new Polimo.Acelerar());
label1.Text = “O Carro está acelerando.”;
}
else
{
movimenta.carro_em_movimento(new Polimo.Frear());
label1.Text = “O Carro está freando.”;
}
}
}
}
namespace Polimo
{
//Classe
public abstract class Carro
{
public abstract bool acao();
}
//Classe
public class Acelerar : Carro
{
//Usa o mesmo nome do método da Classe Carro
public override bool acao()
{
Console.WriteLine(“O Carro está acelerando.”);
return true;
}
}
//Classe
public class Frear : Carro
{
//Usa o mesmo nome do método da Classe Carro
public override bool acao()
{
Console.WriteLine(“O Carro está freando.”);
return true;
}
}
//Classe
public class Movimenta
{
public bool carro_em_movimento(Carro car)
{
return car.acao();
}
}
}

4 Camada de Apresentação

Em primeiro lugar, é importante sabermos que a Camada de Apresentação é a entrada de dados

de uma aplicação. Em muitos momentos ela é apresentada em projetos de software como Front‑End,
definida como protótipo na fase de levantamento de requisitos.

34
Programação Orientada a Objetos II

Figura 15 – Camada de Apresentação

Quadro 2 – Relação Controle versus Tela

Controle Name do Controle Text do Controle

Form frmNotasUnip Cadastro de Notas
GroupBox1 grpNotasSemestre Notas do Semestre
Label1 lblNotasP1 NotaP1:
Label2 lblNotasP2 NotaP2:
Label3 lblMedia Média:
ComboBox1 cbxNotaP1 ‑
ComboBox2 cbxNotaP2 ‑
GroupBox2 grpExameFinal Exame Final
Label4 lblNotaExame Nota Exame:
Button1 btnCalcularMedia Calcular Mé&dia
Button2 btnLimpar Lim&par
Button3 btnSair Sai&r
Button4 btnCalcularExame Calcular &Exame

Saiba mais

Para saber mais sobre esse assunto, sugerimos a leitura do artigo:

JOMORI, S. M.; VOLPE, R. L. D; ZABEU, A. C. P. Qualidade de software.

Revista Banas Qualidade, São Paulo, ano 13, n. 141, fev. 2004.

35
 Unidade II

4.1 Funções específicas da Camada de Apresentação

A camada de apresentação é responsável por diversas funções importantes no processo de execução

do software:

• Pode ser categorizada por processos de aplicação.

• Processamento de transações.

• Acesso a banco de dados.

• Gerência de ações sistêmicas etc.

Observação

Software ou aplicação podem, por meio de uma boa análise efetuada,

gerar frutos excepcionais. Uma boa análise equivale a 80% da execução de
um projeto, restando apenas 20%, que se destinam à programação.

Estudar uma linguagem específica garante conhecimento da tecnologia,

ou seja, ganho técnico. Porém, se a análise não andar em paralelo com
o código, não será possível aplicar todo o conhecimento técnico para o
sucesso da execução do desenvolvimento do software e/ou da aplicação.

A camada de apresentação contém os elementos da interface do usuário do site e inclui toda a

lógica, que compreende a interação do visitante e das regras de negócio (Windows Form).

Podemos definir a Camada de Apresentação, ou Camada do Cliente, ou até mesmo Camada Superior,
como a interface com o usuário, que poderia ser considerada até mesmo como as janelas do Windows
do nosso aplicativo, por exemplo.

Essa camada interage com a Camada de Controle (intermediária) para fazer solicitações e recuperar
informações da camada de dados, exibindo‑as para os usuários.

Uma segregação de camadas certamente deixa o código com uma leitura e um controle mais fáceis,
pois toda a regra está alocada em uma camada isolada.

4.2 Criando a Camada de Apresentação

Iremos apresentar como será feita a criação da nossa primeira camada de apresentação. A princípio
será criado um form para que possamos conhecer alguns componentes.

Como primeiro passo, abriremos nosso IDE de programação, chamado Microsoft Visual Studio.
36
Programação Orientada a Objetos II

Observação

Neste livro‑texto iremos utilizar o Microsoft Visual Studio 2012. Todo e

qualquer exemplo e/ou exercício deverá ser executado nessa versão ou em
uma superior.

Figura 16 – IDE de programação Microsoft Visual Studio 2012

Lembrete

Para efeito de padronização e arquitetura de solução, a estrutura

de desenvolvimento de softwares terá como referência o MVC (Model,
View, Controller), conforme mencionado anteriormente. No entanto, essa
arquitetura dará ao estudante uma visualização melhor sobre todos os
recursos utilizados neste livro‑texto.

Podemos destacar, dentro do Microsoft Visual Studio, pontos que são essenciais para a execução de
um bom trabalho para o desenvolvedor:

• Solution Explorer (Gerenciador de Soluções): aba em que irá ficar concentrada toda
a nossa estrutura de aplicação, desde a camada de apresentação até as classes que serão
utilizadas na aplicação.

37
 Unidade II

Figura 17 – Solution Explorer: Gerenciador de Soluções

• Toolbox (Barra de Ferramentas): utilizada para que o desenvolvedor possa criar suas telas com
base em protótipos elaborados na fase de levantamento de requisitos do projeto de software.

Figura 18 – ToolBox: Barra de Ferramentas

Para criamos um projeto Windows Form, ou seja, um projeto em que a premissa será elaborar uma
aplicação que será executada em ambiente desktop, teremos de seguir estes passos:

• Ao iniciar o Microsoft Visual Studio, devemos acionar o link New Project (Novo Projeto), ou no
menu superior File (Arquivo)  New (Novo) Project (Projeto).

38
Programação Orientada a Objetos II

Figura 19 – Tela inicial para adicionar um novo projeto

Figura 20 – Rota de menu para adicionar um novo projeto

Observação

A versão do Microsoft Visual Studio utilizada para ilustração deste

livro‑texto está em inglês. O autor recomenda a utilização dessa versão, pois
ela é encontrada na maioria das empresas que atuam com desenvolvimento
de software.

39
 Unidade II

• Após executar a ação anterior, a seguinte tela deverá ser apresentada:

Figura 21 – Caixa inicial de criação de um novo projeto

Na figura, podemos nos atentar para alguns detalhes, tais como:

• Do lado esquerdo existe um item chamado Templates, onde podemos, por exemplo, definir em
qual linguagem iremos atuar. É muito importante atentarmos à linguagem escolhida para que, no
momento da codificação, não possamos programar em linguagens diferentes.

Figura 22 – Aplicação Visual Basic com código C#

40
Programação Orientada a Objetos II

Figura 23 – Templates contidos dentro do Visual C#

Podemos notar que existem diversos templates, porém o que iremos utilizar será o Windows
Form Application.

Para que possamos finalizar o processo de criação do nosso projeto, será necessário atentar para
mais alguns itens:

• Name (Nome): nome que será colocado no projeto desenvolvido.

• Location (Localização): onde ficará alocado o novo projeto.

• Solution Name (Nome da Solução): será replicado o Name (Nome) informado para o novo projeto.

Observação

Recomendamos que nunca informe um diretório de pen drive para

salvar ou abrir um projeto Windows Form. Como parte das boas práticas, o
projeto deve ser criado e/ou alocado em disco local e só depois de todas as
alterações efetuadas ser transferido para o pen drive.

41
 Unidade II

Figura 24 – Definição do projeto inicial

Após a execução desse passo será apresentada a seguinte tela:

Figura 25 – Ambiente de Desenvolvimento Windows Form

Quando um projeto Windows Form é adicionado, temos a visualização do Form1, que é

adicionado automaticamente.

O Form1 nada mais é do que a tela onde o desenvolvedor irá adicionar todos os componentes
necessários para a sua funcionalidade.

Existe também, dentro do projeto Windows Form, a aba Solution Explorer, que detalha toda a
estrutura do projeto.

42
Programação Orientada a Objetos II

Figura 26 – Apresentação da Solution Explorer

Dentro da Solution Explorer existem alguns itens como:

• AplicacaoTeste: nome da aplicação, definida no momento da criação do projeto.

• Properties (propriedades): propriedades do projeto. Dentro dela, podemos visualizar cada label
utilizado no projeto e configurações realizadas para o funcionamento da aplicação.

• References (referências): local onde se armazenam todas as referências utilizadas na execução

da aplicação.

• App.config: classe que centraliza endereçamentos utilizados no projeto, dentro deles, o

endereçamento de banco de dados.

• Form1: formulário inicial para desenvolver o layout.

• Program: classe que define qual formulário será executado primeiro.

Figura 27 – Nome da aplicação – AplicacaoTeste

43
 Unidade II

Figura 28 – Properties (Propriedades) – AplicacaoTeste

Figura 29 – References (Referências) – AplicacaoTeste

Figura 30 – App.config – AplicacaoTeste

44
Programação Orientada a Objetos II

Figura 31 – Classe App.config – AplicacaoTeste

Figura 32 – Form1.cs – AplicacaoTeste

Figura 33 – Form1 – AplicacaoTeste

45
 Unidade II

Figura 34 – Program.cs – AplicacaoTeste

Figura 35 – Classe program.cs – AplicacaoTeste

Podemos alterar algumas propriedades do formulário. Na camada de apresentação podemos

adicionar n projetos, ou seja, não existe limitação de formulários dentro desse projeto.

Para adicionarmos um novo formulário podemos seguir por esta rota:

46
Programação Orientada a Objetos II

• Em cima do projeto AplicacaoTeste, devemos clicar com o botão direito. A seguinte tela
será apresentada:

Figura 36 – Menu com itens a serem selecionados

Figura 37 – Selecionar o item Add  Windows Form

47
 Unidade II

Em seguida acionaremos a rota Add  New Item, a tela a seguir será apresentada:

Figura 38 – Tela para adicionar um novo item ao projeto – AplicacaoTeste

Nessa tela, podemos notar que é possível adicionar ao projeto:

• classe;

• formulário;

• classe de componente;

• diagrama de classe.

Figura 39 – Templates que podem ser adicionados ao projeto – AplicacaoTeste

48
Programação Orientada a Objetos II

Após ser adicionado o novo formulário, a Solution Explorer é atualizada com o novo item:

Figura 40 – Form2 adicionado à Solution Explorer

Podemos alterar o nome do Form1 para que possamos especificar melhor nosso projeto.

Observação

Dentro da Solution Explorer podemos adicionar muitos formulários. No

entanto, é muito importante que todos os formulários sejam nomeados
para que, no futuro, cada um possa ser atribuído como funcionalidade
sistêmica da aplicação.

Para que essa ação possa ser efetuada, podemos clicar com o botão direito em cima do nome do
formulário e acionar a ação rename (renomear).

Figura 41 – Renomear Form1 dentro da Solution Explorer

49
 Unidade II

Observação

Como forma de padronização, nomearemos as interfaces iniciando

sempre com as letras “frm”, representando a abreviação do termo
“formulário”, de forma que auxilie os desenvolvedores a saberem que tudo o
que estiver escrito dessa forma deverá ser entendido como implementação
de interfaces.

Figura 42 – frmMensagem: nome do novo formulário

Após ser alterado o nome, acionar o botão enter do teclado. Será apresentada a tela a seguir,
perguntando se todas as classes poderão ser renomeadas; acionamos o botão “sim”:

Figura 43 – Confirmação da alteração de nome de Form1 para frmMensagem

50
Programação Orientada a Objetos II

Para alterarmos o nome da barra de títulos do formulário, deveremos clicar com o botão direito em
cima do formulário frmMensagem e acionar o item properties.

Figura 44 – Properties (propriedades) do formulário Form1

Será apresentada, ao lado direito da tela, uma aba na qual todas as propriedades serão apresentadas.

Figura 45 – Propriedades do formulário

51
 Unidade II

Todo formulário adicionado contém suas respectivas propriedades. Dentre elas, podemos alterar:

• Nome do título.

• Cor de fundo.

• Tamanho do formulário.

• Fonte.

• Controles do formulário.

Figura 46 – Propriedade Text alterada para frmMensagem

Quando a propriedade Text foi alterada, automaticamente o título do formulário foi alterado para
frmMensagem; assim, no momento de execução, esse é o título que será apresentado.

Lembrete

Para efeito de padronização, nomeamos as interfaces iniciando sempre

com as letras “frm”, representando a abreviação do termo “formulário”. Isso
auxilia os desenvolvedores a saberem que tudo o que estiver descrito dessa
maneira será entendido como implementação de interfaces.

52
Programação Orientada a Objetos II

Figura 47 – Formulário em modo de execução

Podemos, por meio de um protótipo desenvolvido na fase de levantamento de requisitos, iniciar a

construção da camada de apresentação. Um protótipo é uma visão de como a camada de apresentação
será construída dentro do projeto de software.

Figura 48 – Protótipo

Com base no protótipo, podemos replicar a figura dentro da camada de apresentação utilizando
alguns componentes‑padrão do Microsoft Visual Studio.

Os componentes que serão utilizados para a construção da camada de apresentação são:

53
 Unidade II

• Label: responsável por alocar um rótulo na camada de apresentação.

• TextBox: responsável por adicionarmos dados de entrada e saída na camada de apresentação.

• Button: responsável por executar a ação desenvolvida na linguagem determinada.

Esses componentes estão contidos no ToolBox (barra de ferramentas).

Figura 49 – Componente Label

Figura 50 – Componente TextBox

Figura 51 – Componente Button

Observação

Os componentes estão alocados na barra de ferramentas, no item

Common Controls.

Iremos iniciar clicando no componente Label e arrastando para o formulário. Todos os componentes
têm como premissa o comportamento de orientação a objeto, ou seja, todos os componentes são objetos
com as suas respectivas propriedades.

Todo componente tem, em suas propriedades, cor, tamanho, posicionamento etc.

54
Programação Orientada a Objetos II

Figura 52 – Formulário com label1

Para que o label1 seja apresentado conforme o protótipo anterior devemos alterar a sua propriedade
de nome. Para isso, em cima do label, iremos clicar com o botão direito do mouse, assim sendo apresentado
um menu.

Figura 53 – Menu de ações do label1

Ao ser apresentado esse menu, iremos clicar em Propriedades. Nesse momento, para o label1, serão
visualizadas todas as propriedades para esse componente.

55
 Unidade II

Figura 54 – Propriedades do componente label1

Podemos visualizar diversas propriedades atribuídas ao componente label1. Nesse primeiro momento
iremos alterar as propriedades Name e Text.

Figura 55 – Propriedade Text do componente label1

Nesse momento, ao ser alterada a propriedade text do componente label1, automaticamente, no

formulário, é replicada e visualizada a alteração. Após essa ação iremos alterar a propriedade name do
componente label1, que será chamado de lblDigiteMensagem.

56
Programação Orientada a Objetos II

Figura 56 – Propriedade Name do componente label

Essa alteração é necessária para um bom entendimento do código. Iremos acompanhar mais à frente
que todos os componentes deverão ser nomeados de uma maneira amigável para que possa facilitar o
desenvolvimento e a manutenção do código.

Quadro 3 – Detalhes de componentes

Componente Name Text

Label lblDigiteMensagem Digite uma Mensagem:
TextBox txtDigiteMensagem N/A
Button btnOk Ok

Podemos perceber que, para cada componente, sempre o seu name irá se iniciar com uma
identificação que remeta ao nome do componente. Exemplo: no caso do nome lblDigiteMensagem, as
letras “lbl” seriam uma espécie de abreviação de label; já no caso de btnDigiteMensagem, as letras “btn”
seriam a referência ao componente button.

Observação

Não é uma regra trabalhar com abreviação de componentes. Caso

o desenvolvedor se sinta confortável, nem precisa alterar o seu name.
Porém, devemos pensar que podem existir aplicações nas quais, dentro do
formulário, podem existir dez TextBox e, como cada vez que é adicionado
um componente o Microsoft Visual Studio adiciona o número 1 (como
textbox1, textbox2, textbox3 etc.), como identificar, por exemplo, qual
textbox equivale ao nome do usuário ou ao login do usuário?

57
 Unidade II

Agora será adicionado o Textbox. Para isso, iremos localizar o componente na barra de ferramentas
e arrastar para o nosso formulário.

Figura 57 – Text adicionado ao formulário

Para esse componente, será alterado o seu name. Para essa ação, iremos clicar com o botão direito
do mouse e será aberto um menu de ações desse componente:

Figura 58 – Menu de ações do componente TextBox

Após esta ação será acionada a propriedade do componente TextBox. Serão abertas todas as
propriedades desse componente:
58
Programação Orientada a Objetos II

Figura 59 – Propriedades do componente TextBox

Após a janela de propriedades ser apresentada, iremos alterar a sua propriedade name para
txtDigiteMensagem.

Figura 60 – Propriedade Name alterada para txtDigiteMensagem

Agora iremos adicionar o nosso terceiro componente no formulário chamado button. Para isso iremos
até a barra de ferramentas, clicaremos no componente button e vamos arrastá‑lo até o formulário.

59
 Unidade II

Figura 61 – Componente button adicionado ao formulário

Depois, iremos acessar as propriedades do componente button. Para isso, iremos clicar com o botão
direito em cima do componente button e acionar o item Propriedades.

Figura 62 – Menu de ações do componente button

60
Programação Orientada a Objetos II

Figura 63 – Propriedades do componente button

Para esse componente iremos alterar as propriedades name e text, conforme protótipo
apresentado anteriormente.

Figura 64 – Propriedade name do componente button alterada

61
 Unidade II

Figura 65 – Propriedade text do componente button alterada

Após serem efetuadas todas as inclusões de componentes no formulário, teremos nossa camada de
apresentação fiel ao protótipo apresentado.

Figura 66 – Camada de apresentação

62
Programação Orientada a Objetos II

Para que possamos visualizar a nossa aplicação devemos acionar o botão “executar”, que fica no
menu superior do Microsoft Visual Studio. Nesse instante acontecerá uma simulação do comportamento
da aplicação, como se ela estivesse instalada, por exemplo, em uma estação de trabalho.

Figura 67 – Botão Start, que executa aplicação

Figura 68 – AplicacaoTeste sendo executada

Podemos imprimir a mensagem “Professor” dentro de um label. Para isso seguiremos o escopo a seguir:

• Digitar uma mensagem na caixa de texto.

63
 Unidade II

• Acionar o botão Ok.

• Apresentar a mensagem por meio de uma label.

Iremos adicionar uma label logo abaixo da caixa de texto:

Figura 69 – Label1 inserida no formulário

Serão alteradas as propriedades Name e Text para identificarmos o componente adicionado

ao formulário. Para essa ação iremos clicar com o botão direito em cima do componente label1 e
acionaremos o item Properties (Propriedades).

Figura 70 – Menu de ações do componente label1

64
Programação Orientada a Objetos II

Figura 71 – Text lblMensagem

Figura 72 – Name lblMensagem

Nesse momento, atendemos parcialmente o requisito solicitado. Nesse instante iremos iniciar a
codificação. Para isso, acionaremos o botão OK, efetuando um duplo clique.

65
 Unidade II

Figura 73 – Modo de codificação

Para que possamos entender melhor o cenário proposto, quando o usuário digitar uma mensagem e
acionar o botão Ok, a mensagem deverá ser apresentada dentro do label lblmensagem.

Inicialmente, para que possamos efetuar o entendimento do código, vamos pensar em um

código estruturado.

Início  Digite uma mensagem  Mensagem é transferida para label lblMensagem  Fim

Para que essa ação possa ser concretizada no código, digitaremos a seguinte instrução:

Figura 74 – Código do botão OK

66
Programação Orientada a Objetos II

O entendimento do código poderia ser feito da seguinte maneira:

• lblMensagem.Text: neste trecho estamos informando ao código C# o nome do componente

(lblMensagem) e sua propriedade (Text). Quando a propriedade informada for Text, poderemos
entender que ela irá receber dados alfanuméricos (String).

• txtDigiteMensagem.Text: neste trecho estamos informando ao código C# o nome do

componente (txtDigiteMensagem) e sua propriedade (Text). Quando a propriedade informada for
Text, poderemos entender que ela irá receber dados alfanuméricos (String).

Resumido a ação codificada, tudo o que estiver sendo informado no componente txtDigiteMensagem
será enviado para o componente lblMensagem.

Vamos executar nossa aplicação:

Figura 75 – AplicacaoTeste sendo executada

Após digitar a palavra “Professor” na caixa de texto, acionaremos o botão OK. Perceba que existe no
formulário o label lblMensagem.

67
 Unidade II

Figura 76 – Label recebe palavra digitada na caixa de texto

Nesse instante, após o botão Ok ser acionando, o label lblMensagem mudou para a palavra “Professor”,
que foi digitada na caixa de texto.

Vamos exercitar. A partir de um protótipo construído após efetuado um levantamento de requisitos,

iremos construir uma calculadora, onde teremos as operações básicas da matemática: adição, subtração,
divisão e multiplicação. Vamos observar o protótipo construído:

Figura 77 – Protótipo Calculadora

68
Programação Orientada a Objetos II

Para a efetivação do código, iremos iniciar pela análise do protótipo. Na figura podemos observar
que existem:

• Três labels.

• Quatro botões.

Quadro 4 – Componentes

Componente Nome Texto

Label lblDigitePrimeiroNumero Digite o primeiro número
Label lblDigiteSegundoNumero Digite o segundo número
Label lblResultado Resultado
Button btnAdicao +
Button btnSubtracao ‑
Button btnMultiplicação *
Button btnDivisao /

Vamos programar:

1. Crie um novo projeto (Windows FormApplication), com o nome de Calculadora.

2. Altere a propriedade Text do formulário para Calculadora.

Figura 78 – Projeto Windows Form Application: calculadora

69
 Unidade II

3. Agora iremos inserir os componentes dentro do formulário, conforme protótipo apresentado

anteriormente.

Figura 79 – Formulário Calculadora

Podemos notar que todos os componentes inseridos no formulário estão sem o nome; para isso, em
todos os componentes, iremos alterar as propriedades Name e Text:

Figura 80 – Alterando propriedade Text do botão Adicionar

70
Programação Orientada a Objetos II

Figura 81 – Propriedade Name alterada no botão Adicionar

Para todos os componentes de tela iremos alterar as propriedades Name e Text e, para isso, iremos
para cada componente, clicar com o botão direito e, em seguida, em Properties:

Figura 82 – Properties (propriedades) do botão Adicionar

Após a execução desse passo, todos os componentes serão alterados e apresentados conforme figura
a seguir:

71
 Unidade II

Figura 83 – Calculadora com todos os componentes adicionados

Vamos iniciar a codificação dos botões da nossa calculadora, mas, antes, precisamos entender alguns
pontos importantes:

• Todo número, a princípio, só poderá ser matematicamente operado se for, no mínimo, do tipo inteiro.

• Caixas de texto recebem somente string.

Para iniciarmos o entendimento de como as operações matemáticas serão efetuadas, precisamos

entender o conceito de Tipos Primitivos, que são atribuições dadas a variáveis que auxiliam na
codificação C#.

Exemplo: precisamos somar dois valores contidos em caixas de texto.

Valor A: 10.

Valor B: 10.

Resultado: 20.

Para que essa conta possa ser executada no código C#, podemos inicialmente declarar duas variáveis
do tipo primitivo inteiro.

72
Programação Orientada a Objetos II

Quadro 5 - Tipos primitivos

Tipo Faixa de Valores Armazenamento

byte ‑128 a 127 Inteiro de 8 bits
short ‑32.768 a 32.767 Inteiro de 16 bits
int ‑2.147.483.648 a 2.147.483.647 Inteiro de 32 bits
‑9.223.372.036.854.775.808 a
long Inteiro de 64 bits
9.223.372.036.854.775.807
1.401298464324811707e‑45 a
float Ponto flutuante de 32 bits
3.40282346638528860e+38
4.94065645841246544e‑324 a
double 8 bytes ou 64 bits
1.79769313486231570e+308
char Representam um único caractere 16 bits
boolean True ou False 1 bit

Escrevendo nosso código, em Português Estruturado, ficaria:

Inicio

Linha1: Var valorA inteiro;

Linha2: Var ValorB inteiro;

Linha3: Var resultado inteiro;

Linha4: valorA = CaixaTexto(Valor A)(Inteiro);

Linha5: valorB = CaixaTexto(Valor B)(Inteiro);

Linha6: Resultado = valorA + valorB;

Linha7: CaixaTexto(resultado) = resultado(String);

Fim

Observação

Português Estruturado ou pseudocódigo é uma sequência de instruções

que pode ser entendida por programadores, independentemente da
linguagem de programação utilizada.

73
 Unidade II

Vamos entender a codificação.

Linhas 1, 2 e 3

Foram declaradas as variáveis valorA, valor e resultado do tipo inteiro, ou seja, será por meio dessas
variáveis que serão feitas a atribuição de valores e a execução da operação matemática soma.

Linhas 4, 5 e 6

As variáveis valorA e valorB receberam os dados digitados nas Caixas de Texto A e B, porém elas
deverão ser convertidas para o tipo primitivo inteiro, pois o seu conteúdo é do tipo string.

Observação

Esse item será mais bem-detalhado quando efetuarmos a codificação

na linguagem C#.

Linha 6

A variável resultado irá receber o resultado da soma das variáveis valorA e valorB.

Linha 7

A Caixa de Texto Resultado irá receber a variável resultado, porém deverá ser feita uma conversão
do tipo inteiro para o tipo string.

Com o Português Estruturado em mãos, vamos iniciar a codificação utilizando a linguagem C#. O
botão Soma (+) será o primeiro a ser codificado. Para isso iremos clicar duas vezes no botão (+) para que
possamos ser redirecionados para o módulo de codificação.

74
Programação Orientada a Objetos II

Figura 84 – Modo codificação

Nesse instante estamos dentro da classe do nosso formulário Calculadora. Quando efetuarmos o
duplo clique no botão (+) do formulário, a aplicação irá nos direcionar até o evento do botão.

Podemos notar que o evento ao qual fomos direcionados, por padrão, é o evento Click, ou seja, no
momento em que o formulário estiver sendo executado e o botão (+) for acionado, será disparado o
evento e executado tudo o que estiver codificado dentro dele.

Para o componente botão adicionado no formulário existem inúmeros eventos. Para que possamos
visualizar os eventos do botão, podemos clicar com o botão direito do mouse em cima do botão e
acionar o item Properties.

75
 Unidade II

Figura 85 – Properties do botão (+)

Logo abaixo do topo da janela Properties, existe um ícone com um símbolo de raio, que equivale aos
eventos que podem ser atribuídos ao botão.

Figura 86 – Eventos do botão (+)

76
Programação Orientada a Objetos II

Na figura, podemos observar que o evento que está acionado é o Click, no qual iremos codificar
inicialmente. Existem diversos eventos que podemos utilizar para a ação de um botão.

Após estarmos dentro do evento click do botão (+) iniciaremos o desenvolvimento do nosso código.

Lembrete

Observe que o botão (+) está com o name btnMais, ou seja, para
qualquer dúvida, estamos programando dentro do evento click do botão
(+). Esse name foi atribuído à propriedade, facilitando o trabalho de
codificação e de documentação. Não é uma regra trabalhar com abreviação
de componentes. No entanto, devemos pensar que podem existir aplicações
nas quais, dentro do formulário, pode haver inúmeros itens que precisem
ser organizados para auxiliar o trabalho do desenvolvedor.

A primeira etapa é declararmos variáveis que receberão o conteúdo digitado em tela:

Figura 87 – Declaração de variáveis

Podemos perceber que as variáveis valor1, valor2 e resultado foram declaradas com o tipo primitivo
int (inteiro), ou seja, a soma somente irá aceitar números inteiros. Mais um detalhe é que nossas variáveis
estão marcadas em verde; isso é uma ação que o Visual Studio realiza quando uma variável é declarada,
porém não utilizada na estrutura de codificação.

77
 Unidade II

A segunda etapa é receber da calculadora os valores informados em tela:

Figura 88 – Variáveis recebendo valores informados na tela

Nota‑se que as palavras txtDigitePrimeiroNumero.Text e txtDigiteSegundoNumero.Text estão

sublinhadas em vermelho; vamos entender:

• Estamos enviando um conteúdo string para uma variável que foi declarada como tipo
primitivo inteiro.

• Precisamos atribuir o contexto string à variável inteiro para que o cálculo possa ser realizado.

Para isso precisamos converter (transformar) o tipo primitivo string, que está na propriedade text,
para o tipo primitivo inteiro. Com esse objetivo iremos escrever a seguinte linha:

78
Programação Orientada a Objetos II

Figura 89 – Convertendo tipo primitivo (String para Inteiro)

Iremos utilizar Convert.ToInt16 para que possamos pegar o conteúdo informado dentro do componente
text para o tipo primitivo inteiro, assim iremos conseguir efetuar, inicialmente, a soma de valores.

Após essa ação nosso código prosseguirá da seguinte maneira:

Figura 90 – Variável resultado recebendo o valor da soma

79
 Unidade II

Após definido o código, precisamos informar o resultado dentro do componente text e, para isso,
iremos efetuar o processo inverso de transformação de tipo primitivo, ou seja, nosso código terá o
seguinte comportamento:

Figura 91 – Componente Text recebendo o valor da variável resultado

Podemos perceber que, para o componente text (txtResultado.Text), a variável foi transformada do
tipo primitivo inteiro para o tipo primitivo string, assim podendo ser visualizada dentro do componente
text no momento de sua execução. Agora iremos executar a nossa aplicação acionando a tecla F5.

Figura 92 – Aplicação em modo de execução

80
Programação Orientada a Objetos II

Nesse momento, nossa aplicação está rodando e iremos informar dois valores para efetuarmos a
nossa soma:

Figura 93 – Valores sendo informados na caixa de texto

Após informarmos os valores iremos acionar o botão (+) da tela. Nesse instante nosso código será
executado, e o valor da soma será apresentado na caixa de texto Resultado:

Figura 94 – Valor da soma apresentado na caixa de texto

81
 Unidade II

Para as operações de subtração e multiplicação o comportamento do código será muito semelhante

à ação de soma.

Para a ação de multiplicação, iremos clicar duas vezes no botão (*) e programar o seguinte código:

Figura 95 – Código que efetua a multiplicação de valores

Figura 96 – Valor da multiplicação apresentado na caixa de texto Resultado

82
Programação Orientada a Objetos II

Figura 97 – Código que efetua a subtração de valores

Figura 98 – Valor da subtração apresentada na caixa de texto Resultado

Nesse instante será efetuado o teste para divisão. No entanto, neste caso, precisamos tomar alguns
cuidados específicos. Dentre eles, considerar a questão: todo número é divisível por zero (0)?

Saiba mais

Leia o artigo de Gabriel Alessandro de Oliveira, para entender um pouco

mais sobre o tema. Ele está disponível no seguinte endereço:

83
 Unidade II

UNIVERSIDADE FEDERAL DO RIO GRANDE DO SUL (UFRGS). Calculando

com o zero: dividindo por zero. Porto Alegre: UFRGS, [s.d.]. Disponível em:
<http://www.mat.ufrgs.br/~portosil/passa7d.html>. Acesso em: 22 jun. 2015.

Vamos rodar nossa solução para verificar o comportamento do nosso código:

Figura 99 – Divisão não pode ser realizada

Ao ser realizada a divisão 10/0 surge uma mensagem no código informando que a divisão por zero
não pode ser realizada, mas como podemos tratar esse erro?

4.3 Desvios condicionais

4.3.1 Desvios condicionais (Comandos de Seleção)

Além dos algoritmos sequenciais, também denominados lineares, há problemas e situações que
necessitam da introdução de comandos de seleção (desvios condicionais simples e desvios condicionais
compostos) para que as decisões possam ser tomadas. No caso da aplicação que estamos desenvolvendo,
precisamos criar um “desvio” para a condição de divisão por zero (0).

4.3.2 Condição

Chamamos de condição a expressão lógica que norteia a tomada de certa decisão, ou seja, precisamos
definir uma expressão que direcione a solução do item divisão por zero (0).

84
Programação Orientada a Objetos II

Por exemplo: imagine que, após a realização do exame final, a média mínima para que um aluno seja
aprovado em determinada disciplina seja igual a 5. Se chamarmos de M a variável que indica a média
do aluno, teremos que a condição para que o estudante seja aprovado é M>=5. Em outras palavras, a
expressão lógica que norteia a tomada de decisão (ser aprovado ou ser reprovado) é M >= 5.

Para o cenário que existe em nosso exemplo da calculadora podemos iniciar a expressão considerando
que o valor2 deverá ser maior que zero (0): valor2 > 0.

4.3.3 Decisão

A decisão é tomada em função de uma condição ser ou não satisfeita. Assim, a tomada de decisão
implica a escolha de qual trecho do algoritmo deve ser executado de acordo com o resultado obtido e
com a sua comparação a uma condição estabelecida.

A condição que oferece o critério de decisão é satisfeita ou não, ou seja, admitem‑se apenas duas
respostas possíveis. Assim, a decisão envolverá, no máximo, duas opções: uma ação no caso de a condição
ser verdadeira (V) e outra no caso de a condição ser falsa (F). Nessas situações, temos o chamado desvio
condicional composto.

Há casos que apresentam somente a primeira alternativa: neles, se a condição for falsa (F), o algoritmo
continuará o fluxo de instruções posteriores ao desvio condicional. Nessas situações, temos o chamado
desvio condicional simples.

Em vez de usarmos as notações de condição verdadeira, indicada por (V), e de condição falsa, indicada
por (F), podemos utilizar, respectivamente, “sim” (S) e “não” (N).

4.3.4 Desvio condicional simples

O desvio condicional simples é uma estrutura utilizada em algoritmos e programas computacionais

na qual se indica uma tomada de decisão, ou seja, um algoritmo é executado caso determinada condição
seja verdadeira (V).

A seguir apresentamos a sintaxe do desvio condicional simples para programas elaborados em

Português Estruturado.

Lembrete

Português Estruturado ou pseudocódigo é uma sequência de instruções

que pode ser entendida por programadores, independentemente da
linguagem de programação utilizada.

85
 Unidade II

Se (CONDIÇÃO) então

<instruções a serem executadas no caso de a condição ser verdadeira>;

Fim_se;

Genericamente, o fluxograma relacionado ao desvio condicional simples é o mostrado na figura a seguir.

Observação

Fluxograma é uma representação gráfica de um procedimento,

problema ou sistema cujas etapas ou módulos são ilustrados de forma
encadeada por meio de símbolos geométricos interconectados para a
representação de um algoritmo.

Figura 100 – Exemplo de desvio condicional simples

4.3.5 Desvio condicional composto

O desvio condicional composto é uma estrutura utilizada em algoritmos e programas

computacionais. Nela, indica‑se uma tomada de decisão de executar um trecho do algoritmo caso
determinada condição seja verdadeira (V) e outra tomada de decisão de executar outro trecho do
algoritmo caso essa condição seja falsa (F).

A seguir, apresenta‑se a sintaxe do desvio condicional composto para programas elaborados em

Português Estruturado.

86
Programação Orientada a Objetos II

Se (CONDIÇÃO) então

<instruções a serem executadas no caso de a condição ser verdadeira>;

Senão

<instruções a serem executadas no caso de a condição ser falsa>;

Fim_se;

Genericamente, o fluxograma relacionado ao desvio condicional composto é o mostrado na figura

a seguir:

Figura 101 – Exemplo de desvio condicional composto

4.3.6 Operadores Lógicos

O uso combinado dos diversos tipos de operadores proporciona a execução das tarefas mais comuns
de processamento de dados.

Quadro 6 – Operadores lógicos

OPERADOR OPERAÇÃO
E (AND) COJUNÇÃO LÓGICA
OU (OR) DISJUNÇÃO LÓGICA
NÃO (NOT) NEGAÇÃO

87
 Unidade II

A prioridade dos operadores lógicos é a seguinte:

• Prioridade mais alta: NOT.

• Prioridade média: AND.

• Prioridade mais baixa: OR.

Para iniciarmos a resolução do problema de divisão por zero (0), iremos pensar na seguinte estrutura:

• Criar uma condicional simples para que possamos tratar dessa situação, conforme ilustra a figura.

Figura 102 – Código C# com condicional simples

Para entendermos melhor o código apresentado vamos seguir com a análise:

• A variável valor2 recebe o conteúdo da caixa de texto txtDigiteSegundoNumero.

• Após a variável valor2 estar carregada, é feita a seguinte validação: se valor2 for diferente (!=) de
zero (0), então efetue o cálculo e apresente o valor na caixa de texto txtResultado.

Efetuando o teste, iremos obter o seguinte cenário:

88
Programação Orientada a Objetos II

Figura 103 – Cenário de sucesso

Figura 104 – Cenário de falha

Podemos perceber que o cálculo não foi efetuado, porém nenhuma mensagem foi informada para
o usuário que está interagindo com o sistema. Para isso teremos de aplicar como solução a condicional
composta.

Vamos efetuar uma análise:

• Se o valor2 recebido pela caixa de texto txtDigiteSegundoNumero for diferente (!=) de zero (0),
então deverá ser feito o cálculo e apresentado o resultado na caixa de texto txtResultado.

89
 Unidade II

• Senão, ou seja, se valor2 recebido pela caixa de texto txtDigiteSegundoNumero for igual (==) a
zero (0), então deverá ser exibida uma mensagem para o usuário informando que não existe a
possibilidade de efetuar o cálculo desejado.

Como essa ação deverá ser codificada? Vamos analisar a figura a seguir:

Figura 105 – Código C# com condicional composta

Vamos executar o código para entendermos melhor:

Figura 106 – Apresentação do cenário com falha

90
Programação Orientada a Objetos II

Para que possamos entender o código criado, colocamos a condicional composta da seguinte maneira:

• Se a condição for atendida, o cálculo será realizado, senão será exibida uma mensagem, utilizando
o método messagebox.show.

Saiba mais

Leia a definição do método MessageBox.Show para entender um pouco

mais sobre o tema:

MÉTODO MessageBox.Show. Microsoft Developer Network. 2015.

Disponível em: <https://msdn.microsoft.com/pt‑br/library/system.windows.
forms.messagebox.show%28v=vs.110%29.aspx>. Acesso em: 10 jun. 2015.

Resumo

Abordamos os principais conceitos da disciplina de Programação

Orientada a Objetos II, utilizando como conceito a linguagem de
programação C#. Entendemos que a construção de uma classe e todo o
seu processo de transformação em cada objeto tem por finalidade criar
mecanismos que possam interagir entre aplicação e usuário.

Também foram abordados conceitos de atributos de classes, que,

por sua vez, são características de uma classe que tem como premissa
a interação com métodos construídos. Também foram apresentadas
técnicas de desenvolvimento na linguagem C#, bem como a apresentação
da IDE Microsoft Visual Studio, seus recursos e conceitos iniciais para o
desenvolvimento de aplicação utilizando o template Windows Form.

Conhecemos também desvios condicionais que irão possibilitar tomadas

de decisões desenvolvidas na linguagem C# e seus operadores lógicos, que
serão capazes de auxiliar o desenvolvimento de aplicações, bem como,
ao final de sua codificação, apresentar, por exemplo, uma mensagem de
retorno do desvio codificado.

Encerramos vendo a importância do entendimento do português

estruturado, que será uma derivação para o código na linguagem C#, bem
como a segregação de código, utilizando como recurso de aprendizado o
MVC (Model, View, Controller).

91