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:
• É considerada uma evolução do C++, do qual são utilizadas algumas características, como
declarações, expressões e operadores.
• 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.
• 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 #.
Saiba mais
3.3 Herança
24
Programação Orientada a Objetos II
Exemplo 1
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
//construtor
public _____________()
{
Console.WriteLine(“Construção do objeto Pessoa.”);
}
}
25
Unidade II
//construtor
public Aluno()
{
Console.WriteLine(“Construção do objeto Aluno.”);
}
}
}
Exemplo 2
using System;
namespace ConsoleApplication2
{
class Program
{
static void Main(string[] args)
{
}
}
}
namespace HerancaBase
{
public class __________
{
//atributos
public string _________;
26
Programação Orientada a Objetos II
//construtor
public __________()
{
//nada
}
public Pessoa(string n)
{
this.nome = n;
Console.WriteLine(“Construção do objeto Pessoa com parâmetro.”);
}
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.
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
28
Programação Orientada a Objetos II
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 = “”;
}
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
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
34
Programação Orientada a Objetos II
Saiba mais
35
Unidade II
• Processamento de transações.
Observação
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.
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
Lembrete
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
• 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.
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
Observação
39
Unidade II
• 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.
40
Programação Orientada a Objetos II
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:
• Solution Name (Nome da Solução): será replicado o Name (Nome) informado para o novo projeto.
Observação
41
Unidade II
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
• Properties (propriedades): propriedades do projeto. Dentro dela, podemos visualizar cada label
utilizado no projeto e configurações realizadas para o funcionamento da aplicação.
43
Unidade II
44
Programação Orientada a Objetos II
45
Unidade II
46
Programação Orientada a Objetos II
• Em cima do projeto AplicacaoTeste, devemos clicar com o botão direito. A seguinte tela
será apresentada:
47
Unidade II
Em seguida acionaremos a rota Add New Item, a tela a seguir será apresentada:
• classe;
• formulário;
• classe de componente;
• diagrama de classe.
48
Programação Orientada a Objetos II
Após ser adicionado o novo formulário, a Solution Explorer é atualizada com o novo item:
Podemos alterar o nome do Form1 para que possamos especificar melhor nosso projeto.
Observaçã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).
49
Unidade II
Observação
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”:
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.
Será apresentada, ao lado direito da tela, uma aba na qual todas as propriedades serão apresentadas.
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.
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
52
Programação Orientada a Objetos II
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.
53
Unidade II
Observação
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.
54
Programação Orientada a Objetos II
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.
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
Podemos visualizar diversas propriedades atribuídas ao componente label1. Nesse primeiro momento
iremos alterar as propriedades Name e Text.
56
Programação Orientada a Objetos II
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.
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
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.
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:
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
Após a janela de propriedades ser apresentada, iremos alterar a sua propriedade name 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
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.
60
Programação Orientada a Objetos II
Para esse componente iremos alterar as propriedades name e text, conforme protótipo
apresentado anteriormente.
61
Unidade II
Após serem efetuadas todas as inclusões de componentes no formulário, teremos nossa camada de
apresentação fiel ao protótipo apresentado.
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.
Podemos imprimir a mensagem “Professor” dentro de um label. Para isso seguiremos o escopo a seguir:
63
Unidade II
64
Programação Orientada a Objetos II
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
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.
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:
66
Programação Orientada a Objetos II
Resumido a ação codificada, tudo o que estiver sendo informado no componente txtDigiteMensagem
será enviado para o componente lblMensagem.
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
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.
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
Vamos programar:
69
Unidade II
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:
70
Programação Orientada a Objetos II
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:
Após a execução desse passo, todos os componentes serão alterados e apresentados conforme figura
a seguir:
71
Unidade II
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.
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
Inicio
Fim
Observação
73
Unidade II
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
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
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
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.
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.
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
• 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
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.
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:
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.
80
Programação Orientada a Objetos II
Nesse momento, nossa aplicação está rodando e iremos informar dois valores para efetuarmos a
nossa soma:
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:
81
Unidade II
Para a ação de multiplicação, iremos clicar duas vezes no botão (*) e programar o seguinte código:
82
Programação Orientada a Objetos II
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
83
Unidade II
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?
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).
Lembrete
85
Unidade II
Se (CONDIÇÃO) então
Fim_se;
Observação
86
Programação Orientada a Objetos II
Se (CONDIÇÃO) então
Senão
Fim_se;
O uso combinado dos diversos tipos de operadores proporciona a execução das tarefas mais comuns
de processamento de dados.
OPERADOR OPERAÇÃO
E (AND) COJUNÇÃO LÓGICA
OU (OR) DISJUNÇÃO LÓGICA
NÃO (NOT) NEGAÇÃO
87
Unidade II
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.
• 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.
88
Programação Orientada a Objetos II
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.
• 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:
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
Resumo
91