Analise e Programacao

Análise e Programação
MANUAL DO (A) PROFESSOR (A)
JULHO DE 2012
FORTALEZA/CEARÁ
Governador
Cid Ferreira Gomes
Vice-governador
Domingos Gomes de Aguiar Filho
Secretária de Educação
Maria Izolda Cela de Arruda Coelho
Secretário Adjunto
Maurício Holanda Maia
Secretário Executivo
Antonio Idilvan de Lima Alencar
Assessora Institucional do Gabinete

Cristiane Holanda
Coordenadora da Educação Profissional
Andréa Araújo Rocha
Consultoria Técnica Pedagógica:
Renanh Gonçalves de Araújo
Equipe de Elaboração:
Cintia Reis
Fernanda Vieira Ribeiro
João Paulo de Oliveira Lima
Liane Coe Girão Cartaxo
Mirna Geyla Lopes Brandão
Moribe Gomes de Alcântara
Valbert Oliveira Costa
Sumário do Manual
APRESENTAÇÃO ............................................................................................................................7
OBJETIVOS DE APRENDIZAGEM ...................................................................................................8
CONTEÚDO PROGRAMÁTICO .......................................................................................................9
EMENTA ..................................................................................................................................... 12
CRONOGRAMA DE ATIVIDADES ................................................................................................. 17
CONTEÚDOS INTERDISCIPLINARES ............................................................................................ 25
MAPA DE ANÁLISE DE AVALIAÇÃO............................................................................................. 26
REFERÊNCIAS BIBLIOGRÁFICAS.................................................................................................. 28
SUMÁRIO DA APOSTILA............................................................................................................... 29
FASE I : LÓGICA DE PROGRAMAÇÃO ................................................................................ 32
AULA - 1. INTRODUÇÃO A LÓGICA DE PROGRAMAÇÃO ............................................................. 32

1.1. INTRODUÇÃO .............................................................................................................................. 32
1.2. NOÇÕES DE LÓGICA ................................................................................................................... 32
AULA - 2. CONCEITOS DE PROGRAMAÇÃO ............................................................................... 34
2.1. TIPOS DE LINGUAGENS DE PROGRAMAÇÃO .............................................................................. 34
2.2. PARADIGMAS DE PROGRAMAÇÃO ............................................................................................. 36
AULA - 3. INTRODUÇÃO AOS ALGORITMOS ............................................................................... 38
3.1. O QUE É UM ALGORITMO?.......................................................................................................... 38
3.2. TIPOS DE ALGORITMOS.............................................................................................................. 38
AULA - 4. ELEMENTOS UTILIZADOS NOS ALGORITMOS EM PSEUDOCÓDIGO ................................................ 45
4.1. DECLARAÇÃO DE VARIÁVEIS ..................................................................................................... 46
4.2. ENTRADA E SAÍDA DE DADOS.................................................................................................... 48
4.3. OPERADORES ............................................................................................................................. 48
4.4. TESTE DE MESA .......................................................................................................................... 52
AULA - 5. ESTRUTURAS DE CONTROLE .................................................................................... 56
5.1. ESTRUTURA DE DECISÃO ........................................................................................................... 56
5.2. ESTRUTURAS DE REPETIÇÃO..................................................................................................... 59
AULA - 6. ESTRUTURAS DE DADOS INDEXADAS ....................................................................... 64
6.1. VETORES .................................................................................................................................... 64
6.2. MATRIZES ................................................................................................................................... 66
AULA - 7. SUBPROGRAMAS ...................................................................................................... 68
7.1. CARACTERÍSTICAS GERAIS ....................................................................................................... 68
7.2. PROCEDIMENTOS ....................................................................................................................... 69
7.3. FUNÇÕES .................................................................................................................................... 69
FASE II – LINGUAGEM DE PROGRAMAÇÃO ...................................................................... 70
AULA - 8. INTRODUÇÃO A LINGUAGEM JAVA ............................................................................ 70

8.1. HISTÓRIA .................................................................................................................................... 70
8.2. CARACTERÍSTICAS DO JAVA ................................................................................................................ 71
8.3. TECNOLOGIAS JAVA .......................................................................................................................... 72
AULA - 9. IDE NETBEANS ........................................................................................................ 73
9.1. CRIAÇÃO DO PROJETO .............................................................................................................. 73
9.2. A APLICAÇÃO OLÁ MUNDO! ....................................................................................................... 77
9.3. CRIAÇÃO DA INTERFACE GRÁFICA ............................................................................................ 78
9.4. CRIAÇÃO DOS PROGRAMAS ...................................................................................................... 81
AULA - 10. ELEMENTOS UTILIZADOS NA PROGRAMAÇÃO ....................................................................... 84
10.1. ENTRADA E SAÍDA DE DADOS ................................................................................................. 85
10.2. TIPOS DE DADOS PRIMITIVOS ................................................................................................. 85
10.3. VARIÁVEIS ................................................................................................................................ 86
10.4. ATRIBUIÇÃO .............................................................................................................................. 86
10.5. OPERADORES........................................................................................................................... 88
AULA - 11. ESTRUTURAS DE CONTROLE ............................................................................................. 90
11.1. ESTRUTURA DE SELEÇÃO........................................................................................................ 90
11.2. ESTRUTURAS DE REPETIÇÃO .................................................................................................. 91
AULA - 12. ESTRUTURAS DE DADOS INDEXADAS ..................................................................... 95
12.1. VETORES .................................................................................................................................. 95
12.2. MATRIZES ................................................................................................................................. 96
AULA - 13. SUBPROGRAMAS.................................................................................................... 97
13.1. PROCEDIMENTOS ..................................................................................................................... 97
13.2. FUNÇÕES .................................................................................................................................. 97
FASE III – PROGRAMAÇÃO ORIENTADA A OBJETOS ...................................................................... 99
AULA - 14. ORIENTAÇÃO A OBJETOS ................................................................................................. 99

14.1. INTRODUÇÃO ............................................................................................................................ 99
14.2. HISTÓRICO................................................................................................................................ 99
14.3. FUNDAMENTOS DE ORIENTAÇÃO A OBJETOS ...................................................................... 101
14.4. VAMOS PRATICAR! ................................................................................................................. 108
AULA - 15. ENCAPSULAMENTO .............................................................................................. 108
15.1. O QUE É ENCAPSULAMENTO? ............................................................................................... 108
15.2. MODIFICADORES DE ACESSO................................................................................................ 109
AULA - 16. HERANÇA ............................................................................................................. 112
16.1. O QUE É HERANÇA? ............................................................................................................... 112
16.2. SUPERCLASSE E SUBCLASSE................................................................................................ 112
16.3. HERANÇA MÚLTIPLA ............................................................................................................... 112
16.4. CLASSE OBJECT .................................................................................................................... 112
16.5. VAMOS PRATICAR! ................................................................................................................. 113
AULA - 17. POLIMORFISMO .................................................................................................... 115
17.1. O QUE É POLIMORFISMO?...................................................................................................... 115
17.2. SOBRECARGA DE MÉTODOS .................................................................................................. 117
17.3. CLASSES E MÉTODOS ABSTRATOS ....................................................................................... 118
FASE IV – ANÁLISE DE SISTEMAS .................................................................................... 120
AULA - 18. INTRODUÇÃO A SISTEMAS .................................................................................... 120

18.2. O QUE É UM SISTEMA ............................................................................................................. 122
18.3. COMO CONSTRUIR UM SISTEMA DE INFORMAÇÃO BASEADO EM COMPUTADOR ................ 123
18.4. O PAPEL DO ANALISTA DE SISTEMAS ................................................................................... 124
18.5. FASES DO DESENVOLVIMENTO DE SISTEMAS ....................................................................... 124
AULA - 19. REQUISITOS ......................................................................................................... 128
19.1. INTRODUÇÃO .......................................................................................................................... 128
19.2. LEVANTAMENTO DE REQUISITOS ........................................................................................... 128
19.3. ANÁLISE DE REQUISITOS ....................................................................................................... 129
AULA - 20. UNIFIED MODELING LANGUAGE – UML ................................................................ 131
20.1. O QUE É UML ......................................................................................................................... 131
20.2. DIAGRAMAS UML ................................................................................................................... 132
BIBLIOGRAFIA............................................................................................................................... 137
APÊNDICE A – EXERCÍCIOS PRÁTICOS ......................................................................................... 139
AULA 1 – INTRODUÇÃO A LÓGICA DE PROGRAMAÇÃO ............................................................................ 139

AULA 3 – INTRODUÇÃO AOS ALGORITMOS .......................................................................................... 139
AULA 4 – ELEMENTOS UTILIZADOS NOS ALGORITMOS EM PSEUDOCÓDIGO ................................................. 140
AULA 4 – ELEMENTOS UTILIZADOS NOS ALGORITMOS EM PSEUDOCÓDIGO (TESTE DE MESA) .......................... 140
AULA 5 – ESTRUTURAS DE CONTROLE ................................................................................................ 141
AULA 7 – SUBPROGRAMAS .............................................................................................................. 142
AULA 9 – IDE NETBEANS ................................................................................................................ 144
AULA 11 – ESTRUTURAS DE CONTROLE .............................................................................................. 144
AULA 12 – ESTRUTURAS DE DADOS INDEXADAS ................................................................................... 145
AULA 14 – ORIENTAÇÃO A OBJETOS .................................................................................................. 145
AULA 17 – POLIMORFISMO ............................................................................................................. 146
AULA 20 – UNIFIED MODELING LANGUAGE – UML .............................................................................. 146
Apresentação
O manual apresenta as técnicas de desenvolvimento de algoritmos e a utilização da
linguagem Java para codificação de algoritmos respeitando o paradigma da
orientação a objetos. Apresentamos ainda alguns diagramas da UML usados para
guiar o desenvolvimento de software. Durante toda a disciplina é visto a elaboração
e implementação de diversos algoritmos criados através da elaboração de
fluxogramas e pseudocódigo, bem como a elaboração e leitura dos diagramas de
classes e casos de uso, descritos na UML.
No intuito de deixar claro à (o) professor (a) o que é esperado do aluno ao final da
disciplina, este manual propõe os objetivos de aprendizagem referentes ao tema,
acompanhado do conteúdo de cada disciplina. Disponibiliza uma bibliografia para o
(a) professor (a), subsidiando-o (a) para aprofundar os debates em sala de aula,
bem como, uma bibliografia de referência do Manual.
Elaborado no intuito de qualificar o processo de formação, este Manual é um

instrumento pedagógico que se constitui como um mediador para facilitar o
processo de ensino-aprendizagem em sala de aula.
É importante que o (a) professor (a) compreenda o propósito do método do

curso, e assim, se aproprie do conteúdo e da metodologia proposta por meio das
atividades pedagógicas, fazendo um estudo cuidadoso deste Manual e buscando
aperfeiçoar sua didática para conduzir com sucesso as atividades propostas.
Esperamos contribuir com a consolidação do compromisso e envolvimento de todos

(professores e alunos) na formação desses profissionais.
Competências
Capacitar o aluno no desenvolvimento de aplicações voltadas para o ambiente de redes de
computadores na plataforma Java usando o paradigma de orientação a objetos a partir de
diagramas básicos da UML elaborados por si ou por terceiros.
Objetivos de Aprendizagem
Ao final da disciplina os alunos devem ser capazes de...
 Aplicar os conceitos fundamentais de algoritmos para a solução de problemas
a partir de técnicas de modularização e refinamentos sucessivos.
 Formular algoritmos consistentes em português estruturado.
 Interpretar e avaliar Algoritmos e fluxogramas.
 Desenvolver aplicações com interfaces gráficas em linguagem Java
respeitando o paradigma de orientação a objetos
 Compreender conceitos sobre sistemas de informação.
 Aplicar técnicas para levantamento de requisitos.
 Analisar e conceber requisitos para o desenvolvimento de sistemas.
 Interpretar e elaborar diagramas UML (diagramas de Classes, diagramas de
Sequência e diagramas de Casos de Uso)
Conteúdo Programático
FASE I – LÓGICA DE PROGRAMAÇÃO
Aula - 1. Introdução a Lógica de Programação

1.1. Introdução
1.2. Noções de Lógica
Aula - 2. Conceitos de Programação

2.1. Tipos de Linguagem de Programação
2.2. Paradigmas de Programação
Aula - 3. Introdução aos algoritmos

3.1. O que é um algoritmo?
3.2. Tipos de Algoritmos
Aula - 4. Elementos utilizados nos Algoritmos

4.1. Declaração de Variáveis
4.2. Entrada e Saída de Dados
4.3. Operadores
4.4. Teste de Mesa
Aula - 5. Estruturas de Controle

5.1. Estrutura de Decisão
5.2. Estruturas de Repetição
Aula - 6. Estrutura de Dados Indexada

6.1. Vetor
6.2. Matriz
Aula - 7. Subprogramas
7.1. Características Gerais
7.2. Procedimentos
7.3. Funções
FASE II – LINGUAGEM DE PROGRAMAÇÃO
Aula - 8. Introdução a Linguagem Java

8.1. História
8.2. Características do Java
8.3. Tecnologias Java
Aula - 9. IDE NetBeans

9.1. Criação de Projetos
9.2. A Aplicação Olá Mundo
9.3. Criação de Interfaces Gráfica
9.4. Criação dos Programas
Aula - 10. Elementos Utilizados na Programação

10.2. Tipos de Dados Primitivos
10.3. Variáveis
10.4. Atribuição
10.5. Operadores

11.1. Estrutura de Seleção
Aula - 12. Estruturas de Dados Indexados

12.1. Vetor
12.2. Matriz
Aula - 13. Métodos

13.1. Procedimentos
13.2. Funções
FASE III –PROGRAMAÇÃO ORIENTAD A OBJETOS
Aula - 14. Orientação a Objetos

14.1. Introdução
14.2. Histórico
14.3. Fundamentos de Orientação a Objetos
Aula - 15. Encapsulamento

15.1. O que é encapsulamento
15.2. Modificadores de Acesso
Aula - 16. Herança

16.1. O que é Herança?
16.2. Superclasses e subclasses
16.3. Herança múltipla
16.4. Classe Object
Aula - 17. Polimorfismo

17.1. Conceito de polimorfismo
17.2. Sobrecarga de métodos
17.3. Classes e métodos abstratos
FASE IV - ANÁLISE DE SISTEMAS

Aula - 18. Introdução a Sistemas
18.1. O que é um sistema?
18.2. Como Construir um Sistema Baseado em Computador
18.3. O Papel do Analista de Sistemas
18.4. Fases do Desenvolvimento de Sistemas
Aula - 19. Requisitos

19.1. Introdução
19.2. Levantamento de Requisitos
19.3. Analise de requisitos
Aula - 20. Diagramas UML

20.1. O que é UML?
20.2. Diagramas UML
Ementa
Disciplinas C/H Ano Sem. Pré-Requisito
Análise e Programação 120 1 5 Informática Básica
INTENÇÃO A SER ALCANÇADA

(Apresenta uma competência como sendo o comportamento global esperado)
Capacitar o aluno no desenvolvimento de aplicações voltadas para o ambiente de
redes de computadores na plataforma Java usando o paradigma de orientação a
objetos a partir de diagramas básicos da UML elaborados por si ou por terceiros.
COMPETÊNCIAS
(Descrevem os elementos essenciais da competência na forma de
comportamentos particulares).
 Construir algoritmos consistentes, em português estruturado, para a solução

de problemas a partir de técnicas de modularização e refinamentos
sucessivos, usando os conceitos fundamentais de construção de algoritmos.
 Desenvolver aplicações com interfaces gráficas em linguagem Java
respeitando o paradigma de orientação a objetos
 Interpretar e elaborar Diagramas de Classes e Diagramas de Casos de Uso
descritos pela UML.
FUNDAMENTOS TEÓRICO-PRÁTICOS
(Determinam e orientam as aprendizagens, permitindo a aquisição das
competências de maneira progressiva e por etapas)
FASE 1: Lógica de Programação

 Estruturar a solução de problemas a partir das técnicas de elaboração de
algoritmos.
 Elaborar algoritmos corretos com as estruturas básicas do português
estruturado no ambiente do laboratório de ensino de informática usando a
IDE do Portugol, que permite elaboração de pseudocódigo em português
estruturado e fluxograma.
FASE 2: Linguagem de Programação
 Implementar aplicações na linguagem Java usando ambiente de
programação adequado (IDE NetBeans) no ambiente do laboratório de
ensino de informática
 Modificar algoritmos e programas formulados por outros programadores
 Identificar e corrigir possíveis erros a partir de programas elaborados por
outros programadores
 Identificar linguagem de programação apropriada para desenvolvimento de
aplicações a partir das necessidades do problema
FASE 3: Programação Orientada a Objetos
 Determinar as classes necessárias para a solução a partir das necessidades
identificadas
 Desenvolver aplicações respeitando os princípios da programação orientada
a objetos usando
 Implementar classes encapsuladas em Java
 Criar aplicações usando o conceito de reaproveitamento de código
 Utilizar e implementar métodos polimórficos
FASE 4: Análise
 Identificar processos do mundo real que podem ser mapeados para sistemas
informatizados
 Elaborar as listas de requisitos necessários a um projeto de software, de
acordo com os tipos de requisitos estudados
 Compreender o ciclo de vida do desenvolvimento de software
 Criar diagramas de classes, sequência e casos de uso para documentação de
sistemas
AÇÕES PEDAGÓGICAS
(Os limites a serem respeitados e os meios de aplicação).
 Possibilitar a execução de várias atividades na resolução de problemas com

algoritmos;
 Estimular as iniciativas dos alunos respeitando os acordos estabelecidos
sobre o trabalho a ser efetuado;
 Assegurar o acompanhamento periódico dos alunos;
 Intervir em casos de dificuldades ou de problemas;
 Guiar o processo de avaliação dos alunos fornecendo instrumentos tais como
questionário, grades de análise, estudo de casos, etc;
 Motivar os alunos a executar as atividades propostas;
 Fornecer aos alunos meio de avaliar suas capacidades de construir
algoritmos;
 Assegurar a disponibilidade da documentação pertinente: conceitos
elementares da lógica;
 Permitir aos alunos a terem trocas entre eles sobre dificuldades e soluções
encontradas;
 Procurar integrar os conhecimentos adquiridos na elaboração de algoritmos
para resolução de problemas;
CRITÉRIOS DE PARTICIPAÇÃO
(Exigências da participação que os alunos e alunas devem respeitar durante a
aprendizagem).
FASE 1: Lógica de Programação

 Identificar corretamente entradas e saídas dos problemas
 Apresentar compreensão clara sobre elaboração de algoritmos
 Explicar algoritmos elaborados
 Opinar com coerência no momento das discussões
 Construir algoritmos corretos para resolução de problemas
 Corrigir algoritmos elaborados por outras pessoas do grupo
FASE 2: Linguagem de Programação
 Construir interfaces na IDE NetBeans usando componentes
 Elaborar programas usando conceitos básicos de programação
 Corrigir erros de sintaxe da linguagem Java
FASE 3: Programação Orientada a Objetos
 Comparar programas elaborados por outras pessoas do grupo;
 Exemplificar corretamente classes e objetos
 Implementar corretamente o classes, com seus atributos e métodos, usando
encapsulamento na linguagem Java
 Exemplificar situações de aplicação do conceito de herança
FASE 4: Análise
 Identificar requisitos para sistema proposto
 Identificar corretamente elementos em diagramas exibidos
 Analisar diagramas elaborados por outras pessoas do grupo
 Corrigir erros em diagramas propostos
 Elaboração de diagramas de acordo situações problema
QUADRO RESUMO DAS COMPETÊNCIAS:

COMPETÊNCIA 01 CONTEXTO DE REALIZAÇÃO
A partir de:
Construir algoritmos consistentes em Utilizando: Portugol IDE
português estruturado, a partir de
técnicas de modularização e Com a ajuda de: Livros, apostilas,
refinamentos sucessivos, usando os anotações no caderno e orientações
conceitos fundamentais de construção do professor.
de algoritmos.
Ambiente: Laboratório de Ensino de
Informática
ELEMENTOS DA COMPETÊNCIA CRITÉRIOS DE DESEMPENHO

1.1. Identificar corretamente
entradas e saídas dos problemas
1. Estruturar a solução de problemas
1.2. Apresentar compreensão clara
a partir das técnicas de
sobre elaboração de algoritmos
elaboração de algoritmos.
1.3. Opinar com coerência no
momento das discussões
2.1. Explicar algoritmos elaborados
2. Elaborar algoritmos corretos com 2.2. Construir algoritmos corretos
as estruturas básicas do para resolução de problemas
português estruturado. 2.3. Corrigir algoritmos elaborados
por outras pessoas do grupo

A partir de:
Utilizando: NetBeans IDE

Desenvolver aplicações com
interfaces gráficas em linguagem Java Com a ajuda de: Livros, apostilas,
respeitando o paradigma de anotações no caderno e orientações
orientação a objetos. do professor.

Informática

1. Construir interfaces na IDE 1.1. Construir interfaces na IDE
NetBeans usando componentes NetBeans usando componentes
2. Elaborar programas usando 2.1. Elaborar programas usando
conceitos básicos de conceitos básicos de programação
programação
3. Corrigir erros de sintaxe da 3.1. Corrigir erros de sintaxe da
linguagem Java linguagem Java.

A partir de: Estudo de Casos
Utilizando: UML2 – plug in do

Eclipse; UMLet
Interpretar e elaborar Diagramas de
Classes e Diagramas de Casos de Com a ajuda de: Livros, apostilas,
Uso descritos pela UML. anotações no caderno e orientações
do professor.

Informática

1.1. Determinar corretamente a
sequência de passos de um
1. Identificar processos do mundo processo
real que podem ser mapeados 1.2. Relacionar corretamente
para sistemas informatizados processos do mundo real que
podem ser mapeados no mundo
computacional
2. Analisar e elaborar conjunto de
requisitos necessários a um
2.1. Identificar requisitos para
projeto de software, de acordo
sistema proposto
com os tipos de requisitos
estudados
3. Compreender o ciclo de vida do 3.1. Descrever corretamente as
desenvolvimento de software etapas necessárias ao
desenvolvimento de um softeware
4.1. Identificar corretamente
elementos em diagramas exibidos
4.2. Analisar diagramas elaborados
4. Criar diagramas de classes e
por outras pessoas do grupo
casos de uso para documentação
4.3. Corrigir erros em diagramas
de sistemas
propostos
4.4. Elaboração de diagramas de
acordo situações problema
Cronograma de Atividades
Aula Núcleo de Conteúdos Descrição
Fase I - Lógica de Programação

Plano de ensino, método de trabalho, bibliografia e formas de
Apresentação da disciplina. avaliação.
Introdução
1ª.Aula Introdução a Lógica de Programação Noções de lógica
Exercício prático
Tipos de Linguagens de programação
2ª.Aula Conceitos de Programação.
Paradigmas de Programação
O que é um algoritmo?
3ª.Aula Introdução aos Algoritmos
Tipos de Algoritmos
Declaração de Variáveis
Entrada e Saída de Dados
4ª.
Elementos utilizados nos algoritmos Operadores
Aula
Teste de mesa
Exercício prático
Estrutura de Decisão
Exercício prático
5ª.Aula Estruturas de Controle.
Estruturas de repetição
Exercício prático
Vetores
6ª.Aula Estrutura de Dados Indexada Matrizes
Exercício prático
Características Gerais
Procedimentos
7ª.Aula Subprogramas
Funções
Exercício prático
Avaliação de Competências
Intervenção Pedagógica
Fase II - Linguagem de Programação
História
8ª.Aula Introdução a linguagem java Características do JAVA
Tecnologias Java
Criação do Projeto
Aplcação Olá Mundo
9ª.Aula IDE Netbeans. Criação da Interface Gráfica
Criação dos Programas
Exercício prático
Entrda e Saída de Dados
Tipos de Dados Primitivos
Variáveis
10ª.Aula Elementos utilizados na Programação
Atribuição
Operadores aritimeticos, Lógicos e relacionais
Exercício prático
Estrutura de Seleção
Exercício prático
11ª.Aula Estruturas de Controle
Estruturas de Repetição
Exercício prático
Vetores
12ª.Aula Vetores e Matrizes Matrizes
Exercício prático
13ª.Aula Subprogramas Procedimentos
Funções
Exercício prático
Fase III - Programação Orientada a Objetos
Introdução
14ª.Aula Orientação a Objetos Histórico
Fundamentos de Orientação a Objetos
O que é encapsulamento
15ª.Aula Encapsulamento
Modificadores de Acesso
O que é Herança
Superclasses e subclasses
16ª.Aula Herança
Herança múltipla
Classe Object
O que é Polimorfismo
17ª.Aula Polimorfismo Sobrecarga de métodos
Classes e métodos abstratos
Fase IV – Análise de Sistemas
O que é um sistema?
Como Construir um Sistema de Informação Baseado em
18ª.Aula Introdução a sistemas Computador
O Papel do Analista de Sistemas
Fases do Desenvolvimento de Sistemas
Introdução
Levantamento de Requisitos
19ª.Aula Requisitos Análise de requisitos
Exercício prático - pesquisar sobre sistemas e elaborar os
requisitos do sistema pesquisado.
O que é UML
Diagramas UML
Exercício prático - os alunos devem apresentar a proposta
20ª.Aula Diagramas UML de um sistema que eles pretendem desenvolver utilizando os
conhecimentos adquiridos e como produto apresentar os
diagramas estudados para o sistema proposto.
Aula Núcleo de Conteúdos Descrição

FASE I – Lógica de Programação
Plano de ensino, método de trabalho, bibliografia e formas de
1ª.Aula Apresentação da disciplina. avaliação.
Noções de lógica
Raciocinio lógico
2ª.Aula Introdução a Lógica de Programação.
Exercicio pratico - problemas lógicos com palitos de fósforo,
testes lógicos da Coquetel etc
O que é um algoritmo?
Algoritmos usados na resolução de problemas.
Tipos de Algoritimo
Pseudocódigo (mostrar exemplos, construir junto com os
3ª.Aula Introdução aos Algoritmos. alunos)
Exercicio prático - elaboração de pseudocódigo para
problemas não computacionais como a receita de bolo ou a
troca de pneu, para explorar a compreensão por parte do
aluno.
Linguagem de Baixo nível e de Alto nível.
Linguagems de programação.
4ª.Aula Conceitos de Programação.
Tipos de Linguagens de programação (Conceitos sobre
programação Linear, Estruturada, orientada a objetos)
Variáveis
Constantes
5ª.Aula
Atribuição
Operadores aritimeticos, Lógicos e relacionais
Elementos utilizados nos algoritmos Teste de mesa
Exercício prático - elaborar algoritmos em pseudocódigo
com problemas usando fórmulas matemáticos (integração
6ª.Aula com a base comum). Implementar usando Portugol
Estrutura de Seleção - Decisão Simples

Estrutura de Seleção - Decisão Composta
Estrutura de Seleção - Decisão Encadeada
7ª.Aula Estruturas de Controle. Estrutura de Seleção - Mútipla Escolha
Exercício prático
Exercício prático
Vetores
8ª.Aula Estrutura de Dados Indexada Matrizes
Exercício prático
Parâmetros
Retorno
9ª.Aula Subprogramas
Procedimentos e Funções
Exercício prático
10ª.Aula Intervenção Pedagógica
11ª.Aula Avaliação da Fase
FASE II – Linguagem de Programação
História, Tecnologias da linguagem
JVM -JRE –JDK
Bytecode
12ª.Aula Introdução a linguagem Java javac (compilador)
java (interpretador)
Características do JAVA
Erros de sintaxe e de runtime
Criação de Projetos, Plugins,
Plataformas
13ª.Aula IDE Netbeans. Visão geral dos componentes Swing
Exercício prático
Variáveis
Constantes
14ª.Aula Elementos utilizados em Programação Atribuição
Casting
Operadores aritimeticos, Lógicos e
relacionais
Estrutura de Seleção(Decisão,
Simples,composta, encadeada, Múltipla
escolha) - Exercicio pratico.
15ª.Aula Estruturas de Controle. Exercício prático
Exercício prático
Vetores e Matrizes Classe Array
16ª.Aula Declarando e criando arrays
Exercício prático
FASE III – Programação Orientada a Objetos
Histórico da orientação a objetos
19ª.Aula Introdução a orientação a Objetos
Linguagens orientadas a objetos
Classes vs Objetos
Modificadores de Acesso de Objetos
Variáveis de instâncias
20ª.Aula Introdução a Classes e objetos
Construtores (inicializando objetos com
construtores)
Exercício Prático
O que é encapsulamento
21ª.Aula Encapsulamento
Métodos get e set
Conceito de herança
Superclasses e subclasses
22ª.Aula Herança
Herança múltipla
Classe Object
Conceito de polimorfismo
Sobrecarga de métodos
23ª.Aula Polimorfismo
Classes e métodos abstratos
Interface
FASE IV – Análise
O que é um sistema?
Sistemas de Informação e seus tipos.
Fases da concepção de sistemas de
26ª.Aula Introdução a sistemas informação.
Procedimentos operacionais passíveis
de sistematização (Mostrar aos alunos
procedimentos manuais como alguns
formulários e como ele fica após a
informatização do processo.)
Estudo de viabilidade
Técnicas de entrevistas e
levantamentos de necessidades
Analise de requisitos
27ª.Aula Requisitos
Requisitos funcionais e Não funcionais
Requisitos do usuário
Requisitos do sistema
Exercício prático
Elaboração de diagrama de classes
Elaboração de diagrama de casos de
28ª.Aula Diagramas UML uso
Exercício prático
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Conteúdos Interdisciplinares
BASE TÉCNICA:
 Fórmulas matemática
 Operadores relacionais
 Proposições lógicas
 Conceitos de estrutura lógica
 Conceitos de variáveis
 Técnicas para resolução de problemas (Top down, dividir pra conquistar etc)
DISCIPLINAS CONTRIBUTIVAS:
FILOSOFIA: Lógica aristotélica, abstração, eficiência e eficácia
MATEMÁTICA: Lógica matemática (proposições lógicas, tabelas verdade e álgebra de

Boole), situações, expressões matemáticas (equações e inequações), funções
(domínio, contra-domínio e imagem), substituição de variáveis em equações,
constantes, sequência, finitude e matrizes
PORTUGUÊS: Leitura e interpretação de texto
Redes de Computadores – Análise e Programação 25

Mapa de Análise de Avaliação

ESCOLA:
DISCIPLINA: Análise e Programação SÉRIE: 1º ANO
N NOME COMP I COMP II COMP III COMP IV
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

Legendas para o Mapa de Analise

de Avaliação
O Aluno já passou por uma avaliação
ED – Em desenvolvimento de competência, e ainda não foi
satisfatório em alguma das habilidades.
O Aluno passou pela a avaliação de

competência e teve um resultado
MB – Muito Bom muito bom, este esta no nível
intermediário a Avançado.
O Aluno passou pela a avaliação de

B – Básico competência e teve um resultado bom,
este esta no nível básico.
Quando a aluno não esta conseguindo

MC – Muito Critico adquirir os elementos da competência.
Significa que o aluno não passou por

Campo Vazio uma avaliação de competência.

Referências Bibliográficas
1. Antonio Manso, Célio Marques, Pedro Dias. http://www.dei.estt.ipt.pt/portugol.

s.l. : Instituto Politécnico de Tomar.
2. Caelum Ensino e Inovação. Java e Orientação a Objetos. [www.caelum.com - 10/05/2012]. São Paulo,
São Paulo, Brasil : www.caelum.com, 10 de 05 de 2012.
3. Wikipedia. Java (linguagem de progração).

[http://pt.wikipedia.org/wiki/Java_%28linguagem_de_programa%C3%A7%C3%A3o%29 – 10/05/2012]
2012.
4. School of Information System. Java Virtual Machine.

[https://wiki.smu.edu.sg/is200/Java_Virtual_Machine - 09/05/2012] s.l. : Singapore Management
University.
5. Wikipedia. Java Runtime Environment. [http://pt.wikipedia.org/wiki/Jre – 11/05/2012] 2011.
6. —. Java Development Kit. [http://pt.wikipedia.org/wiki/Jre – Em: 11/05/2012] 2011. a.
7. Kathy Sierra, Bert Bates. Use a Cabeça - Java. Rio de Janeiro : O'Reilly, 2005.
8. ScriBD. Desenvolvimento de Software Orientado a Objetos.

[http://pt.scribd.com/doc/56735259/2/Desenvolvimento-de-Softwares-orientado-a-objetos]
01/06/2012.
9. DAVENPORT, T H e PRUSAK, L. Conhecimento empresarial. Rio de Janeiro : Campus, 1988.
10. Balagtas, Florence Tiu. Projeto J.E.D.I. Students Manual. s.l. :

http://edu.netbeans.org/contrib/jedi/Intro-to-Programming-1/student-manual.pdf, 2006.
11. de Souza, Marcos Antônio Furlan e Goncílio, Marcelo Marques. Algoritmos e Lógica de
Programação. s.l. : Thomson.
12. Deitel, Harvey M. e Deitel, Paul J. Java como Programar 8ª Ed. s.l. : Pearson.
13. Ascencio, Ana Fernanda Gomes e Ven, Edilene Aparecida. Fundamentos da Programação de
Computadores – Algoritmos, Pascal, C/C++, JAVA 2 Edição. s.l. : Pearson Prentice Hall.
14. Forbellone, André Luiz Villar. Lógica de Programação – A Construção de Algoritmos e Estruturas de
Dados. São Paulo : Makron, 1993.
15. Puga, Sandra e Rissetti, Gerson. Lógica de Programação e Estruturas de Dados. s.l. : Pearson.
16. Lingagem de Modelagem Unificada. S.l.: s.n. : [http://apostilando.net.br/swf/2038.swf], junho de

2012.
17. Evolução Educação e Tecnologia. Orientação a Objetos com Java. [www.evolucao.com.br – junho de
2012].

Sumário da Apostila
FASE I : LÓGICA DE PROGRAMAÇÃO 32
AULA - 1. INTRODUÇÃO A LÓGICA DE PROGRAMAÇÃO 32

1.1. INTRODUÇÃO 32
1.2. NOÇÕES DE LÓGICA 32
AULA - 2. CONCEITOS DE PROGRAMAÇÃO 34
2.1. TIPOS DE LINGUAGENS DE PROGRAMAÇÃO 34
2.2. PARADIGMAS DE PROGRAMAÇÃO 36
AULA - 3. INTRODUÇÃO AOS ALGORITMOS 38
3.1. O QUE É UM ALGORITMO? 38
3.2. TIPOS DE ALGORITMOS 38
AULA - 4. ELEMENTOS UTILIZADOS NOS ALGORITMOS EM PSEUDOCÓDIGO 45
4.1. DECLARAÇÃO DE VARIÁVEIS 46
4.2. ENTRADA E SAÍDA DE DADOS 48
4.3. OPERADORES 48
4.4. TESTE DE MESA 52
AULA - 5. ESTRUTURAS DE CONTROLE 56
5.1. ESTRUTURA DE DECISÃO 56
5.2. ESTRUTURAS DE REPETIÇÃO 59
AULA - 6. ESTRUTURAS DE DADOS INDEXADAS 64
6.1. VETORES 64
6.2. MATRIZES 66
AULA - 7. SUBPROGRAMAS 68
7.1. CARACTERÍSTICAS GERAIS 68
7.2. PROCEDIMENTOS 69
7.3. FUNÇÕES 69
FASE II – LINGUAGEM DE PROGRAMAÇÃO 70
AULA - 8. INTRODUÇÃO A LINGUAGEM JAVA 70

8.1. HISTÓRIA 70
8.2. CARACTERÍSTICAS DO JAVA 71
8.3. TECNOLOGIAS JAVA 72
AULA - 9. IDE NETBEANS 73
9.1. CRIAÇÃO DO PROJETO 73
9.2. A APLICAÇÃO OLÁ MUNDO! 77
9.3. CRIAÇÃO DA INTERFACE GRÁFICA 78
9.4. CRIAÇÃO DOS PROGRAMAS 81
AULA - 10. ELEMENTOS UTILIZADOS NA PROGRAMAÇÃO 84
10.1. ENTRADA E SAÍDA DE DADOS 85
10.2. TIPOS DE DADOS PRIMITIVOS 85
10.3. VARIÁVEIS 86
10.4. ATRIBUIÇÃO 86
10.5. OPERADORES 88
AULA - 11. ESTRUTURAS DE CONTROLE 90
11.1. ESTRUTURA DE SELEÇÃO 90
11.2. ESTRUTURAS DE REPETIÇÃO 91
AULA - 12. ESTRUTURAS DE DADOS INDEXADAS 95
12.1. VETORES 95
12.2. MATRIZES 96
AULA - 13. SUBPROGRAMAS 97
13.1. PROCEDIMENTOS 97
13.2. FUNÇÕES 97
FASE III – PROGRAMAÇÃO ORIENTADA A OBJETOS 99
AULA - 14. ORIENTAÇÃO A OBJETOS 99

14.2. HISTÓRICO 99
14.3. FUNDAMENTOS DE ORIENTAÇÃO A OBJETOS 101
14.4. VAMOS PRATICAR! 108
AULA - 15. ENCAPSULAMENTO 108
15.1. O QUE É ENCAPSULAMENTO? 108
15.2. MODIFICADORES DE ACESSO 109
AULA - 16. HERANÇA 112
16.1. O QUE É HERANÇA? 112
16.2. SUPERCLASSE E SUBCLASSE 112
16.3. HERANÇA MÚLTIPLA 112
16.4. CLASSE OBJECT 112
AULA - 17. POLIMORFISMO 115
17.1. O QUE É POLIMORFISMO? 115
17.2. SOBRECARGA DE MÉTODOS 117
17.3. CLASSES E MÉTODOS ABSTRATOS 118
FASE IV – ANÁLISE DE SISTEMAS 120
AULA - 18. INTRODUÇÃO A SISTEMAS 120

18.2. O QUE É UM SISTEMA 122
18.3. COMO CONSTRUIR UM SISTEMA DE INFORMAÇÃO BASEADO EM COMPUTADOR 123
18.4. O PAPEL DO ANALISTA DE SISTEMAS 124
18.5. FASES DO DESENVOLVIMENTO DE SISTEMAS 124
AULA - 19. REQUISITOS 128
19.2. LEVANTAMENTO DE REQUISITOS 128
19.3. ANÁLISE DE REQUISITOS 129
AULA - 20. UNIFIED MODELING LANGUAGE – UML 131
20.1. O QUE É UML 131
20.2. DIAGRAMAS UML 132
BIBLIOGRAFIA 137

APÊNDICE A – EXERCÍCIOS PRÁTICOS 139
AULA 1 – INTRODUÇÃO A LÓGICA DE PROGRAMAÇÃO 139

AULA 3 – INTRODUÇÃO AOS ALGORITMOS 139
AULA 4 – ELEMENTOS UTILIZADOS NOS ALGORITMOS EM PSEUDOCÓDIGO 140
AULA 4 – ELEMENTOS UTILIZADOS NOS ALGORITMOS EM PSEUDOCÓDIGO (TESTE DE MESA) 140
AULA 5 – ESTRUTURAS DE CONTROLE 141
AULA 7 – SUBPROGRAMAS 142
AULA 9 – IDE NETBEANS 144
AULA 11 – ESTRUTURAS DE CONTROLE 144
AULA 12 – ESTRUTURAS DE DADOS INDEXADAS 145
AULA 14 – ORIENTAÇÃO A OBJETOS 145
AULA 17 – POLIMORFISMO 146
AULA 20 – UNIFIED MODELING LANGUAGE – UML 146

FASE I : LÓGICA DE PROGRAMAÇÃO
Aula - 1. Introdução a Lógica de Programação
1.1. Introdução
Programar é como escrever um texto para que se possa escrever corretamente você
primeiramente pensa e analisa o vocabulário depois inicia o procedimento de escrever
colocando cada palavra no seu devido lugar e usando a sintaxe correta, no mundo da
programação é de extrema importância à lógica, pois através dela adquirimos a
capacidade de escrever programas em qualquer linguagem de programação, é isso
mesmo o que muda de uma linguagem para outra é a sintaxe.
Para produzir programas é necessário que o programador seja treinado em modelagem

de problemas, o que envolve um refinamento da sua foram de abstrair suas soluções,
bem como representar com estas soluções com o uso da lógica.
Adotaremos o software Portugol IDE para trabalhar com pseudocódigo (portugol) e a

linguagem de programação Java usando a ide do NetBeans.
1.2. Noções de Lógica
Nesta disciplina, iniciaremos nossos estudos sobre Lógica de Programação. Mas, antes
de começarmos, seria útil uma reflexão sobre o significado da palavra “Lógica”. Assim,
o que é Lógica?
De acordo com a filosofia a lógica procura compreender a forma como pensamos, do

ponto de vista técnico nos ensina a usar as leis do pensamento de forma correta.
O filósofo grego Aristóteles é considerado o criador da lógica, em sua época

denominava-se razão, depois que a palavra lógica começou a ser utilizada, esta tem
origem do grego logos que significa linguagem racional.
Enfim, lógica é ciência que coloca a cabeça para funcionar corretamente.
Para chegarmos à conclusão de algo utilizamos as premissas, que são conhecimentos

prévios, desta forma organizamos o pensamento, com a organização do mesmo é que
concluímos se algo é verdadeiro ou falso.
Utilizamos a lógica de forma natural em nosso dia-a-dia. Por exemplo:
a) Sei que o dinheiro está na bolsa
Sei que a bolsa está fechada
Logo, concluo que preciso abrir a bolsa pra retirar o dinheiro

Vamos observar neste exemplo as premissas e os pontos os quais levam a conclusão

deste fato.
1ª. (premissa) Sei que o A está no B.
2ª. (premissa) Sei que o B está fechado.
3ª. (conclusão) Logo, concluo que tenho de abrir a B para retirar o A.
Sendo A o dinheiro ou qualquer outra coisa que tenho que pegar em B(bolsa), tenho o
conhecimento prévio de que o que quero pegar está na bolsa e a mesma encontra-se
fechada.
Neste exemplo do dia-a-dia tenho duas premissas que através delas chego a uma
conclusão.
Exercício Prático

Aula - 2. Conceitos de Programação
A arte de programar exige do programador um exercício contínuo da aplicação da

lógica aos problemas que se propõe a resolver. Uma vez a lógica da solução esteja
defnida, deve-se implementar a olução em uma linguagem de programalção que,
embora siga, em linhas gerais a mesma filosofia, precisa ser mais rigorosa em sua
sintaxe para que identifique corretamente o que se deseja. A seguir falaremos sobre as
linguagens de programação.
2.1. Tipos de linguagens de programação
2.1.1. Linguagens de Baixo Nível
São linguagens totalmente dependentes da máquina, ou seja, o programa que utiliza

este tipo de linguagem não pode ser migrado ou utilizado em outras máquinas. Ao
estar praticamente desenhado para aquele hardware, aproveitam ao máximo as
características do mesmo.
Dentro deste grupo se encontram:
A linguagem máquina: esta linguagem ordena à máquina as operações fundamentais

para seu funcionamento. Consiste na combinação de 0's e 1's para formar as ordens
entendíveis pelo hardware da máquina.
Esta linguagem é muito mais rápida que as linguagens de alto nível.
A desvantagem é que são bastante difíceis de manejar e usar, além de ter códigos
fonte enormes onde encontrar uma falha é quase impossível.
A linguagem Assembler é um derivado da linguagem máquina e está formada por

abreviaturas de letras e números chamados mnemotécnicos. Com o aparecimento
desta linguagem se criaram os programas tradutores para poder passar os programas
escritos em linguagem assembler à linguagem de máquina. Como vantagem com
respeito ao código máquina é que os códigos fontes eram mais curtos e os programas
criados ocupavam menos memória. As desvantagens desta linguagem continuam
sendo praticamente as mesmas que as da linguagem assembler, acrescentando a
dificuldade de ter que aprender uma nova linguagem difícil de provar e manter.
2.1.2. Linguagens de Alto Nível
São aquelas que se encontram mais próximas à linguagem natural do que à linguagem
de máquina. Estão dirigidas a solucionar problemas mediante o uso de EDD's.
Nota: EDD's são as abreviaturas de Estruturas Dinâmicas de Dados, algo muito

utilizado em todas as linguagens de programação. São estruturas que podem
mudar de tamanho durante a execução do programa. Permitem-nos criar estruturas
de dados que se adaptem às necessidades reais de um programa.

Trata-se de linguagens independentes da arquitetura do computador. Sendo assim, a

princípio, um programa escrito em uma linguagem de alto nível, pode ser migrado de
uma máquina a outra sem nenhum tipo de problema.
Estas linguagens permitem ao programador se esquecer completamente do

funcionamento interno da máquina/s para a que está desenhando o programa.
Somente necessita de um tradutor que entenda o código fonte como as características
da máquina.
Costumam usar tipos de dados para a programação e existem linguagens de propósito

geral (qualquer tipo de aplicação) e de propósito específico (como FORTRAN para
trabalhos científicos).
2.1.3. Linguagens de Médio nível
Trata-se de um termo não aceito por todos, porém certamente vocês já devem ter
escutado. Estas linguagens se encontram em um ponto médio entre as duas
anteriores. Dentro destas linguagens poderia se situar C já que pode acessar aos
registros do sistema, trabalhar com endereços de memória, todas elas características
de linguagens de baixo nível e ao mesmo tempo realizar operações de alto nível.
Gerações
A evolução das linguagens de programação pode ser dividida em cinco etapas ou

gerações.
PRIMEIRA GERAÇÃO: Linguagem máquina.
SEGUNDA GERAÇÃO: Criaram-se as primeiras linguagens assembler.
TERCEIRA GERAÇÃO: Criam-se as primeiras linguagens de alto nível. Ex: C, Pascal,

Cobol etc.
QUARTA GERAÇÃO: São linguagens capazes de gerar código por si só, são os
chamados RAD, com o qual pode-se realizar aplicações sem ser um expert na
linguagem. Aqui também se encontram as linguagens orientadas a objetos, tornando
possível a reutilização de partes do código para outros programas. Ex: Visual, Natural
Adabes…
QUINTA GERAÇÃO: Aqui se encontram as linguagens orientadas à inteligência

artificial. Estas linguagens ainda estão pouco desenvolvidas. Ex: LISP.
2.1.4. Linguagens de Programação
Uma linguagem de programação é um método padronizado para expressar instruções

para um computador. É um conjunto de regras sintáticas e semânticas usadas para
definir um programa de computador. Permite que um programador especifique
precisamente sobre quais dados um computador vai atuar, como estes dados serão

armazenados ou transmitidos e quais ações devem ser tomadas sobre várias

circunstâncias.
O conjunto de palavras (tokens), compostos de acordo com essas regras, constitui o

código fonte de um software. Esse código fonte é depois traduzido para código de
máquina, que é executado pelo processador.
Uma das principais metas das linguagens de programação é permitir que

programadores tenham uma maior produtividade, permitindo expressar suas intenções
mais facilmente do que quando comparado com a linguagem que um computador
entende nativamente (código de máquina). Assim, linguagens de programação são
projetadas para adotar uma sintaxe de nível mais alto, que pode ser mais facilmente
entendida por programadores humanos. Linguagens de programação são ferramentas
importantes para que programadores e engenheiros de software possam escrever
programas mais organizados e com maior rapidez.
Linguagens de programação também tornam os programas menos dependentes de

computadores ou ambientes computacionais específicos (propriedade chamada de
portabilidade). Isto acontece porque programas escritos em linguagens de
programação são traduzidos para o código de máquina do computador no qual será
executado em vez de ser diretamente executado. Uma meta ambiciosa do Fortran, uma
das primeiras linguagens de programação, era esta independência da máquina onde
seria executada.
2.2. Paradigmas de Programação
2.2.1. Programação linear
Em matemática, problemas de Programação Linear são problemas de otimização nos

quais a função objetivo e as restrições são todas lineares. Muitos problemas práticos
em pesquisa operacional podem ser expressos como problemas de programação
linear. Certos casos especiais de programação linear, tais como problemas de network
flow e problemas de multicommodity flow são considerados importantes o suficiente
para que se tenha gerado muita pesquisa em algoritmos especializados para suas
soluções. Vários algoritmos para outros tipos de problemas de otimização funcionam
resolvendo problemas de PL como sub-problemas. Historicamente, idéias da
programação linear inspiraram muitos dos conceitos centrais de teoria da otimização,
tais como dualidade, decomposição, e a importância da convexidade e suas
generalizações.
2.2.2. Programação modular
Programação modular é um paradigma de programação no qual o desenvolvimento

das rotinas de programação é feito através de módulos, que são interligados entre si
através de uma interface comum. Foi apresentado originalmente pela Information &
Systems Institute, Inc. no National Symposium on Modular Programming em 1968, com
a liderança de Larry Constantine.

2.2.3. Programação estruturada
Programação estruturada é uma forma de programação de computadores que

preconiza que todos os programas possíveis podem ser reduzidos a apenas três
estruturas: sequência, decisão e repetição. Tendo, na prática, sido transformada na
Programação modular, a Programação estruturada orienta os programadores para a
criação de estruturas simples em seus programas, usando as sub-rotinas e as funções.
Foi à forma dominante na criação de software entre a programação linear e a
programação orientada por objetos. Apesar de ter sido sucedida pela programação
orientada por objetos, pode-se dizer que a programação estruturada ainda é
marcantemente influente, uma vez que grande parte das pessoas ainda aprende
programação através dela. Porém, a orientação a objetos superou o uso das
linguagens estruturadas no mercado.
2.2.4. Programação orientada a objetos
Orientação a objetos, também conhecida como Programação Orientada a Objetos

(POO) ou ainda em inglês Object-Oriented Programming (OOP) é um paradigma de
análise, projeto e programação de sistemas de software baseado na composição e
interação entre diversas unidades de software chamadas de objetos.
Em alguns contextos, prefere-se usar modelagem orientada ao objeto, em vez de

programação. De fato, o paradigma "orientação a objetos" tem bases conceituais e
origem no campo de estudo da cognição, que influenciou a área de inteligência artificial
e da linguística no campo da abstração de conceitos do mundo real.
Na qualidade de método de modelagem, é tida como a melhor estratégia, e mais

natural, para se eliminar o "gap semântico", dificuldade recorrente no processo de
modelar o mundo real, no domínio do problema, em um conjunto de componentes de
software que seja o mais fiel na sua representação deste domínio. Facilitaria a
comunicação do profissional modelador e do usuário da área alvo, na medida em que a
correlação da simbologia e conceitos abstratos do mundo real e da ferramenta de
modelagem (conceitos, terminologia, símbolos, grafismo e estratégias) fosse a mais
óbvia, natural e exata possível.
A análise e projeto orientados a objetos têm como meta identificar o melhor conjunto de
objetos para descrever um sistema de software. O funcionamento deste sistema se dá
através do relacionamento e troca de mensagens entre estes objetos. Na programação
orientada a objetos, implementa-se um conjunto de classes que definem os objetos
presentes no sistema de software. Cada classe determina o comportamento (definido
nos métodos) e estados possíveis (atributos) de seus objetos, assim como o
relacionamento com outros objetos.

Aula - 3. Introdução aos Algoritmos
3.1. O que é um algoritmo?
É o passo que antecede a programação. Um algoritmo é formalmente uma seqência

finita de passos que levam a execução de uma tarefa. Podemos pensar em algoritmo
como uma receita, uma sequência de instruções que dão cabo de uma meta
específica. Estas tarefas não podem ser redundantes nem subjetivas na sua definição,
devem ser claras e precisas.
Como exemplos de algoritmos podemos citar os algoritmos das operações básicas

(adição, multiplicação, divisão e subtração) de números reais decimais. Outros
exemplos seriam os manuais de aparelhos eletrônicos, como um celular, que explicam
passo-a-passo como, por exemplo, inserir um contato na agenda.
Até mesmo as coisas mais simples, podem ser descritas por sequências lógicas. Por
exemplo:
“Chupar uma bala”.

1. Pegar a bala.
2. Retirar o papel.
3. Chupar a bala.
4. Jogar o papel no lixo.
Exercício Prático
3.2. Tipos de Algoritmos
Os tipos de algoritmos mais usados são descrição narrativa, fluxograma e

Pseudocódigo ou portugol, agora vamos conhecer um pouco destes tipos e nos
próximos tópicos nos aprofundarmos.
 Descrição narrativa
 Utiliza linguagem natural;
 Vantagem: Não é necessário aprender nenhum conceito novo, é como
estivéssemos falando ou escrevendo os detalhes de algo para outra pessoa.
 Desvantagem: Permite várias interpretações, dificultando transcrição para
programa.
 Exemplo
Ler dois números e calcular a média
1 Ler os dois números.

2 Calcular a média.
3 Mostrar o resultado da média.
 Fluxograma
 Utiliza elementos gráficos.

 Vantagem: Entendimento de gráficos é mais fácil que de textos.

 Desvantagem: Necessário aprender simbologia e não apresenta detalhes
para transcrever para programa.
 Pseudocódigo ou Portugol.
 Utiliza uma linguagem com regras definidas com uma estrutura formal.
Também conhecido como português estruturado.
 Vantagem: Transcrição para programa (linguagem de computador) é
praticamente imediata.
 Desvantagem: Necessário aprender regras.
Imagine o seguinte problema: Calcular a média final dos alunos da 3ª Série. Os alunos
realizarão quatro provas: P1, P2, P3 e P4.
Onde:
Para montar o algoritmo proposto, faremos três perguntas:
a) Quais são os dados de entrada?
R: Os dados de entrada são P1, P2, P3 e P4
b) Qual será o processamento a ser utilizado?
R: O procedimento será somar todos os dados de entrada e dividi-los por 4 (quatro)
c) Quais serão os dados de saída?
R: O dado de saída será a média final
ALGORITMO (SEQUÊNCIA DE EXECUÇÃO)
Receba a nota da prova1.
Receba a nota de prova2.
Receba a nota de prova3.
Receba a nota da prova4.
Some todas as notas e divida o resultado por 4.
Mostre o resultado da divisão.

Para construção de um algoritmo são necessários os passos descritos a seguir:
1. Ler atentamente o enunciado, destacando os pontos mais importantes;

2. Definir os dados de entrada, ou seja, quais dados serão fornecidos;
3. Definir o processamento, ou seja, quais cálculos serão efetuados e quais as restrições
para esses cálculos. O processamento é responsável pela transformação dos dados de
entrada em dados de saídas;
4. Definir os dados de saídas, ou seja, quais dados serão gerados depois
do processamento;
5. Construir o algoritmo utilizando um dos tipos descritos;
6. Testar o algoritmo utilizando as informações.
3.2.1. Descrição Narrativa
Para escrever um algoritmo precisamos descrever a sequência de instruções, de

maneira simples e objetiva.
Para isso utilizaremos algumas técnicas:
 Usar somente um verbo por frase.

 Imaginar que você está desenvolvendo um algoritmo para pessoas que não
trabalham com informática.
 Usar frases curtas e simples.
 Ser objetivo.
 Procurar usar palavras que não tenham sentido dúbio.
3.2.2. Fluxograma
Como foi apresentado anteriormente, o pseudocódigo é uma maneira interessante e

bastante utilizada para representar o comportamento das soluções a implementar
através de um computador.
Entretanto, uma forma gráfica para a expressão do fluxo de execução de um programa

pode apresentar algumas vantagens. O uso de símbolos especiais e a combinação
destes símbolos para formar as estruturas mais clássicas de controle, como aquelas
apresentadas anteriormente podem eliminar a ambigüidade eventualmente provocada
pelo uso do texto escrito.
Há muitos anos, o fluxograma tem aparecido como uma ferramenta interessante de

representação do comportamento de programas, permitindo expressar, além do fluxo
lógico da execução e, as operações envolvidas no processamento dos dados e as
entradas e saídas. Os fluxogramas são construídos a partir do uso de símbolos
padronizados que expressam classes de operações comumente utilizadas nos
programas.

Simbologia
Existem diversos símbolos em um diagrama de bloco. No decorrer do curso

apresentaremos os mais utilizados. Veja no quadro a seguir alguns dos símbolos que
iremos utilizar:
Tabela 1 - Símbolos usados em fluxogramas
Símbolo Descrição
Terminal: Representa o início e fim do fluxograma.
Processamento: Representa a execução de

operações ou ações como cálculos, atribuições de
valores das variáveis, dentre outras.
Entrada de Dados: Representa a entrada de dados
para as variáveis através do teclado.
Saída de vídeo: Através deste símbolo podemos

representar a saída de informações (dados ou
mensagens) por meio de um dispositivo visual de
saída de dados, o monitor de vídeo e outros.
Decisão: Representa uma ação lógica, que realizará
uma sequência de instruções sendo verdadeiro ou
falso, se o teste lógico apresentar o resultado
“verdadeiro”, realizará uma sequência se o teste lógico
apresentar resultado “false” será executado outra
sequência.
Preparação: Representa uma ação de preparação
para o processamento, um processamento predefinido
(procediemnto ou função).
Conector: Este símbolo é utilizado para interligar
partes do fluxograma ou desviar o fluxo para um
determinado trecho do fluxograma.
Conector de Página: Utilizado para ligar partes do
fluxograma em páginas distintas.
Seta: Orienta a sequencia de execução ou leitura, que
poderá ser horizontal ou vertical.
O fluxograma pode ser representado de forma horizontal ou vertical, dentro dos

símbolos sempre terá algo escrito, pois somente os símbolos não nos dizem nada.

Fluxograma da solução para cálculo da

média de uma disciplina, podemos notar
que no fluxograma as variáveis são
inicializadas com zero, na montagem do
fluxograma não é obrigado as variáveis
serem inicializadas, se não houver a
inicialização no fluxograma o mesmo
ainda estará correto e será executado
perfeitamente no Portugol IDE.
Figura 1 - Fluxograma da média de duas notas
Na Figura 2 vemos um representação de fluxograma no sentido horizontal.
Figura 2 - Olá mundo
3.2.3. Pseudocódigo
Os algoritmos são descritos em uma linguagem chamada pseudocódigo, que segue os

paradigmas das linguagens de programação, sem serem dependentes de qualquer
linguagem de programação específica. Este nome é uma alusão à posterior
implementação em uma linguagem de programação. Ou seja, quando formos
programar em uma linguagem, por exemplo Java, estaremos gerando código em Java.
Por isso os algoritmos são independentes das linguagens de programação. Ao
contrário de uma linguagem de programação não existe um formalismo rígido de como
deve ser escrito o algoritmo.
O algoritmo deve ser fácil de interpretar e fácil de codificar. Ou seja, ele deve ser o
intermediário entre a linguagem falada e a linguagem de programação.
Utilizaremos Portugol IDE (1) para desenvolver os nossos algoritmos em

pseudocódigo.

Já vimos anteriormente que ALGORITMO é uma sequência lógica de instruções que

podem ser executadas. É importante ressaltar que qualquer tarefa que siga
determinado padrão pode ser descrita por um algoritmo, como por exemplo:
 Como fazer arroz doce

 Calcular o saldo financeiro de um estoque
Vejamos em detalhe como elaborar algoritmos em portugol.
3.2.4. Estrutura geral de um pseudocódigo
Entretanto ao montar um algoritmo, precisamos primeiro dividir o problema

apresentado em três fases fundamentais.
DADOS DE ENTRADA PROCESSAMENTO SAÍDA
Figura 3 - Adaptação da arquitetura de Von Neumann
Entrada: São os dados necessários para a resolução do problema proposto;

Processamento: São os processamentos utilizados para chegar ao resultado final;
Saída: São os dados processados apresentando o resultado para o problema proposto;
Figura 4 - Analogia com o homem

Exercício Prático

Aula - 4. Elementos Utilizados nos Algoritmos em Pseudocódigo
Vimos que o pseudocódigo é uma forma de representação intermediária entre a

narrativa e a linguagem de programação. A partir de agora iremos detalhar melhor esta
técnica de criação de algoritmos. Observe na Figura 5 o pseudo código escrito no
Portugol IDE para calcular a média final dos alunos da 3ª Série. Os alunos realizarão
quatro provas: prova1, prova2, prova3 e prova4.
Figura 5 - Pseudo código em Portugol - Média de provas

Estrutura de um algoritmo independente do problema os algoritmos tem a mesma
estrutura. Vamos estudar as partes deste pseudocódigo.
//calcular_media Identificação do algoritmo
Identificação do algoritmo: Todo algoritmo deve ser identificado, abaixo algumas

regras básicas;
 Não utilizar espaços entre as letras ou caracteres especiais como acentos,

símbolos (@#%&*?:/) entre outros.
 Para identificar um algoritmo com duas palavras, por exemplo “calcular media“
usar o underline o correto ficaria calcular_media.
 Não utilizar palavras reservadas como as que são utilizadas para representar
ações específicas como ler, variavel, escrever no portugol ide as palavras
reservadas são destacadas em negrito.
 Não utilizar números no inicio da identificação do algoritmo como, por exemplo;
“1exemplo” o correto seria “exemplo1”.
 Usar nomes coerentes para identificação de algoritmos, nomes os quais possam
identificar o que o algoritmo vai fazer.

Inicio Início de bloco
Início de bloco: um bloco é um conjunto de instruções de um algoritmo ou de um

programa. Para que saibamos que comandos pertencem a um determinado bloco,
usamos um delimitador de inicio e fim. No Portugol IDE usamos a própria palavra inicio
para identificar o começo de um bloco.
variavel real prova1 Declaração de variáveis

variavel real prova2
variavel real media
Declaração de variáveis: é o local onde o algoritmo define quais variáveis serão

usadas. As variáveis de entrada, saída e de manipulação de valores intermediários
necessários a resolução do problema. As mesmas regras para escrita da identificação
do algoritmo são válidas para nomeação de variáveis.
ler prova1 Corpo do algoritmo

ler prova2
ler prova3
ler prova4
media<- (prova1+ prova2+ prova3+ prova4)/4
escrever "sua media é "
escrever media
Corpo do Algoritmo: No corpo do algoritmo deve ser escrito todos os passos para a
resolução de problemas, como por exemplo;
 Entrada de valores para as variáveis.

 Operações de atribuição tais como lógicas e aritméticas.
 Laços de repetição.
 Exibição de resultados.
Fim Fim de bloco
Fim de bloco: já conceituamos bloco e identificador de início de bloco, da mesma

forma, no Portugol IDE usamos a própria palavra fim para identificar o término de um
bloco.
4.1. Declaração de Variáveis
As variáveis que serão utilizadas na resolução de problemas, devem ser declaradas,

que são as informações relacionadas à resolução do problema.

Mas o que são variáveis?

Variáveis são os elementos básicos que um programa manipula. Uma variável é um
espaço reservado na memória do computador para armazenar um tipo de dado
determinado.
Estas devem receber nomes para poderem ser referenciadas e modificadas quando
necessário. Um programa deve conter declarações que especificam de que tipo são as
variáveis que ele utilizará e às vezes um valor inicial.
4.1.1. Tipos de Variáveis
As variáveis e as constantes podem ser basicamente de quatro tipos: Numéricas,

caracteres, alfanuméricas ou lógicas independente da linguagem de programação.
Numéricas: Específicas para armazenamento de números, que posteriormente

poderão ser utilizados para cálculos. Podem ser ainda classificadas como Inteiras ou
Reais. As variáveis do tipo inteiro são para armazenamento de números inteiros e as
Reais são para o armazenamento de números que possuam casas decimais.
Caracteres: Específicas para armazenamento de conjunto de caracteres que não

contenham números (literais). Ex: nomes.
Alfanuméricas: Específicas para dados que contenham letras e/ou números. Pode em
determinados momentos conter somente dados numéricos ou somente literais. Se
usado somente para armazenamento de números, não poderá ser utilizada para
operações matemáticas.
Lógicas: Armazenam somente dados lógicos que podem ser Verdadeiro ou Falso.
No Portugol IDE usamos a palavra variavel para declarar uma variável como no
exemplo anterior (variavel real prova1) na Erro! Autoreferência de indicador não válida.
podemos ver os tipos de dados utilizados.
Tabela 2 - Tipos básicos no Portugol IDE
Tipo Descrição Valores Valor por

defeito
Inteiro Valores ordinais definidos com quatro -2 147 483 648 0
bits 2 147 483 647
Real Valores com parte decimal definidos com -1.7 E 308 0.0
64 bits 1.7 E 308
Lógico Valore lógicos - 1 bit verdadeiro falso
falso
Carácter Caracteres da Tabela ASCII ASCII(0) " " (espaço)
ASCII(255)

Texto Conjuntos de caracteres "Sequências de "" (vazio)

caracteres"
"entre aspas"
Exercício Prático
Para escrever algo utilizamos a palavra escrever, se quisermos escrever algum texto ,
por exemlplo “Olá mundo!” digitamos o seguinte comando:
escrever “Olá mundo!”
Se for uma variável A então teremos:
escrever A
Para ler uma variável que recebeu uma entrada do usuário digitamos a palavra ler
acompanhada do nome da variável declarada.
Ou ainda:
escrever “O conteúdo de A é: “, A
4.3. Operadores
4.3.1. Atribuição
O comando de atribuição faz com que um valor seja guardado em uma variável. Do
lado esquerdo temos a variável que armazenará o valor. Do lado direito da expressão
podemos ter um valor específico ou uma expressão que retorna um valor a ser
armazenado, em geral uma expressão aritmética. Observe na Figura 6.
No Portugol IDE utilizamos este símbolo <- para atribuir valor a uma variável.

Figura 6 - Funcionamento de variáveis
No Portugol IDE, teremos:
A <- 2
4.3.2. Aritméticos
Os operadores aritméticos são os utilizados para obter resultados numéricos. Além
da adição, subtração, multiplicação e divisão, podem utilizar também o operador para
resto da divisão.
Os símbolos para os operadores aritméticos são:

Tabela 3- Operadores aritméticos
Operador Aritmético Portugol

Adição +
Subtração -
Multiplicação *
Divisão /
Resto da Divisão %
Hierarquia das Operações Aritméticas
1 º ( ) Parênteses
2 º Exponenciação
3 º Multiplicação, divisão (o que aparecer primeiro)
4 º + ou – (o que aparecer primeiro)

4.3.3. Relacionais
Os operadores relacionais são utilizados para comparar String de caracteres e

números. Os valores a serem comparados podem ser caracteres ou variáveis. Estes
operadores sempre retornam valores lógicos (verdadeiro ou falso). Para estabelecer
prioridades no que diz respeito a qual operação executar primeiro, utilize os
parênteses.
Os operadores relacionais são:

Tabela 4 - Resultado de uma comparação de valores
Operador Relacional Portugol

Igual a A=B
Diferente de A =/= B
Maior que A>B
Maior ou igual a A >= B
Menor que A>B
Menor ou igual a A<B
Figura 7 - Fluxograma de um teste de uma expressão relacional
4.3.4. Lógicos
Os operadores lógicos servem para combinar resultados de expressões, retornando o

resultado final é verdadeiro (V) ou falso (F).
Os operadores lógicos são:

Tabela 5 - Operadores Lógicos
Operador Lógico Portugol

Uma expressão (E) é verdadeira se todas as condições forem
E
verdadeiras

Uma expressão (OU) é verdadeira se pelo menos uma condição for

OU
verdadeira
Um expressão (NÃO) inverte o valor da expressão ou condição, se
NAO
verdadeira inverte para falsa e vice-versa
A tabela abaixo mostra todos os valores possíveis criados pelos três operadores
lógicos (E, OU e NAO).
Tabela 6 - Tabela Verdade
1º. valor Operador 2º. Valor Resultado

V E V V
V E F F
F E V F
F E F F
V OU V V
V OU F V
F OU V V
F OU F F
V NÃO — F
F NAO — V
Exemplos:
Suponha que temos três variáveis A = 5, B = 8 e C =1
Os resultados das expressões seriam:
Operações Lógicas
Operações Lógicas são utilizadas quando se torna necessário tomar decisões em um

fluxograma ou pseudocódigo. Toda decisão terá sempre como resposta o resultado
VERDADEIRO ou FALSO.
Como no exemplo do algoritmo “CHUPAR UMA BALA”. Imaginemos que algumas

pessoas não gostem de chupar bala de Morango, neste caso teremos que modificar o
algoritmo acrescentando as linhas sublinhadas:

“Chupar uma bala”.

1. Pegar a bala
2. A bala é de morango?
3. Se sim, não chupe a bala
4. Se não, continue com o algoritmo
5. Retirar o papel
6. Chupar a bala
7. Jogar o papel no lixo
Figura 8- Algoritmo “Chupar Bala” utilizando fluxograma
Exercício Prático
4.4. Teste de mesa
Para testar se as funcionalidades implementadas em um algoritmo estão corretas é

necessário testar o algoritmo, verificando o conteúdo das variáveis passo a passo. Para
efetuar esta tarefa, costuma-se utilizar o chamado Teste de Mesa ou Teste Exaustivo.
Realizar este teste significa seguir passo a passo as instruções do algoritmo, de
maneira precisa, para verificar se o que foi implementado está correto ou não, a partir
dos resultados gerados e dos valores parciais. Este teste permitirá que o programador
visualize o comportamento de todo o processo, cheque se o algoritmo está correto e
corrija eventuais erros, se existirem. Em Informática, dá se o nome de “bugs” aos erros
de um programa. O processo de identificação e correção dos erros denomina-se
“debugging”. Os erros podem ser dos seguintes tipos:
ERROS SINTÁTICOS – ocorrem quando as instruções do programa não são escritas de

acordo com a sintaxe da linguagem sendo usada. Por exemplo: se eu esquecesse um
fim se de um comando se, o comando estaria incompleto. Não estaria definido
conforme a sintaxe da linguagem. Por isso, ocorreria o erro sintático. Este tipo de erro
impede a execução do algoritmo ou programa.
ERROS SEMÂNTICOS – (ou lógicos) - ocorrem quando o código escrito pelo programador
não gera o resultado desejado por este. Ou seja, o código está sintaticamente correto,
mas o resultado gerado pelo algoritmo não está correto. Erros de lógica podem ser
simplesmente uso incorreto de operadores (+ no lugar de -, usar o operador OU no
lugar de usar o E), atribuições erradas (por exemplo, pedir para digitar o nome da
pessoa e guardar o que for digitado na variável endereço), etc.
Os erros sintáticos são fáceis de encontrar e corrigir porque, geralmente, o compilador

se encarrega de apontá-los e, normalmente, dá uma indicação do tipo de erro. O
programa só é executado quando não existem mais erros sintáticos. Já os erros
semânticos são de detecção mais difícil, uma vez que os compiladores não podem
encontrar erros de lógica, já que não tem conhecimento sobre o que o programador
deseja fazer. Dessa forma, erros de lógica só podem ser encontrados e remediados
pelo programador. Esse tipo de erro pode fazer com que o programa exiba
comportamentos inesperados.
Suponha um algoritmo para ler duas notas de um aluno e calcular a média das
mesmas. Depois indicar se o aluno foi aprovado (média >= 7) ou não. Suponha
também que os valores digitados para as notas serão 8.0 e 9.0, respectivamente.
Seguindo os passos que foram explicados do teste de mesa, vai ser criada uma coluna
para cada variável do algoritmo e uma coluna para o que vai aparecer na tela. Em
seguida, você vai seguindo, linha a linha, passo a passo a execução do algoritmo, com
os valores de teste sugeridos e vai preenchendo a tabela criada (vide
E como se faz o teste de mesa?

1. Leia o algoritmo que foi escrito.
2. Crie uma coluna para cada uma das variáveis declaradas no algoritmo e uma coluna para a
saída de dados (o que vai ser impresso na tela)
3. Em seguida, acompanhe linha a linha a execução do algoritmo, anotando nas colunas

apropriadas cada mudança de valor das variáveis ou do que foi escrito na tela.
Sugestão:
4. Preste atenção nas estruturas condicionais (porque pode haver instruções que não serão
 Uma animação interessante sobre um exemplo de teste de mesa simples
executadas) e nas estruturas de repetição (porque pode haver trechos de instruções que devem
pode ser vista em http://www.brasilacademico.com/ed/testemesa.htm.
ser executados mais de uma vez).
5. Siga a execução até chegar ao final do algoritmo

Tabela 7), até terminar o algoritmo.
Tabela 7 – Teste de mesa
Executando Variáveis
Visualização na tela
Nº Linha N1 N2 Media
3 Digite a sua 1ª nota
4 8.0
5 8.0 Digite a sua 2ª nota
6 8.0 9.0
7 8.5
9 Aprovado sua média é:
10 8.5
Como as variáveis foram preenchidas corretamente e o resultado impresso na tela está

correto, o algoritmo criado está correto.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Figura 9 - Algoritmo em Portugol para calcular a média entre dois números

Exercício Prático

Ao construir uma aplicação, verá a necessidade de controlar o fluxo do sistema, blocos

de instruções para solucionar um determinado problema.
Essa necessidade de controle deve-se ao fato de mudar o fluxo de execução para

conseguir o resultado esperado. Um determinado bloco de instruções pode não ser
executado ou poder ser repetido em determinadas circunstâncias. Para isso temos as
estruturas de controle que podem nos dar desvio de fluxo e repetições.
Na programação estruturada utiliza-se três formas básicas para controlar o fluxo das
operações: Sequência, Seleção e Repetição, que serão descritas e exemplificadas nas
subseções seguintes. A combinação destas estruturas permite construir algoritmos
diversos, em vários níveis de complexidade.
A sequência foi utilizada até agora, onde as instruções são executadas sem desvios. A
seguir veremos em mais detalhes seleção e repetição
5.1. Estrutura de decisão
Estas estruturas permitem direcionar o fluxo das ações conforme uma condição
estabelecida, ou seja, executam as ações de um determinado bloco se a condição de
teste retornar um valor verdadeiro. Caso a condição retorne falso, o programa desvia
seu fluxo de execução para o primeiro comando após o final da estrutura em questão.
Pode-se também utilizar uma estrutura composta, na qual adiciona-se o senão
imediatamente após o bloco de comandos do se. O bloco de comandos do senão será
executado se, e somente se, a condição de teste do se retornar um valor falso.
Como vimos no capítulo anterior em “Operações Lógicas”, verificamos que na maioria

das vezes necessitamos tomar decisões no andamento do algoritmo. Essas decisões
interferem diretamente no andamento do programa. Trabalharemos com dois tipos de
estrutura. A estrutura de Decisão e a estrutura de Repetição
5.1.1. Simples
A estrutura de decisão SE normalmente vem acompanhada de um comando, ou seja,

se determinada condição for satisfeita pelo comando se ENTAO execute determinado
comando.
Estrutura de Decisão Simples Portugol

Quando um bloco deve ser se expressão_lógica entao
executado apenas quando uma //Código se expressão_lógica for verdadeira
expressão lógica for verdadeira fimse
Imagine um algoritmo que determinado aluno somente estará aprovado se sua média
for maior ou igual a 5.0, veja no exemplo de algoritmo como ficaria.

b – Portugol a – Fluxograma
Figura 10 - Status do aluno para sua média – condição simples
5.1.2. Composta
A estrutura de decisão SE – ENTÃO – SENÃO funciona exatamente como a estrutura

SE, com apenas uma diferença, em SE somente podemos executar comandos caso a
condição seja verdadeira. A diferença é que sempre um comando será executado
independente da condição, ou seja, caso a condição seja verdadeira o comando da
condição será executado, caso contrário o comando da condição falsa será executado
Estrutura de Decisão Composta Portugol

Há um bloco para ser executado se expressão_lógica entao
quando uma expressão lógica for //Código se expressão_lógica for verdadeira
verdadeira e um bloco diferente para senao
//Código se expressão_lógica for falsa
ser executado quando a expressão Fimse
lógica for falsa
Figura 11 - Status do aluno para sua média – condição composta

No exemplo acima está sendo executada uma condição que, se for verdadeira, executa
o comando escrever “Aluno aprovado!”, caso contrário executa o segundo comando
escrever “Aluno reprovado!”.
5.1.3. Encadeada
Podemos também dentro de uma mesma condição testar outras condições. De forma
encadeada. Se o aluno que tiver que fazer uma outra avaliação quando sua média for
menor que 7.0, teremos a seguinte alteração no nosso algoritmo:
Estrutura de Decisão Composta Portugol

Há um bloco para ser executado se expressão_lógica entao
quando uma expressão lógica for //Código se expressão_lógica for verdadeira
verdadeira e um bloco diferente para senao
//Código se expressão_lógica for falsa
ser executado quando a expressão fimse
lógica for falsa
Figura 12 - Status do aluno para sua média – condição encadeada
Vale ressaltar que poderemos encontrar situações problema onde outro se dever ser
escrito dentro do bloco senão, ou termos outro se encadeado no se mais interno, as
possibilidades são infinitas.
Exercício Prático

5.2. Estruturas de repetição
Utilizamos os comandos de repetição quando desejamos que um determinado conjunto

de instruções ou comandos seja executado um número definido ou indefinido de vezes,
ou enquanto um determinado estado de coisas prevalecer ou até que seja alcançado.
5.2.1. Enquanto
O laço enquanto é bastante parecido com a estrutura de seleção simples, onde temos
um bloco de comandos sendo executado quando uma expressão lógica é verdadeira,
não tendo nada pra ser executado quando o resultado da expressão for falso.
A diferença entre as duas estruturas, seleção simples e enquanto, é que o bloco de

comandos pode ser executado várias vezes: enquanto a expressão lógica permanecer
verdadeira.
Veremos o comportamento do enquanto em das modalidades: com teste no inicio e

teste no final.
Teste no início
O enquanto com teste no início não permite que nenhuma linha seja executada antes
que esteja testada a condição de entrada do laço, que é definida por uma expressão
lógica na primeira linha do laço.
Tabela 8 - Estruturas de repetição – Portugol
Enquanto – Teste no início Portugol

Executa código até que atinja o critério de enquanto expressão_lógica faz
parada, ou seja expressão_lógica seja //Código se expressão_lógica for verdadeira
falsa. Neste caso o teste é feito antes que Fimenquanto
se comece a execução do bloco do
enquanto.
Figura 13 – Fluxograma da Estrutura Enquanto – Teste no Início
No exemplo iremos demonstrar como conduzir o seu raciocínio para que consiga
elaborar a solução para os problemas que irão ser apresentados pra você na área de

programação. Esta mesma forma de construir a solução pode ser aplicada para outros
problemas.
Exemplo – Dado um número deseja-se identificar seus divisores. Iremos usar os três
tipos de laços mencionados na Tabela 19 resolução do exercício proposto. Iremos
primeiro mostrar a interface escolhida para este problema. Todas as soluções irão usar
a mesma interface.
1. Identificar a entrada: um número B (Entrada)

2. Identificar a saída: os números divisores do número B (Saída)
3. Precisamos saber o que é um divisor: um número A é divisor de um outro
B se o resto da divisão de B por A for igual a zero. Sabemos ainda que todo
número é divisor dele mesmo e que 1 é divisor de qualquer número.
(Processamento)
a. Então, pra eu saber quais são os divisores de um número B tenho que
testar se resto da divisão de todos os números entre B e 1 são iguais a
zero. Quando o resultado dessa comparação for verdadeira, tenho um
divisor. Significa que tenho que pegar B e dividir por (B – 1) pegar o resto
e comparar com 0, essa operação já aprendemos fazer:
B % (B) = 0 ?  se B % (B) = 0 entao

escrever B, “ é divisor”
fimse
B % (B – 1) = 0 ?  se B % (B – 1) = 0 entao
escrever (B – 1), “ é divisor”
fimse
B % (B – 2) = 0 ?  se B % (B – 2) = 0 entao
fimse
B % (B – 3) = 0 ?  se B % (B – 3) = 0 entao
fimse
...
B % (1) = 0 ?  se B % (1) = 0 entao
escrever (1), “ é divisor”
fimse
b. Para não ficar usando o próprio número B, atribuo o valor de B para a
variável A, e minha solução vai ficar assim:
A <- B
B % (B) = 0 ?  se B % A = 0 entao
escrever B, “ é divisor”
fimse
A <- A – 1
B % (B – 1) = 0 ?  se B % A = 0 entao
escrever A, “ é divisor”
fimse
A <- A – 1
B % (B – 2) = 0 ?  se B % A = 0 entao
fimse
A <- A – 1
B % (B – 3) = 0 ?  se B % A = 0 entao
fimse
A <- A – 1
...
B % (1) = 0 ?  se B % A = 0 entao
fimse
A <- A – 1 //Nesse momento A = 0, nosso critério de parada
c. Concluímos que repete-se a estrutura do se e a atualização da variável

pelo decremento de 1. Veja o código final em Portugol para este
exemplo.
Figura 14 - Pseudocódigo em Portugol - Divisores – Enquanto com teste no início
Teste no final
Neste caso, executa-se primeiro o bloco de operações e somente depois é realizado o

teste de condição. Se a condição for verdadeira, o fluxo do programa continua
normalmente. Caso contrário é processado novamente os comandos antes do teste da
condição.
Enquanto – Teste no final Portugol

Executa código até que atinja o critério de Faz
parada, ou seja expressão_lógica seja //Código se expressão_lógica for verdadeira
falsa. Neste caso o testeé feito depois enquanto (expressão_lógica)
que a primeira iteração do laço seja
executada.

Figura 15 – Fluxograma Estrutura Enquanto - Teste no Final – Enquanto com teste no final
Resolvendo o problema dos divisores, descrito anteriormente, teremos:
Figura 16 - Pseudocódigo em Portugol – Divisores – Enquanto com teste no final
5.2.2. Para
O laço para, também conhecido como laço contado, tem uma estrutura muito
específica a para determinar seu critério de parada, ou seja, a sua expressão lógica.
Ele tem em sua estrutura uma variável chamada de contador que é inicializada,
atualizada e testada de acordo com o que é informado na primeira linha de definição do
laço.
Para Portugol
A variável contadora é inicializada, para contador de inicio ate fim passo p
atualizada e testada de acordo com o que //Código se expressão_lógica for verdadeira
está na definição do laço Proximo
Iremos resolver o problema dos divisores mais uma vez.

Figura 17 - Pseudocódigo em Portugol – Divisores – Para

Aula - 6. Estruturas de Dados Indexadas
Estruturas de dados são modelos de armazenamento de dados na memória que visam

tornar eficiente tanto o armazenamento quanto o tempo gasto no processamento dos
dados. A forma mais simples de uma estrutura de dados é denominada Vetor.
Estruturas de dados estáticas são mais simples e fáceis de usar. Mas para a maioria
das aplicações não se pode conhecer o número de elementos necessários na
resolução do problema, exigindo estruturas de dados dinâmicas, em que a quantidade
de elementos pode ser frequentemente alterada.Em relação ao uso de estruturas de
dados dinâmicas podem ser citada, por exemplo; lista de contatos de uma agenda, lista
de clientes de um banco, número de personagens de um jogo, lista de usuários de um
computador.
6.1. Vetores
Vetores são elementos que são armazenados de forma indexada. Os vetores podem
ser estruturas de dados estáticas, pois o número de elementos nessa estrutura é
determinado no momento de sua alocação na memória; normalmente quando as
variáveis são declaradas. (Algumas linguagens permitem vetores de alocação
dinâmica).
O vetor é uma coleção de variáveis de um mesmo tipo de dados, que compartilham o

mesmo nome porem com posições diferentes em memória.
Abaixo temo a representação de um vetor de 10 elementos.
Os índices determinam a posição do

elemento inserido na estrutura, onde cada
Valores que serão posição do vetor contém o valor que
armazenados no vetor [0] [1] [2] [3] poderá
[4] [5]ser manipulado
[6] [7] [8] [9]
1 2 3 4 5 6 7 8 9 10
6.1.1. Declaração de vetor
Para declararmos um vetor é necessário definirmos o seu nome, tipo e tamanho.
variavel inteiro V [10]
Essa declaração define uma variável chamada V que pode armazenar um conjunto de
números inteiros que serão identificados como V[0], V[1], V[2], ..., V[N],

6.1.2. Acesso e Atribuição de Vetores
Uma vez criado um vetor, a atribuição de valores é processada de elemento em

elemento, alterando-se o valor do índice do vetor.
Exemplo: Um vetor usado para guardar os nomes dos meses do ano.
Meses : vetor [1..12] de inteiros
variavel texto Meses [12]

Meses[1] <- “Janeiro”
Meses[2] <- “Fevereiro”
Meses[3] <- “Março”
...
Meses[11] <- “Novembro”
Meses[12] <- “Dezembro”
Exemplo2:
Figura 18 - Algoritmo em Portugol para exemplo de vetor

6.2. Matrizes
Estruturas indexadas que necessitam de mais que um índice para identificar um de

seus elementos;
São chamadas matrizes de dimensão n, onde n representa o número de índices

requeridos;
Uma matriz de dimensão 2 é uma matriz que exige dois índices para identificar um
elemento em sua estrutura;
A maioria das linguagens não impõe limite sobre a dimensão de uma estrutura
indexada, ficando a cargo do programador utilizar tantos índices quanto considerar
convenientes.
6.2.1. Declaração
A declaração de uma matriz poderia ser feita da seguinte forma:
variavel inteiro V [10][3]
Essa declaração é muito semelhante à declaração de vetor, porque o vetor é uma

matriz de dimensão 1.
A convenção mais comum é dizermos que o primeiro índice identifica uma linha de uma
matriz bidimensional e o segundo, uma coluna.
Exemplo: Dada uma matriz de 6 linhas e 2 colunas de inteiros, calcular e exibir a média
geométrica dos valores de cada uma das linhas. A média geométrica é calculada pela
seguinte expressão : SQRT (X1 * X2), que representa a raiz quadrada do resultado da
multiplicação dos elementos da coluna 1 (X1) pelos elementos da coluna 2 (X2).
Para realizarmos o acesso e atribuição em uma matriz temos que lembrar que, cada
elemento de uma matriz pode armazenar um valor, para realizar uma atribuição temos
que informar as dimensões (linha,coluna), podemos compara com uma planilha que
aprendemos a usar em Informática básica.
Vejamos exemplos de algoritmos em Portugol e em Java usando matrizes.
Exemplo: Desejamos guardar uma quantidade de coisas em nosso caixote, o formato

dele é uma matriz de 2x2, em cada espaço temos que armazenar um valor de um
objeto qualquer, abaixo temos uma tabela com os valores que serão inseridos.
12 26
21 45
Figura 19 - Algoritmo em Portugol para preencher e exibir uma matriz
Como já vimos à atribuição em uma matriz é igual como é feito em um vetor, a

diferença é que você precisa indicar as coordenadas assim como estudamos no plano
cartesiano.
Neste exemplo declaramos uma matriz de 2x2 e atribuímos os valores conforme a

tabela informada anteriormente, dando a localização de linha e coluna (tabela [0] [0] ),
onde tabela é o nome da minha matriz de inteiros, se quero armazenar o valor 26
conforme a tabela anterior, então passo linha 0 e coluna 1, para realizar a alocação
conforme a tabela.
Algoritmo Exemplo:
Figura 20 - Algoritmo em Portugol para calcular a média geométrica de 6 números

7.1. Características Gerais
Subprogramas são rotinas (trechos ou módulos) de programas, capazes de executar

uma tarefa definida pelo programador. Os programas desenvolvidos com
subprogramas são ditos ‘modulares’. Desta forma, Os programas desenvolvidos assim
são mais legíveis e melhor estruturados. Todo subprograma deverá ter um nome e um
corpo (conjunto de instruções).
No Portugol IDE não podemos implementar subprogramas, embora seja uma técnica
bastante utilizada em programação. Em Java subprogramas são chamados métodos.
Escopo de variáveis
Todo subprograma possui um espaço para declaração de variáveis, chamadas de

variáveis locais, embora não seja obrigatório o seu uso. As variáveis declaradas no
programa principal são chamadas de variáveis globais.
Dentro do subprograma podem ser utilizadas tanto variáveis locais quanto variáveis
globais. Todas as variáveis locais aos subprogramas são alocadas somente quando
estão em execução, mas são liberadas quando o procedimento termina, perdendo
assim, seus conteúdos. Caso seja necessário o aproveitamento dos dados
manipulados, o procedimento deverá utilizar as variáveis globais.
No campo de declaração de variáveis locais ao procedimento, poderão também ser

definidos outros procedimentos internos. Assim, poderemos ter um programa com
vários subprogramas, e dentro destes outros subprogramas, e assim por diante.
Parâmetros
Parâmetros são dados que um subprograma necessita para executar suas instruções e
dá o retorno desejado. Por exemplo, quando criamos um subprograma para calcular a
soma de dois números n1 e n2, teremos que passar esses números para que o
subprograma possa realizar a soma dos mesmos. Então dizemos que n1 e n2 são
parâmetros para o subprograma soma.
soma(n1, n2)
Para chamarmos uma função ou procedimento deste tipo, devemos colocar o nome
seguido de um conjunto de parâmetros entre parênteses. Os parâmetros devem ser em
igual quantidade e de mesmos tipos, conforme foi definida a função ou o procedimento.
Um subprograma pode retornar um valor para o ponto de chamada, o que chamamos

de parâmetro de retorno. No momento em que esse subprograma é escrito, deve ser
definido também a existência desse parâmetro, que é único. No caso do exemplo da
soma há um retorno

Figura 21 - Exemplo de como seria a escrita de um algoritmo de uma função em Portugol
Se fosse possível escrever um subprograma no Portugol IDE, teria uma sintaxe

parecida com o exemplo acima. Neste exemplo temos dois parâmetros n1 e n2 e um
parâmetro de retorno S, que é uma variável local ou subprograma.
7.2. Procedimentos
Os subprogramas que não retornam um valor para o ponto de onde foram invocados é
chamado de procedimento. Aqueles que retornam são chamados de função.
7.3. Funções
Funções são rotinas similares aos procedimentos, só que retornam um valor após cada
chamada. Uma função não deverá simplesmente ser chamada, como no caso dos
procedimentos, mas deverá ser atribuída à alguma Var. Uma função deve ter um nome
e um tipo, e sua sintaxe é mostrada abaixo.
O nome da função é quem deve assumir o valor da função, como se fosse uma
variável. Assim como nos procedimentos, uma função deve ser definida dentro do
espaço de declaração de variáveis do programa. Para que a função possa retornar um
valor, este deverá ser explicitamente atribuído ao nome da função, dentro da rotina da
função.

FASE II – LINGUAGEM DE PROGRAMAÇÃO
Aula - 8. Introdução a Linguagem Java
8.1. História
Em 1992 foi criado na Sun um time, conhecido como Green Team, para desenvolver
inovações tecnológicas. Liderado por James Gosling, considerado o pai do Java, o time
lançou a ideia de criar um interpretador para pequenos dispositivos, facilitando a
reescrita de software para aparelhos eletrônicos. A ideia não vingou, tentaram fechar
diversos contratos com grandes fabricantes de eletrônicos, como Panasonic, mas não
houve êxito devido ao conflito de interesses e custos. Hoje, o Java domina o mercado
de aplicações para celulares com mais de 2.5 bilhões de dispositivos compatíveis.
Com o surgimento da web, a Sun percebeu que poderia utilizar a ideia criada em 1992
para rodar pequenas aplicações dentro do browser. Como a ideia inicial era
portabilidade, ambiente semelhante ao da internet, onde havia uma grande quantidade
de sistemas operacionais e browsers, e com isso seria grande vantagem poder
programar numa única linguagem, independente da plataforma. Foi aí que o Java 1.0
foi lançado, para transformar o browser, que funcionava apenas como um cliente fino
(thin client ou terminal burro) para um ambiente que pudesse também realizar
operações, não apenas renderizar HTML. (1)
Desde seu lançamento, em maio de 1995, a plataforma Java foi adotada mais
rapidamente do que qualquer outra linguagem de programação na história da
computação. Em 2004 Java atingiu a marca de três milhões de desenvolvedores em
todo mundo. Java continuou crescendo e hoje é uma referência no mercado de
desenvolvimento de software. Java tornou-se popular pelo seu uso na internet e hoje
possui seu ambiente de execução presente em navegadores, mainframes, sistemas
operacionais, celulares, palmtops, cartões inteligentes etc. (2)
Em 1997 a Sun Microsystems tentou submeter à linguagem a padronização pelos

órgãos ISO/IEC e ECMA, mas acabou desistindo. Java ainda é um padrão de fato, que
é controlada através da JCP Java Community Process. Em 13 de novembro de 2006, a
Sun lançou a maior parte do Java como Software Livre sob os termos da GNU General
Public License (GPL). Em oito de maio de 2007 a Sun finalizou o processo, tornando
praticamente todo o código Java como software de código aberto, menos uma pequena
porção da qual a Sun não possui copyright. (2)
Sugestão:
 Uma Breve História de Java – http://www.youtube.com/watch?v=WAy9mgEYb6o –

Em: 10/05/2012]
 Apresentação de James Gosling – http://www.youtube.com/watch?v=9ei-
rbULWoA – Em: 10/05/2012]
 Rap Java Life – http://www.youtube.com/watch?v=b-Cr0EWwaTk – Em:
10/05/2012]

8.2. Características do Java
A característica mais atrativa desta linguagem é sua portabilidade. Mas, o que é

portabilidade? A portabilidade, neste caso, quando uma plataforma onde o software
será executado não interfere no processo de implementação do mesmo, ou seja, um
código é escrito apenas uma vez, independente da plataforma (arquitetura e sistema
operacional) onde irão executar. Isso traz uma enorme vantagem no que diz respeito
ao processo de desenvolvimento de software. Não seria mais necessário preocupar-se
com peculiaridades de plataforma, apenas da implementação da solução desejada.
Isso só se tornou possível graças a JVM, sigla em inglês para Máquina Virtual Java. A
JVM tem a função de intermediar a “conversa” entre a aplicação/software Java que
está executando e a plataforma onde ele está. Veja a Figura 22:
Figura 22 – Arquitetura de uma aplicação implementada em outra linguagem de programação
Aplicações desenvolvidas em outras linguagens que não utilizam máquina virtual

precisam ser adaptadas para cada plataforma em que vai ser utilizada. Uma aplicação
Controle de Estoque foi desenvolvida em Delphi, e tem que ser instalada em dois
clientes diferentes. De acordo com a Figura 22, o software foi compilado em duas
versões diferentes para poder executar nas plataformas indicadas (Ubuntu e Windows
7). O mesmo software foi desenvolvido em Java e, sendo assim, compilado apenas
para JVM, que, por sua vez, comunica-se com a plataforma de cada cliente.
Tanto Java quanto Delphi são linguagens compiladas, ou seja, geram código de
máquina a partir dos códigos fontes criados pelos programadores através de seus
compiladores. A diferença entre elas é que no Delphi temos a compilação para uma
plataforma específica (Linux, Windows etc), enquanto o compilador Java gera
bytecode, que é a linguagem de máquina da JVM. Sendo assim, observe a Figura 23.
Já vimos no item 1.2 que a JVM faz a “conversa” entre a aplicação Java e a plataforma
que está sendo utilizada. A esta “conversa” chamamos interpretação, ou seja, a JVM
interpreta os comandos existentes na aplicação para a plataforma em que está sendo
executada, em uma primeira instância esta interpretação de comandos é feita da
aplicação para o sistema operacional. Se observarmos novamente a Figura 23 veremos

que o código interpretável Java, chamado de bytecode é o mesmo, sendo executado
pela JVM nas duas plataformas, ou seja, para os sistema operacional Windows XP Pro
e para o Red Hat Fedora Linux. Entretanto, devemos ressaltar que para cada sistema
operacional teremos uma JVM adequada, que é instalada uma única vê e serve para
todas as aplicações Java que sejam executadas na máquina.
Fonte: https://wiki.smu.edu.sg/is200/Java_Virtual_Machine
Figura 23 – Máquina Virtual Java (3)
8.3. Tecnologias Java
Java não é apenas uma linguagem de programação, mas uma tecnologia. Além da
linguagem, onde temos principalmente o compilador com seu conjunto de palavras
reservadas e a sua sintaxe, oferece também o ambiente de execução das aplicações.
Sendo assim, o ciclo de vida de uma aplicação implementada em Java contempla três
etapas: escrita do programa, compilação do código para gerar o bytecode
correspondente e, por fim, a interpretação do programa pela JVM em tempo de
execução.
Para a execução de uma aplicação escrita em Java será necessária a instalação do

Ambiente de Tempo de Execução Java (Java Runtime Environment – JRE), composto
por bibliotecas (APIs) e pela Máquina Virtual Java (JVM). (4)
Para a implementação de uma aplicação, entretanto, será necessário ainda a

instalação do Kit de Desenvolvimento Java (Java Development Kit – JDK). O JDK é
composto por bibliotecas e compilador. (5). Para melhor eficiência no processo de
desenvolvimento de aplicações é muito comum o uso de Ambiente de Desenvolvimento
Integrado (Integrated Development Environment – IDE). Muitas IDEs possibilitam a
programação Java, NetBeans, Eclipse e JCreator são algumas delas. O BlueJ, por
exemplo, é uma ferramenta usada para fins didáticos apenas. A ferramenta que
escolhemos usar neste curso será o NetBeans.

Tabela 9 - Vantagens e desvantagens da linguagem Java
Desvantagens
Vantagens
Independência do sistema operacional Uma camada a mais
Segurança Desempenho
Estabilidade
Aula - 9. IDE NetBeans
A construção de um software precisa respeitar três etapas básicas: a identificação do

problema, elaboração da solução e implementação da solução. (Figura 24).
Identificação do Elaboração da Implementação

problema solução da solução
Figura 24 – Etapas para criação de software
Durante a etapa de identificação do problema devemos compreender o que precisa ser

feito. Devemos lembrar que um problema a ser resolvido em programação significa a
implementação de um processo que temos a nossa volta para um programa de
computador. Resolver o problema significa, então, compreender todas as etapas
necessárias para que possamos “ensinar” o computador o que ele deve fazer para
simular este processo através de um programa ou de um conjunto de programas. Uma
vez identificado o problema que precisa ser resolvido, partimos para a solução do
problema. Lembre-se, criar um programa é ensinar o computador a realizar uma tarefa.
A etapa de elaboração da solução serve para identificarmos quais estratégias serão

usadas para termos êxito na tarefa de ensinar para o computador como executar um
processo. Essas estratégias já foram exploradas na fase anterior, quando aprendemos
as técnicas de desenvolvimento de algoritmos.
Por fim, temos a etapa da implementação da solução, onde iremos transferir a solução
idealizada para uma linguagem de programação apropriada, que pode ser subdividida
em três etapas, como mostrado na Figura 25.
Criação do Criação da Criação dos

projeto interface programas
Figura 25 – Etapas para criação de uma aplicação no NetBeans
O detalhamento da implementação da solução virá nas seções seguintes.
9.1. Criação do Projeto
http://netbeans.org/kb/index_pt_BR.html
Para um melhor entendimento vamos ver como fazemos para receber uma entrada ou
saída nesta linguagem de programação e alguns conceitos que mudam quando
transcrevemos um pseudocódigo para uma linguagem de programação, então vamos
conhecer nossa ferramenta de trabalho.
3
2
Figura 26 - IDE NetBeans
Acima temos a imagem de nossa IDE, na tabela abaixo vamos conhecer cada item
para aprendermos a utiliza-la, veremos antes alguns ícones importantes para nos
ambientarmos a IDE.
Este ícone representa um projeto Java, dentro dele teremos a organização de

todos os algoritmos que iremos criar.
Este é chamado de pacote, onde nesta etapa podemos compreendê-lo com um

diretório, ou uma caixa onde guardamos os nossos arquivos *.java.
Com este ícone temos a identificação que este é um arquivo com a extensão
*.java.
Tabela 10 - Identificação das áreas no NetBeans
Item Descrição
Nesta área temos a barra de menu e barra de tarefas, através dela
criamos os nossos projetos, como na imagem acima temos o projeto
logica2, onde tem várias outras coisa que iremos conhecer.
1
Com estes ícones da esquerda para a direita, o
primeiro podemos criar um novo arquivo que terá a extensão *.java, o
segundo criamos o projeto onde teremos todos os nossos arquivos, para
cada algoritmo teremos um arquivo que segue as mesmas regras que
aprendemos anteriormente sobre nomes de algoritmos, o terceiro ícone

utilizamos para abrimos um projeto salvo.
O quarto ícone utilizamos para salvar os nossos algoritmos que são os
arquivos *.java, onde são chamados de classes, este conceito e
definição de classe veremos na próxima disciplina entre outros
conceitos de orientação a objetos.
Como aprendemos em informática básica em nossa IDE também
podemos usar o recurso de desfazer e refazer com estes ícones
Através do menu temos arquivo, Editar, Format e outros que podemos

utilizar para realizar as mesmas operações dos ícones citados.
Agora como executamos o nosso algoritmo nesta IDE? Usando o menu
Executar>Executar arquivo, pelo atalho Shift+F6 ou pelo ícone

Nesta área ficam os projetos e arquivos que foram criados, com o botão
2 direito do mouse em cima do pacote ou projeto na opção novo também
podemos criar um arquivo *.java que é denominado classe.
Nesta área escrevemos o algoritmo, abaixo veremos uma comparação
3
com o pseudocódigo para entendermos a sintaxe da linguagem.
Neste item da imagem é gerada a saída do algoritmo, assim como é no
4 portugol IDE, nesta fase vamos aprender a gerar uma saída gráfica do
nosso programa.
No NetBeans, uma aplicação é um projeto. Sendo assim, a primeira providência é

criarmos um projeto para trabalharmos.
Para criarmos o projeto no NetBeans basta clicarmos no botão na barra de ferramentas

(veja a Figura 27a) ou através do menu Arquivo Novo Projeto.
a. Novo projeto

b. Identificação do tipo do projeto c. Nomeando o novo projeto

Figura 27 – Criação de projeto no NetBeans
Devemos então identificar a categoria (Java para desktop, Java Web, Java SE etc),
bem como do projeto (Aplicativo Java, Aplicativo da Área de Trabalho Java etc), Java e
Aplicativo Java serão selecionados respectivamente, como na Figura 27b, será o
modelo que iremos usar neste curso. Feito isso então nomeamos nosso projeto ( Figura
27c). Dado o nome e tendo marcado a caixa Criar classe principal, basta pressionar o
botão Finalizar.
A classe principal é indispensável nas aplicações pois é a classe inicial da mesma, ou

seja, por onde o compilador começa a executar o programa. (6)
Ao pressionar o botão Finalizar o NetBeans irá criar o ambiente de programação para

ser usado, a aprtir do qual cria-se as aplicações desejadas. Na Figura 28 vemos, idicado
pela seta que foi criado um projeto, mostrado do lado esquerdo da tela, com nome
MeuExemplo, e dentro da pasta com mesmo nome temos subpastas que são usadas
oportunamente. Neste momento a pasta que nos interessa é a pasta Pacote de código-
fonte, onde serão colocadas todas as classes da aplicação. Vale ressaltar que a pasta
do projeto estará, no caso do Windows, dentro da pasta NetBeansProjects, na pasta
Documentos, como pode ser visto na Figura 27c no item Localização do projeto.
Figura 28 – Pasta do projeto MeuExemplo

9.2. A Aplicação Olá Mundo!
Vamos chama-la de OlaMundo, por questões de padrão e normas adotadas na

linguagem as nossas classes sempre deverão ter a inicial maiúscula, quando se tratar
de uma palavra composta as iniciais de cada palavra devem ser maiúscula.
Após a criação do projeto a classe

principal ficará assim como na imagem
ao lado, agora vamos a algumas
considerações.
No Portugol IDE usávamos a
palavra inicio para começarmos a
escrever o algoritmo e fim onde o
mesmo terminava, agora usamos as
chaves para iniciar ({) e finalizar (})o
programa, logo tudo que iremos
(Onde você digitará seu código) codificar estará entre as chaves. Na
Figura 29 você pode obervar o local
(Onde você digitará seu código)
Figura 29 - Início e Fim de bloco no Java
No Portugol IDE quando queríamos escrever algo usávamos a palavra escrever agora
em nossa linguagem de programação iremos usar a seguinte instrução
System.out.println(“Olá mundo!”);, tudo que eu quero que seja exibido ao usuário
irei colocar dentro dos parênteses e com as aspas duplas, finalizando a linha com
ponto e virgula, ficando como na imagem ao lado;
Para executar podemos utilizar o atalho Shift+F6, que irá gerar a saída abaixo, no
console. Observe a Figura 30.
O resultado do print sai no console
Figura 30 - Execução do projeto OlaMundo

Podemos usar:
System.out.println(“Olá mundo!”);
A diferença entre eles é que o print ele gera a saída do conteúdo na mesma linha, e o
println realiza a quebra de linha.
9.3. Criação da Interface Gráfica
A criação de aplicativos inclui a criação de interfaces gráficas amigáveis para os

usuários, tornando mais fácil a utilização do software. Interfaces gráficas para usuário
(Graphical User Interface – GUI) incluem a utilização de botões, campos de texto etc.
No NetBeans usaremos o Swing para construirmos as interfaces gráficas

necessárias. O Swing é um framework que contem uma série de componentes gráficos
para construção de interfaces gráficas. Entre estes componentes podemos citar
JFrame (formulário), JButton (botão), JTextField (campo de texto) entre outros.
Sugestão:
 http://netbeans.org/kb/trails/matisse_pt_BR.html - Em: 04/06/2012
9.3.1. Formulários, Botões, Campos de Texto etc
Para exemplificar a criação de um formulário no NetBeans usando Swing. Nossa

aplicação MeuExemplo calcula a premiação de um funcionário, dado o valor vendido
por este funcionário. Para isso iremos criar uma tela (JFrame) com duas campos de
texto (JTextField), um para ser informado o valor da venda do funcionário e outro será
usado para dar a saída do progrma, ou seja, o valor da premiação. Para identificar os
valores que deverão está contido nas campos de texto iremos usar dois rótulos
(JLable).
Então vejamos como começar... O primeiro passo é criar o formulário dentro do pacote
meuexemplo, que está dentro da pasta Pacote de código-fonte. Para isso basta que
seja usado o botão direito do mouse sobre o referido pacote, como mostra a Figura 31a.
Com o botão esquerdo do mouse seleciona a opção Formulário JFrame. Feito isso,
uma janela (Figura 31b) irá se abrir e deve ser colocado o nome do formulário, que
chamamos de JFPrincipal e pressiona o botão Finalizar.

a. Adicionar formulário b. Nomear formulário

Figura 31 – Criação de um formulário JFrame
a. Paleta de componentes b. Formulário com componentes inseridos

Figura 32 – Inserção de componentes
Agora, podemos começar a colocar os componentes necessários à aplicação, que está

do lado direito da tela, como mencionado anteriormente. Para inserir um componente
no formulário usamos a Paleta de componentes (Figura 32). Os campos de texto estão
na seção Controles Swing. Para inserir um componete basta arrastar o componente
desejado para o formulário na melhor posição.
Figura 33 - Alteração dos textos exibidos nos componentes

Após todos os componentes da interface gráficas terem sido inseridos no formulário é

desejável que exibam os textos adequados a aplicação. Para isso ser feito deve-se
clicar em cada componente com o botão direito e selecionar a opção Editar texto no
menu suspenso que se abre, conforme a Figura 33.
Figura 34 - Alterar o nome do componente
A manipulação dos componente dentro do código da aplicação é feita através dos

nomes que damos a estes componentes na interface gráficas. Quando arrastamos um
componete para o formulário, o próprio NetBeans o nomeia de forma automática
seguindo um padrão. Por exemplo, quando o primeiro campo de texto é iserido o
NetBeans dá o nome de JTextField1, quando o segundo é iserido, ele dá o nome de
JTextField2, e assim por diante, como pode ser visto na Figura 32b, no Inspetor (do
lado esquerdo da tela). Esses nomes não são interessantes de se manipular, pois não
fazem relação com a aplicação que está sendo desenvolvida, no caso o cálculo da
premiação de um funcionário.
Faz-se necessário, então, renomear os componentes. Isso é feito da mesma forma que
foi feito para alterar o texto dos componentes, pressionando o botão direito do mouse
sobre o componente, mas selecionar o item Alterar o nome da variável (que pode ser
visto na Figura 34). Esse procedimento deve ser repetido para todos os componentes
que serão manipulados dentro do código.
O caso do MeuExemplo, serão manipulados os campos de texto, um para entrada do

dado e o outro para retornarmos a informação de saída, e o botão, que acionará o
código que calculará a premiação.

Figura 35 - Visualizando a interface gráfica
Por fim, podemos visualizar a interface gráfica que foi construída pressionando o botão
na barra de botões, como na
Figura 35a. Na
Figura 35b temos o resultado obtido.
9.4. Criação dos Programas
Agora já temos um projeto, e nesse projeto já construimos a interface gráfica

necessária a nossa aplicação. Com isso, podemos começar a construir o código
necessário ao cálculo da premiação segundo a descrição aseguir:
Exercício Prático
Na nossa aplicação MeuExemplo, todo o código está dentro do evento do botão ok.
Um evento é um acontecimento da interface gráfica, do formulário ou de um de seus

componentes. Os componentes Swing tem vários eventos possíveis associados a eles:
ActionEvent, MouseEvent, KeyEvent, WindowEvent etc, você pode vê-los na lista
que se apresenta na Figura 36. Todos estes eventos são classes implementadas no
pacote java.awt.event.

Figura 36 – Visualização dos eventos possíveis para JButton
Os eventos associados a um componente podem ser vistos na janela Propriedades,

na seção Eventos. Nesta aplicação usaremos o actionPerformed do botão ok, que
pode ser criado pelo próprio NetBeans através do duplo click no botão ok na tela de
Projeto da interface gráfica. Esta ação abre automaticamente a janela de Código-
fonte da interface gráfica, como podemos constatar na Figura 37.
Figura 37 – Código inserido automaticamente para actionPerformed do JButton
Agora estamos prontos para escrever o código necessário para o cálculo da

premiação, do exemplo descrito no início desta seção.
Quando queremos usar uma informação digitada em um JTextField, usamos o método

(em Java um subprograma é chamado de método) getText(). Assim, para obtermos a
informação do campo de texto jTVendido, do MeuExemplo, devemos escrever o
seguinte código:
sVendido = jTVendido.getText();

Vale ressaltar que:
i. a variável sVendido é do tipo String (texto).

ii. getText() é um método que retorna uma String e não tem parâmentros.
Como os componentes da interface gráfica onde os usuários digitam informações para

a aplicação, JTextField, tratam apenas informações do tipo texto, quando precisamos
de uma informação numérica de campos de texto, precisamos converter o texto em
numérico. O mesmo vale quando queremos exibir uma informação numérica para o
usuário, ela deve ser convertida em texto, para poder ser exibida na interface gráfica.
No MeuExemplo, temos que realizar um cálculo usando o valor vendido, que está em
jTVendido. No código apresentado acima armazenamos o valor de jTVendido em
sVendido, podemos então usar o valor de sVendido para calcular o valor da premiação,
como no código abaixo:
Vendido = Double.parseDouble(sVendido);
Esta instrução converte o valor de String para Double e armazena na variável

Vendido, que é do tipo Double. Agora que já temos o valor numérico do montante
vendido, podemos calcular o prêmio, obtido através da seguinte linha de código:
Premio = Vendido * 0.1;
Para exibirmos o valor do prêmio temos que converter a variável sPremio em String
(texto), que é realizado usando o código a seguir:
sPremio = String.valueOf(Premio);
Quando queremos que uma informação do programa seja exibida na interface gráfica,
então usamos o método setText(). Para exibirmos uma informação contida na variável
sPremio na interface gráfica, devemos escrever o seguinte código:
jTPremio.setText(sPremio);
Vale ressaltar que:
i. a variável sPremio é do tipo String (texto).

ii. getText() é um método sem retorno e tem como parâmentro uma String.
Juntando tudo teremos o código exibido na Figura 38:

Figura 38 – Código Java correspondente ao cálculo de premiação
Aula - 10. Elementos Utilizados na Programação
Temos que entender que nossas aplicações irão interagir com o usuário, dessa
interação é que temos a execução dos passos necessários para garantir o objetivo
desejado (determinado em princípio pelo usuário). É isso que deve fazer um sistema de
computação segundo Von Neummann (Figura 39), seja ele do ponto de vista do
hardware ou do software.
a. Ponto de vista do Hardware
b. Ponto de vista do Software

Figura 39 – Arquitetura de Von Neumann
Lembramos que em Java:
 No final de toda instrução deve ser finalizada com o ponto e vírgula (;).
 Os comentários podem ser representados de duas formas
o // : quando só for usar uma linha
o /* : sinaliza o início do comentário com múltiplas linhas
o */ : sinaliza o final do comentário com múltiplas linhas

 A linguagem diferencia letras maiúsculas de minúsculas, sendo assim,

quando você digita Nome e nome, para o Java você está se refeindo a duas
variáveis diferentes;
Tabela 11 – Entrada e Saída
Java Portugol
Scanner leia = new ler valor
Scanner(System.in);
valor = leia.nextDouble();
System.out.print(“Oi, Mundo!”); escrever “Oi, Mundo!”
O código apresentado acima é usado para interface usando o console. Entretanto

iremos usar as interfaces gráficas, demonstradas em seção anterior.
10.2. Tipos de Dados Primitivos
Em Java há dois tipos de variáveis, as primitivas e as de referência. As primeiras são

as que definem os tipos básicos em Java e a segunda referenciam objetos em Java.
Os tipos básicos em Java são: int (inteiro), long (inteiro longo), float (real de 4 bytes),
double (real de oito bytes), char (caracter), byte (byte) e Boolean (booleano). Temos
ainda o tipo String (texto), que é uma sequência de char. Embora não seja um tipo
básico, estamos colocando ele aqui pelo seu largo uso.
A identificação do tipo da variável em Java é insdispensável. Então vejamos como

fazer na prática. Vamos fazer uma comparação de como era feito em Portugol, e
depois como faz-se em Java.
Tabela 12 – Declaração de Variáveis
Java Portugol
int idade; inteiro idade
long habitantes;
float nota; real nota
double nota;
char sexo; caracter sexo
Boolean ligado; logico ligado
String nome; texto nome
Do lado esquerdo da tabela temos o código escrito em Java e do lado direito o mesmo
código em Portugol.

 Identificar tipos de dados adequados para Cada variável.
10.3. Variáveis
Variáveis são repositórios de valores que são usados no decorrer do programa, todas
devem ser declaradas antes de seu uso. Na declaração das variáveis estamos
reservando espaço de memória para que sejam usadas. Algumas observações sobre
declaração de variáveis:
 Não podem receber nomes de palavras reservadas da linguagem.

 Não podem começar por números.
 Não podem conter caracteres especiais ou pontuações.
 A linguagem diferencia letras maiúsculas de minúsculas, ou seja, idade é
uma variável, Idade é outra.
10.4. Atribuição
A atribuição é o meio pelo qual colocamos um valor em uma variável.

Tabela 13 - Atribuição de valor
Java Portugol
idade = 16; idade < - 16
10.4.1. Casting
Casting é usado quando queremos atribuir valores de outros tipos para uma variável.
Por exemplo, se quisermos que um valor real seja armazenado em uma variável
declarada como inteiro, teremos que realizar o processo de casting, de acordo com o
código que se segue:
double nota1 = 6.7;

int nota2 = (int) nota1;
Neste caso para a variável nota2 será atribuído o valor 6.
Abaixo temos uma tabela de possíveis conversões de valores usando casting. Apenas
o Boolean não pode ser convertido em nenhum dos demais tipos primitivos. Nos
quadros onde encontramos a abreviação Impl. na
Tabela 9 significa que esta conversão é implícita, o que torna a ulização do casting
desnecessária, a atribuição direta de valores pode ser feita (1).

Tabela 14 - Casting entre tipos
Para: byte short Char int long float double

De:
byte — Impl (char) Impl Impl Impl Impl
short (byte) — (char) Impl Impl Impl Impl
char (byte) (short) — Impl Impl Impl Impl
int (byte) (short) (char) — Impl Impl Impl
long (byte) (short) (char) (int) — Impl Impl
float (byte) (short) (char) (int) (long) — Impl
Double (byte) (short) (char) (int) (long) (float) —
10.5. Operadores
10.5.1. Aritméticos
Os operadores aritméticos, a exemplo da matemática, são responsáveis por realizar

operações matemáticas simples. Além das operações básicas como soma (+),
subtração (-), multiplicação (*) e divisão (/), temos o operador de resto inteiro da divisão
de dois números (%). A Tabela 15 mostra alguns exemplos.
Tabela 15 - Operadores aritméticos básicos
Java Portugol
int a = 2 + 2; inteiro a = 2 + 2
int a = 2 - 2; inteiro a = 2 – 2
int a = 2 * 2; inteiro a = 2 * 2
double a = 2 / 2; real a = 2 / 2
int a = 2 % 2; inteiro a = 2 % 2
Ainda de acordo com a matemática, temos a chamada ordem de precedência de

operadores, onde temos os operadores que são executados primeiro em uma
expressão. Multipicações e divisões são executadas antes de somas e subtrações.
Essa ordem pode ser alterada usando parênteses, na linguagem Java usamos apenas
os parênteses com esta função, enquanto na matemática usamos ainda os colchetes e
as chaves. Os parênteses são resolvidos do mais interno para ao mais externo.
 Identificar operações básicas adequadas.

 Na empresa onde trabalhamos, há tabelas com o quanto foi gasto em cada
mês. Para fechar o balanço do primeiro trimestre, precisamos somar o gasto
total, dados os gastos em Janeiro, Fevereiro e Março. Faça um programa
que calcule e imprima o gasto total no trimestre.
10.5.2. Relacionais
Os operadores relacionais servem para fazer comparações entre valores de tipos

primitivos, exceto para o tipo booleano. O resultado de uma comparação é um valor
lógico: true (verdadeiro) ou false (falso). Para condicionais e laços usamos valores
lógicos diretos, verdadeiro ou falso, ou do resultados de equações envolvendo

operadores relacionais, como veremos mais adiante.
Na Erro! Autoreferência de indicador não válida. temos comparações entre duas

variáveis, o melhor, os valores destas variáveis. Podemos ainda comparar dois valores
numéricos ou o conteúdo de uma variável com um valor numérico.
abela 16 - Operadores relacionais
Java Portugol
A == B A=B
A != B A =/= B
A>B A>B
A >= B A >= B
A>B A>B
A<B A<B
A <= B A <= B
A comparação entre duas Strings não pode ser feita diretamente usando os
operadores relacionais, temos que usar um método (equals) da classe String para
compará-las, veja:
String s1 = “sol”, s2 = “Sol”;

boolean b = s1.equals(s2); //b terá o valor false, ao final des operação
10.5.3. Lógicos
Os operadores lógicos concatenam expressões lógicas. Uma expressão lógica é

aquela que retorna verdadeiro ou falso, como no caso das comparações. Usamos um
operador lógico quando desejamos saber se duas comparações em conjunto retornam
valor verdadeiro ou falso.
Temos dois operadores lógicos importantes o E e o OU. Usamos o E quando duas

situações devem ser verdadeiras ao mesmo tempo. Veja o exemplo a seguir:
Exemplo 1 – Quando desejamos saber se um aluno pode ser aprovado de uma no

para o outro. Neste caso o aluno tem que ter nota superior ou igual a seis, que obtemos
através da comparação da nota do aluno com o valor numérico seis (6.0), mas
devemos levar em consideração também a quantidade percentual de faltas que teve no
decorrer do ano, que deve ser que deve ser inferior a vinte e cinco por cento (25%).
Temos então as comparações:
 Nota maior igual a 6.0  Nota >= 6.0

 Faltas menor que 25  Faltas < 25

Para que o aluno seja aprovado, a comparação Nota >= 6.0 deve ser ter resultado
verdadeiro, bem como (E), Faltas < 25 deve ter resultado verdadeiro. Portanto, Nota >=
6.0 E Faltas < 25 deve ter resultado verdadeiro para que o aluno seja aprovado.
Usamos o OU, quando precisamos que pelo menos uma seja verdadeira. Isso
descobrimos com o estudo do problema. Veja o exemplo a seguir:
Exemplo 2 – Quando um zero carro é comprado a fábrica oferece uma garantia que
acaba quando o período de um ano termina, mas leva em consideração também a
quilometragem de 20000 km é atingida pelo veículo. O que acontecer primeiro extingue
a garantia. Então se a primeira situação acontece, acabou o período maior que 1, a
garantia acaba ou se a outra situação acontece, atingiu a quilometragem máxima maior
que 20000, também acaba a garantia.
 Periodo maior que 1  Periodo > 1

 Quilometragem maior que 20000  Quilometragem > 20000
Para que a garantia se acabe, apenas a comparação Periodo > 1 deve ter resultado
verdadeiro, (OU) apenas Quilometragem > 20000. Então, Periodo > 1 OU
Quilometragem > 20000 deve ter resultado verdadeiro, para que a garantia seja
automaticamente suspensa.
Temos a seguir, na Tabela 17 a sintaxe de utilização dos operadores lógicos na

linguagem Java.
Tabela 17 - Operadores Lógicos
Java Portugol
(A == B && C == D) (A = B E C == D)
(A == B || C == D) (A == B OU C == D)
Um programa tem um fluxo linear de execução de suas instruções, a menos que

encontre uma estrutura de controle, que pode redirecionar o fluxo de execução para
uma outra linha. Temos dois tipos de estrutura de controle: seleção e repetição.
11.1. Estrutura de Seleção
A estrutura de seleção desvia o fluxo quando uma expressão lógica é testada. Um

determinado bloco do programa é executado quando a expressão é verdadeira e outro
bloco, quando é falsa.
11.1.1. Estrutura de Decisão Simples e Encadeada
Em uma estrutrura de decisão simples temos uma expressão lógica que é testada, de
onde se decide que trexo de código deve ser executado.

Tabela 18 - Estrutura de seleção
Java Portugol
if (expressão_lógica){ se expressão_lógica entao
//Código se expressão_lógica for verdadeira //Código se expressão_lógica for verdadeira
} fimse
if (expressão_lógica){ se expressão_lógica entao
}else{ senao
//Código se expressão_lógica for falsa //Código se expressão_lógica for falsa
} Fimse
Podemos substituir a expressão_lógica na Em uma estrutrura de decisão simples

temos uma expressão lógica que é testada, de onde se decide que trexo de código
deve ser executado.
Tabela 18 por qualquer expressão que temos na Na Erro! Autoreferência de

indicador não válida. temos comparações entre duas variáveis, o melhor, os valores
destas variáveis. Podemos ainda comparar dois valores numéricos ou o conteúdo de
uma variável com um valor numérico.
abela 16 ou na Tabela 17.
Exercício Prático
11.1.2. Estrutura de Decisão de Múltipla Escolha
A estrutura de repetição repete um bloco de código testanto alguma expressão lógica,

usando-a como critério de parada. As estruturas de repetição são também chamadas
de laços. Em Java temos três tipos de laços: for e while (com teste no início e com
teste no final). O teste, como usado na expressão, equivale ao que chamamos de
expressão lógica.
Tabela 19 - Estruturas de repetição
Java Portugol
while (expressão_lógica){ enquanto expressão_lógica faz
} fimenquanto
do{ Faz
}while (expressão_lógica) enquanto (expressão_lógica)
for (cont = inicio;critério parada;atualiza do para contador de inicio ate fim passo p
cont){ //Código se expressão_lógica for verdadeira
//Código se expressão_lógica for verdadeira Proximo
}

Exemplo – Dado um número deseja-se identificar seus divisores. Iremos usar os três
tipos de laços mencionados na Tabela 19 resolução do exercício proposto. Iremos
primeiro mostrar a interface escolhida para este problema. Todas as soluções irão usar
a mesma interface.
Figura 40 – Interface gráfica para o problema dos Divisores
O laço while com teste no início (Tabela 19 – primeira linha), assim como no if, tem uma
expressão lógica para realizar ações (código se expressão_lógica for verdadeira), a
diferença é que o laço repete o bloco de comamandos até que a expressão lógica seja
falsa.
Figura 41 – Problema dos Divisores usando while com teste no início
Quando temos o while com teste no final a primeira iteração do laço é realizada
independente da expressão lógica, que só testada ao final do bloco (código se
expressão_lógica for verdadeira). Este bloco só será executado novamente se a
expressão lógica for verdadeira.

Figura 42 - Problema dos Divisores usando while com teste no final
O laço for tem sua expressão lógica bem defiida, sendo necessário que seja colocada
uma variável, que chamamos de contadora, que é inicializada na primiera parte de sua
definição, podendo ser também declarada neste momento. Na segunda parte de sua
definição temos o critério de parada, ou seja, a expressão lógica, que está relacionada
com a variável contadora. Por fim, temos na última parte como a variável contadora vai
mudar de valor, em geral é incrementada de um, quanod podemos usar o operador ++
ou --, de acordo com a necessidade do problema.
Sugestão:
 Pesquisar como funcionam os operadores ++ e --, bem como suas

variações.
Exercício Prático

Figura 43 - Problema dos Divisores usando for

Aula - 12. Estruturas de Dados Indexadas
12.1. Vetores
Nesta seção falaremos sobre vetores e matrizes.
Neste exemplo em Java, declaramos um vetor do tipo String chamado meses com 12
posições linha 17.
Agora precisamos inicializar o vetor com os meses, fazemos isso através dos índices
como vemos nas linhas 18 a 29, para cada posição do vetor atribuímos um valor do
tipo String.
Na linha 31(Figura 44) usamos o JOptionPane para exibir o conteúdo do vetor, que irá
apresentar uma caixa de dialogo com todos os meses atribuídos, para imprimi-los na
console precisaremos usar uma estrutura de repetição o for, como veremos abaixo.
Figura 44 – Código Java para exibir o vetor meses do ano
Na estrutura de repetição for vai repetir a instrução System.out.println(meses[i]);

onde será exibido o valor de cada índice do vetor, onde i=0 que é o valor inicial, a
condição i<meses.length que será a condição de repetição, o length é para o vetor
usar o seu próprio tamanho, ao invés de determinar, se determinado um valor maior
que o tamanho do vetor isso causará um erro de execução, pois o valor esta fora dos
limites do vetor.

Para imprimir uma posição especifica do vetor você deve colocar o nome do vetor
meses [2] (Dentro do colchete você coloca a posição do índice do vetor que será
exibido) ficando assim System.out.println(meses[2]);.
Abaixo vemos outra forma de declarar e inicializar um vetor
Int meses[] = {1,2,3,4,5,6,7,8,9,10,11,12};
O que está dentro das { } será o conteúdo do vetor, correspondente a cada índice.
12.2. Matrizes
No exemplo da Figura 45, para obter o mesmo resultado da tabela usamos o

System.out.print que imprime o resultado na mesma linha.
Figura 45 – Código Java com exemplo de matriz

Subprogramas em Java são chamados de métodos. Todos os métodos tem uma lista
de parâmetros de entrada e um parâmetro de retorno.
Static tipo nome_método(tipo parâmetro, tipo parâmetro){

//Aqui serão digitadas as Instruções
}
13.1. Procedimentos
Como já vimos anteriormente, um procedimento não tem retorno para o ponto de

chamada. Por exemplo, poderíamos criar um procedimento para limpar os campos da
interface gráfica. Um procedimento em Java é um método com parâmetro de retorno
void.
Figura 46 – Código Java que implementa um procedimento
No exemplo da Figura 46 temos o método soma sem parâmetros de entrada e sem

retorno definido. Ele requer os dados direto do próprio método, e imprime o valor
também dentro do método. Note que a chamada do procedimento não requer uma
variável pra receber valor, pois o método não retorna valor algum! Em consequência
disso a utilização da palavra void na sua definição.
13.2. Funções
Vamos observar o código da Figura 47, abaixo. Neste exemplo temos um programa que
vai executar no console. Este programa calcula a força resultante, dados massa e
gravidade. Foi criado um método que tem como parâmetros Massa e Gravidade.
Como este método tem como retorno a força resultante, que é do tipo double. No
método temos apenas uma instrução que é o retorno da fórmula m*g. m irá receber o
valor passado em Massa, e g irá receber o valor passado em Gravidade.

Figura 47 – Código Java para cálculo da força resultante

FASE III – PROGRAMAÇÃO ORIENTADA A OBJETOS
Aula - 14. Orientação a Objetos
14.1. Introdução
A orientação a objetos é, sem dúvida alguma, um dos mais significativos

conhecimentos daquele que quer efetivamente se aprofundar no universo da Ciência
da Computação. Para haver uma precisa compreensão do que vem a ser tal conteúdo,
torna-se indispensável, antes de mais nada, conhecer aspectos como sua origem e
conceitos relacionados. Assim, neste capítulo você terá oportunidade de estudar
perspectivas que facilitarão e enriquecerão seu estudo acerca do fascinante universo
da Orientação a Objetos.
Como aspecto inicial, podemos dizer que a orientação a objetos é uma forma de
análise, projeto e programação de sistemas de software, que tem por base a
composição e interação entre diversas unidades computacionais, as quais de
chamamos de objetos.
Ela surgiu com a finalidade de facilitar e garantir mais agilidade aos então existentes
programas computacionais e viabilizar também um entendimento mais claro de como
se conectam, interagem e trabalham os processos computacionais.
Inicialmente, os programas eram feitos de forma sequencial, onde o fluxo tinha um

início, meio e fim já definidos, e era processado sequencialmente até encontrar o fim do
programa, quando ele parava, simplesmente.
Com a necessidade de controlar este fluxo, surgiram os recursos da programação

estruturada, como laços e desvios condicionais. Mesmo já sendo um avanço, ainda
existia o problema da repetição demasiada de códigos. Numa tentativa de otimizar o
desenvolvimento de sistemas, a necessidade de reutilizar trechos de códigos foi sendo
estudada cada vez mais pelos profissionais e pesquisadores da área, passando pela
filosofia de guerra de Sun Tzu, “Dividir para conquistar”, que dividia os programas em
vários programas menores.
A Programação Orientada a Objetos surgiu como um desenvolvimento natural da

programação procedural. Na verdade buscava-se dar maior agilidade, inteligência,
clareza e funcionalidade aos sistemas, assim, tentou-se implementar ainda
melhoramentos focando a reusabilidade de códigos, até chegar na Programação
Orientada a Objetos.
Adiante, veremos como a Programação Orientada a Objetos conquistou um verdadeiro

avanço na programação de computadores, garantindo assim o desenvolvimento de
novos programas, linguagens e ações no mundo computacional.
14.2. Histórico
Historicamente a origem da Orientação a Objetos conta da década de 1960 na

Noruega, por meio de Kristen Nygaard e Ole-Johan Dahl, pesquisadores do Centro

Norueguês de Computação. De fato, por meio da chamada linguagem Simula 67,

deram-se os primeiros conceitos de classe e herança. Este é considerado o primeiro
conteúdo de programação orientada ao objeto, porém, precisou de mais algum tempo
para alcançar mais destaque com a linguagem Smalltak.
Como dito, houve grande impulso para a Orientação ao Objeto com a Smalltalk,
nascida nos laboratórios da Empresa Norte Americana Xerox (Estados Unidos da
América). Neste renomado laboratório chamado Palo Alto Research Center, foi
desenvolvida pela equipe liderada por Alan Curtis Kay uma sequência de protótipos
que resultou na linguagem Smalltalk, esta é considerada uma das primeiras linguagens
computacionais orientadas a objeto e por isso apropriada para iniciantes. Diante deste
trabalho é que o estudioso programador Alan Kay é considerado históricamente um dos
criadores do termo “Programação Orientada a Objetos”.
Alan Kay, percebeu que o conceito de objetos possuia grande força como instrumento
do conhecimento. De fato a partir deste conceito se pode fazer uma série de
associações da maneira como percebemos pessoas, objetos e o mundo em si. Se
prestarmos bem atenção, a programação orientada a objetos tem como filosofia básica
simular o mundo real dentro do mundo virtual, implementando objetos para que se
comportem de forma similar à realidade.
Dentro deste conceito, Alan Kay pensou em como construir um sistema de software
partindo de itens autônomos que interagissem entre si, estabelecendo os seguintes
princípios da orientação a objetos:
 Qualquer coisa do mundo pode ser um objeto;

 Tarefas são realizadas por objetos por meio de requisição de serviços;
 Cada objeto é originado a partir de uma classe;
 Uma classe agrupa objetos semelhantes;
 Uma classe possui comportamentos associados ao objeto;
 Classes são organizadas de forma hierárquica.
Neste sentido, após coletar, elaborar e formatar conceitos de diversos campos do

saber, aliando seu conhecimento e sua experiência, Alan Kay conseguiu lançar um dos
mais utilizados e precisos instrumentos de linguagem computacional, qual seja, a
programação orientada a objetos. Vejamos algumas características desse paradigma
(8):
 A orientação a objetos é uma tecnologia para a produção de modelos que

especifiquem o domínio do problema de um sistema.
 Quando construídos corretamente, sistemas orientados a objetos são
flexíveis a mudanças, possuem estruturas bem conhecidas e provém a
oportunidade de criar e implementar componentes totalmente reutilizáveis.
 Modelos orientado a objetos são implementados convenientemente
utilizando uma linguagem de programação orientada a objetos. A engenharia
de software orientada a objetos é muito mais que utilizar mecanismos de sua
linguagem de programação, é saber utilizar da melhor forma possível todas
as técnicas da modelagem orientada a objetos.
 A orientação a objetos não é só teoria, mas uma tecnologia de eficiência e

qualidade comprovadas usada em inúmeros projetos e para construção de
diferentes tipos de sistemas.
Fonte: Apostila Lingagem de Modelagem Unificada

(http://apostilando.net.br/swf/2038.swf em junho de 2012).
Temos a seguir alguns exemplos de linguagens orientadas a objetos:
 Simula
 Smalltalk
 C++
 ADA
 Eiffel
 Object Pascal
 Java
 Common Lisp
 C#
 Perl
 Python
14.3. Fundamentos de Orientação a Objetos
14.3.1. Uma analogia
No capítulo anterior nós aprendemos que a Programação Orientada a Objetos foi

criada para que se tornasse possível fazermos uma simulação do mundo real no nosso
computador. Dessa forma, os objetos reais serão moldados e terão suas características
e comportamentos instruídos através da programação, podendo interagir entre si,
através da troca de mensagens. Essa interação entre os objetos possibilita que uma
tarefa computacional seja realizada.
Cabe ao programador fazer uma análise do objeto do mundo real que será
implementado, observar suas particularidades relevantes e implementá-las, definindo
quais características os objetos podem assumir, e quais ações podem executar. Mas,
como fazer isso?
Naturalmente, os seres humanos costumam agrupar coisas para entendê-las. Por

exemplo, observemos o objeto “Carro”. Facilmente podemos concluir que existem
diversas variações de modelo, forma, cor, tamanho, etc. Porém, mesmo assim
reconheceríamos um carro como sendo um carro, por características que eles têm em
comum, como cor, modelo, fabricante, a ação de frear, de acelerar, e enfim, uma
infinidade de características similares, ainda que cada um possua suas diferenças.

Fonte: http://vidadeprogramador.com.br/
Figura 48 – Tirinha sobre o que é Programação Orientada a Objeto
14.3.2. Objeto x Classe x Instância
Na POO (Programação Orientada a Objetos), os objetos do mundo real são analisados

de uma forma abstrata, ou seja, as características do objeto que são levadas em
consideração são apenas as que são fundamentais para o sistema. E aquilo que é
importante será definido na classe.
Mas, o que é uma classe?
É uma abstração das características relevantes de um grupo de coisas do mundo real.

A classe, em orientação a objeto, é criada para definir no sistema como o objeto vai ser
criado, quais serão suas características (atributos) e suas ações (métodos). Já o objeto
é o componente de software que representa o objeto do mundo real, reunindo atributos
e métodos relacionados, e se relacionando entre si através de mensagens. Uma classe
pode gerar vários objetos.
Chamamos de instância o ato de a classe criar um novo objeto. Em outras palavras,

um objeto é uma instância de uma classe.
Vamos voltar ao nosso exemplo e refletir como podemos criar uma classe para ele:

Classe:
Figura 49 – Exemplo classe Carro
Comumente os conceitos de classe e objetos são confundidos por aprendizes, mas é

importante entender bem essa diferença. Uma classe não é um objeto, mas ela é
usada para criar um. Usamos a classe carro para definir diversos tipos de carro, como
ilustra a tabela a seguir:
Classe Carro Objeto Fusca Objeto Opala

Atributos de Objeto Placa XYZ 0000 ZYX 9999
Cor Preto Vermelho
Fabricante Wolks Wolks
Velocidade 30km/h 120km/h
Métodos de Objetos Método Acelerar
Método Frear
Observe que a classe define quais os tipos de características que o objeto vai ter, e
quando construídos, cada um adquire um conjunto novo de estados. Cada objeto é
único, mesmo que possuam dados idênticos.
Agora, vamos considerar como exemplo um estudante, sendo nosso objeto um aluno.
Para que esse objeto possa ser instanciado, precisamos definir a classe. Fazendo uma
análise abstrata, temos de relevante que um aluno possui nome, idade, matrícula,
notas e média geral. Como ação, temos o ato de calcular a média geral das
disciplinas.Observe:
Classe:
Figura 50 – Exemplo de classe: Aluno

Mas, afinal, como escrever uma classe em códigos? Ao definir como a classe será
usada, temos que obedecer a estrutura a seguir:
<modificador> class <nome_da_classe> {

<atributos>
<construtor>
<métodos>
}
Onde:
 modificador: é a forma como a classe será acessada (estudaremos mais

adiante);
 nome_da_classe: nome da classe, a ser definido pelo programador;
 atributos: declaração dos atributos do objeto;
 construtor: construtor da classe (estudaremos mais adiante);
 método: declaração dos métodos da classe.
Veja como fica em Java:
Figura 51 – Criação da Classe Aluno em Java
Dicas de Programação
Pense em nomes apropriados para a sua classe. Não a chame simplesmente de
classe XYZ ou qualquer outro nome aleatório.
Os nomes de classes devem ser iniciados por letra MAIÚSCULA.
O nome do arquivo de sua classe obrigatoriamente possui o MESMO NOME da sua

classe pública.
 Observação: Fonte das Dicas de Programação:

Balagtas, Florence Tiu. Projeto J.E.D.I. Students Manual.s.l..
14.3.3. Mensagem
Mensagens são requisições enviadas de um objeto para outro para que alguma
operação seja realizada. É a forma como os objetos interagem entre si, enviam e
recebem mensagens e respostas. Eles manifestam essa interatividade através da

invocação de métodos que definem e implementam uma determinada responsabilidade

que o objeto tem.
14.3.4. Atributo
Os objetos possuem atributos, que são informações que definem seu estado. Os
atribtos de cada objeto de uma classe têm seus próprios valores. Em uma classe,
podemos encontrar dois tipos de atributos: atributos de objeto e atributos de classe.
 Atributos de objeto: cada objeto tem seus atributos, e não compartilham com
os outros.
 Atributos de classe são aqueles que têm valores compartilhados por todos
os objetos da classe.
Vamos analisar nosso exemplo, a classe Aluno. Sabemos que a classe tem como
atributos de objeto o nome, a matricula, idade, as notas das disciplinas e a média geral
do aluno. Poderemos ter também um atributo que guarda a média de notas dos alunos
da sala, não fazendo sentido algum essa informação constar em todos os objetos.
Acrescentemos, então, o atributo (de classe) media_turma.
Figura 52 – Exemplo classe Aluno com o atributo de classe media_turma
A seguir, a estrutura para a declaração de um atributo. Escrevemos, dentro da classe:
<modificador> <tipo_do_atributo> <nome_do_atributo> [= <inicialização>];
Onde:
 modificador: forma como o atributo será acessado;

 tipo: tipo de dado;
 nome: nome escolhido pelo programador;
 inicialização: valor inicial que o atributo vai receber.

Figura 53 – Atributos de objeto e atributos de classe da Classe aluno
1 Declare todos os atributos de objeto na parte superior da declaração da classe.
2 Atributos de objeto, assim como qualquer outro atributo devem iniciar com letra
MINÚSCULA.
3 Use o tipo de dado apropriado para cada atributo declarado.
4 Declare atributos de objetos como private de modo que somente os métodos da
classe possam acessá-los diretamente.
14.3.5. Método
Os métodos são as ações que a objeto poderá realizar. É a descrição, em forma de

código, das operações que um objeto executa quando recebe uma mensagem. Pode
ser chamado por qualquer outro método para realizar alguma função específica. Por
exemplo, vamos imaginar um aparelho de som. Sua função é reproduzir músicas, mas
só a executa se receber uma ordem para isso. E essa ordem é passada pelo botão de
ligar, que ao ser acionado, faz com que a música toque. Nesse caso, teríamos que
implementar um método que tivesse a ação de fazer o som tocar. Perceba que um
aparelho de som possui outros botões, cada um com suas responsabilidades diversas
como parar de tocar, gravar, aumentar volume, diminuir.
Os métodos possuem as seguintes características:
 Podem retornar ou não algum valor;

 Podem aceitar ou não repasse de argumentos;
 Após o encerramento de sua execução, o fluxo de controle retorna para
quem o solicitou.
A seguir, a estrutura para a declaração de um método. Escrevemos, dentro da classe:
<modificador> <tipo_do_retorno> <nome_do_método> (<argumentos>){

<instruções>
}
Onde:
 modificador: como o método será acessado;

 tipo_do_retorno: tipo de dado do valor que o método retornará (podendo
também ser void);
 nome_do_método: nome escolhido para o método;
 argumentos: argumentos que serão recebidos pelo método, separados por
vírgula., precedido pelo seu tipo de dado.

Figura 54 – Método que calcula a média geral do aluno
1 Nomes de métodos devem iniciar com letra MINÚSCULA.
2 Nomes de métodos devem conter verbos.
3 Sempre faça documentação antes da declaração do método. Use o estilo javadoc
para isso.
4
14.3.6. Construtores
O construtor de uma classe é utilizado para a construção de um objeto pertencente

àquela classe. Ao ser chamado, todas as inicializações do objeto são declaradas de
forma organizada. Deve ser criado com o mesmo nome da classe, e pode ou não
receber um argumento, podendo inicializar, assim, já com algum tipo de informação
atrbuída.
Definindo um construtor:
<modificador> <nome_da_classe> (<argumento>){

<instrução>
}
Vejamos agora exemplo de construtor sem parâmetros. Um objeto instanciado através

desse construtor terá os valores dos atributos de notas inicializados com 0.
Figura 55 – Exemplo de construtor para a classe Aluno sem parâmetros
Vejamos agora exemplo de construtor com parâmetros. Nesse caso, ao ser chamado,
o construtor irá inicializar os atributos de nome e matrícula com os valores dos
parâmetros.

Figura 56 – Exemplo de construtor para a classe Aluno com parâmetros
14.4. Vamos praticar!
Considerando que você já conhece os comandos básicos, vamos ilustrar nossos

exemplos na linguagem de programação Java. A seguir, a implementação a classe
Aluno com definição de métodos, atributos e objetos instanciados. Observe e
acompanhe os comentários explicativos no código.
Figura 57 – Implementação da classe Aluno com atributos, métodos e construtores
Agora, vejamos a criação de objetos (instância) da classe Aluno na classe principal:
Figura 58 – Instância e utilização de método da classe Aluno
Aula - 15. Encapsulamento

15.1. O que é Encapsulamento?
Encapsulamento é um princípio da programação orientada a objeto que permite que

determinados elementos de uma classe possam ser ocultados de outras classes. Ou

seja, encapsulando, conseguimos esconder dados contidos em uma classe, podendo

ser acessados apenas por intermédio de métodos próprios.
Para que alguma funcionalidade seja utilizada, não é necessário que a forma como ela
foi implementada seja conhecida. Vamos imaginar o funcionamento de um telefone
celular. O usuário faz ligações, recebe, usa a calculadora e o alarme sem ter
conhecimento de como aquelas funções foram desenvolvidas, mas, para que ele as
utilize, basta apenas acessar da forma correta que o aparelho atenderá suas
expectativas, independente de ter sido implementado de uma forma ou de outra.
15.2. Modificadores de Acesso
Agora já sabemos que o encapsulamento nos dá a opção de esconder dados de

objetos. Mas como? Podemos definir esse acesso aos dados de três formas: Público,
Protegido e Particular.
15.2.1. Acesso Público (Public)
No acesso público, os elementos da classe poderão ser acessados tanto de dentro

como de fora da classe. Ou seja, qualquer objeto que interage com a classe poderá
acessar seus elementos que estão públicos.
15.2.2. Acesso Privado (Private)
Já no acesso Privado, o atributo ou o método só poderá ser acessado

internamente, apenas na classe que o definiu.
15.2.3. Acesso Protegido (Protected)
Somente classes do mesmo pacote podem ter acesso aos atributos e métodos no
modo protegido.
15.2.4. Métodos Get e Set
Vimos que podemos definir a forma como os nossos dados serão acessados e
modificados por outros objetos, utilizando os modificadores de acesso. Muitas vezes o
acesso aos dados se dá de forma privada (private), porém, em algumas situações se
faz necessário que outros objetos acessem esses dados. Devemos ter muita cautela ao
declarar esses métodos, só devendo ser declarados em caso de real utilidade. Mas de
qual forma ele fará este acesso, se o dado foi definido como privado?
Set
Utilizamos o método Set para modificar o valor de um atributo. Ele necessita de um

argumento, qual seja, o novo dado a ser atribuído, devendo ser do mesmo tipo de dado
do atributo declarado.

Figura 59 – Implementação dos métodos Set para atributos da classe Aluno
Agora, veja como o método Set é chamado na classe principal:
Figura 60 – Chamada do método Set na classe principal para atribuição de valores
Get
Podemos utilizar o método Get para ler valores de atributos (de objeto ou de classe). O
método deverá retornar um valor, que é a informação contida no atributo, obviamente
com o mesmo tipo de dado. Ao método Get, não é necessário passarmos nenhum
argumento.

Figura 61 – Implementação dos métodos Get para atributos da classe Aluno
Veja abaixo como o método Get é chamado na classe principal. Observe a chamada do
método calculaMediaAluno() definido anteriormente.
Figura 62 – Chamada do método Get na classe principal

Resultado do processamento do programa:
Figura 63 – Saída do programa
Aula - 16. Herança
16.1. O que é herança?
Uma das grandes vantagens do uso da orientação a objetos é justamente a utilização

do conceito de herança. Com a herança o trabalho do programador pode ser otimizado,
pois proporciona uma eficiente e segura política de reutilização de códigos, evitando
assim o retrabalho.
A herança nos permite que características que são comuns a diversas classes sejam
reunidas em uma única classe base. A partir desta, outras classes herdam suas
especificações, e nelas apenas é implementado o que lhes falta, a diferença.
16.2. Superclasse e Subclasse
Essa classe base, que reúne informações comuns a outras classes, é chamada de
Superclasse. Já a Subclasse é uma classe mais específica, que herda as
funcionalidades da Superclasse e ainda adiciona funcionalidades específicas que por
ventura venha a ter.
Esse conceito de Superclasses e Subclasses faz com que exista uma estrutura de
hierarquia entre as classes.
16.3. Herança múltipla
Algumas linguagens de programação suportam a herança múltipla, que permite

que uma subclasse tenha capacidade de herdar características de duas ou mais
superclasses. Assim, uma única classe pode agrupar atributos e métodos de várias
classes. Não é o caso de Java, que não permite essa funcionalidade.
16.4. Classe Object
No Java, a classe Object é a raiz principal, a classe suprema, e a partir dela todas as
outras subclasses são criadas. Ainda que você não expresse que sua classe está
herdando de outra, o Java considera que você está herdando de Object. Sem exceção,
todas as classes herdam de Object, de forma direta ou indireta.

Figura 64 – Hierarquia entre classes
16.5. Vamos praticar!
Vimos o exemplo da implementação da classes Aluno. Imagine agora que desejamos

criar objetos Alunos, mas com uma particularidade: é aluno de uma EEEP. Por estar
em uma Escola Profissional, o aluno, além das notas de português, matemática e
ciências, tem também nota de TESE, FPC e PPE. Vamos utilizar o conceito de herança
para adicionar esses dados, sem precisar repetir todas as demais infromações que já
constam na classe Aluno. Nesse caso, criaremos a classe AlunoEEEP, que herda
funcionalidades da classe Aluno, e podemos acrescentar o que está faltando.
Veja baixo a implementação da subclasse de Aluno, a AlunoEEEP. A primeira coisa

que devemos fazer é mudar na classe Aluno o modificador de acesso de private para
protected, para que os atributos sejam visualizados também pela subclasse.
Figura 65 – Modificador de acesso “protected” para ser acessado também pelas subclasses
Agora vejamos a implementação da classe AlunoEEEP:
Figura 66 – Implementação da subclasse AlunoEEEP, que herda da superclasse Aluno

Implementação dos métodos SETs e GETs na classe AlunoEEEP:
Figura 67 – Métodos SETs e GETs da classe AlunoEEEP
Agora, vejamos a criação de objetos (instância) da classe AlunoEEEP e atribuição de

valores na classe principal:
Figura 68 – Instância de objetos e chamada do método Set na classe principal para atribuição de valores
Veja a chamada dos métodos GETs na classe principal. Observe como o conceito de
herança é praticado pelo objeto da subclasse AlunoEEEP. Ele utiliza métodos de sua
própria classe (calculaMediaTecnicaAluno()) e herda métodos de sua superclasse
(calculaMediaAluno()).

Figura 69 – Instância de objetos e chamada do método SET na classe principal para atribuição de
valores
Resultado do processamento do programa:
Aula - 17. Polimorfismo
17.1. O que é polimorfismo?
A palavra Polimorfismo vem do grego, e significa muitas formas. Em orientação a

objetos, é a capacidade de uma referência mudar de comportamento de acordo com o
objeto a que se refere. Significa que um mesmo tipo de objeto, sob certas condições,
pode se comportar de formas distintas ao receber uma mensagem. Ou seja,
dependendo do contexto da execução, o sistema decidirá qual método será executado.
Através do polimorfismo, a aplicação dos métodos se dá de forma automática, de

acordo com o tipo do objeto. Por exemplo, já implementamos a superclasse Aluno e
criamos objetos “aluFabricio” e “aluCamila”. Depois, criamos uma subclasse
AlunoEEEP, para os estudades de escola profissionalizante, que herda funcionalidades
de Aluno. Dessa classe, criamos os objetos AluMilena e AluRafaela.
Na classe Aluno, criamos o método “calculaMediaAluno()” que faz a média aritmética

das notas de português, matemática e ciências. Já na classe AlunoEEEP, criamos o

método “calculaMediaTecnicaAluno()”, que calcula a média aritmética das disciplinas

técnicas, quais sejam TESE, FPC e PPE.
Vamos refletir sobre a seguinte situação: no momento em que um objeto da classe

AlunoEEEP chama o método “calculaMediaAluno()”, ele se comporta da mesma forma
como para um objeto da classe Aluno: calcula as médias de português, matemática e
ciências. Mas, e se nós quisermos que ele calcule a mética artimética de todas as
disciplinas, inclusive as técnicas, como fazemos? Utilizando o polimorfismo,
conseguimos definir a forma como queremos que nosso objeto se comporte.
Analise o código a seguir e observe que o mesmo método “calculaMediaAluno()” é

implementado de forma a atender as particularidades de cada uma das classes.
Método “calculaMediaAluno()” na classe Aluno:
Figura 71 – Método para calcular a média do aluno na classe Aluno
Método “calculaMediaAluno()” na classe AlunoEEEP:
Figura 72 – Método para calcular a média do aluno na classe AlunoEEEP
Agora, na classe principal, vamos ver como objetos das classes Aluno e AlunoEEEP se
comportam ao chamarem o método “calculaMediaAluno()”:
Figura 73 – Chamada do método “calculaMediaAluno()” de objetos de classes distintas

Observe a saída do sistema. Para os objetos da classe Aluno, o sistema calculou a

média aritmética entre as disciplinas de português, matemática e ciências, como
definido em Aluno. Já para os objetos da classe AlunoEEEP, calculou a média
aritmética das notas de português, matemática, ciências, TESE, PFC e PPE.
Figura 74 – Saída do programa: médias calculadas de acordo com o tipo de objeto
17.2. Sobrecarga de métodos
Sobrecarga de métodos é a propriedade que torna possível a criação de métodos com

o mesmo nome, que executam funções diferentes. Ele saberá de qual maneira deverá
se comportar através da quantidade de argumentos informada. A sobrecarga de
métodos facilita a implementação, pois muitas vezes a mesma operação tem
implementações diferentes para cada situação, e ao invés de criarmos nomes para
cada uma delas, podemos diferenciar apenas através dos argumentos enviados.
Vamos refazer o método “calculaMediaAluno()” para que funcione de outra forma.

Agora, vamos passar as notas a serem calculadas por parâmetro.
Figura 75 – Método “calculaMediaAluno()” implementado com passagem de parâmetro
Chamada do método na classe principal:
Figura 76 – Chama do método “calculaMediaAluno()” na classe principal
A saída do sistema é a média calculada das três notas enviadas por parâmetro:
Agora vamos refletir sobre a seguinte situação: em alguns momentos a média do aluno
de uma escola profissionalizante deve ser calculada apenas com as discilplinas da
base comum, porém em outros momentos é necessário que a nota seja calculada
também incluindo as disciplinas técnicas. Usando o conceito de polimorfismo, podemos
implementar o método “calculaMediaAluno()” na classe AlunoEEEP de forma que,
automaticamente, o programa saiba de que forma calcular: somente com as notas da

base comum, ou incluindo, também, as disciplinas técnicas. Esse reconhecimento é

possível devido a quantidade de argumentos passados. Se a média deve ser calculada
apenas com as notas da base comum, o método deve ser chamado e enviado a ele
apenas os três argumentos. Se é para ser calculada incluindo também as disciplinas
técnicas, então o método é chamado e a ele enviado os seis parâmetros. Vejamos:
Figura 78 – Implementação do método calculaMediaAluno na classe AlunoEEEP, com seis parâmetros
Agora, um mesmo objeto da classe AlunoEEEP chama o método “calculaMediaAluno()”

de duas formas diferentes: uma passando três (03) parâmetros, e outra, seis (06).
Figura 79 – Chamada do método calculaMediaAluno pelo mesmo objeto
O programa retornará resultados diferentes. O conceito de polimorfismo, sobrecarga de

métodos é o que torna possível esse reconhecimento automático de como o método
deve se comportar através os parâmetros informados.
Figura 80 – Resultados diferentes
17.3. Classes e métodos abstratos
Uma classe abstrata é uma superclasse criada apenas para representar entidades e
conceitos abstratos, e dela não são gerados objetos, ou seja, a classe abstrata não é
instanciada.
Geralmente criamos uma classe com um propósito específico, porém, a classe abstrata
tem outra função, ela é criada com a intenção de que outras classes herdem
funcionalidades delas. É definida como um modelo genérico a ser utilizado pelas suas
subclasses.
A utilização de classes abstratas nos proporciona uma redução de código e um ganho

considerável na utilização do polimorfismo, pois com elas podemos criar métodos mais
genéricos que se adaptam a diversos tipos de objetos.
Vejamos um outro exemplo em que se aplica a utilização de classes abstratas. Imagine

uma superclasse “Pessoa” e duas subclasses que herdam suas funcionalidades, quais

sejam “PessoaFisica” e “PessoaJuridica”. Quando cadastramos um cliente, temos que

defini-lo como pessoa física ou pessoa jurídica. Sendo assim, podemos criar a Pessoa
como sendo abstrata para herdar funcionalidades e ganharmos polimorfismo, não
fazendo sentido ser instanciada.
Agora vamos imaginar a nossa classe Aluno contendo os dados básicos comuns a
todos os alunos da rede estadual de ensino. A superclasse Aluno poderá ser abstrata,
tendo como subclasses AlunoConv, AlunoEEEP e AlunoSuperior, que são,
respectivamente, alunos de escolas convencionais, alunos de escolas
profissionalizantes e alunos de ensino superior. Se todos os alunos se encaixam em
um desses três tipos, não faz sentido instanciar a classe Aluno, sendo ela, portanto,
uma classe abstrada.
Figura 81 – Classe abstrata Aluno e subclasses
Vejamos como implementar uma classe abstrata em Java:
Figura 82 – Implementação da classe abstrata Aluno
Métodos abstratos são métodos da classe abstrata que não têm implementação. Eles
são declarados apenas com a assinatura, sem o corpo e com a palavra-chave abstract.
Dicas de Programação (9)
Use classes abstratas para definir muitos tipos de

comportamentos no topo de uma hierarquia de classes de
programação orientada a objetos. Use suas subclasses
para prover detalhes de implementação da classe abstrata.

Exercício Prático
FASE IV – ANÁLISE DE SISTEMAS
Aula - 18. Introdução a Sistemas
Inicialmente, vamos definir alguns conceitos básicos para posteriormente assimilarmos

o conteúdo de Análise de sistemas.
18.1.1. O que é dado?
“Dados são itens referentes a uma descrição primária de objetos, eventos, atividades e
transações que são gravados, classificados e armazenados, mas não chegam a ser
organizados de forma a transmitir algum significado específico” (Turban, McLean e
Wetherbe, 004, pg. 63).
18.1.2. O que é uma informação?
“Informação é todo conjunto de dados organizados de forma a terem sentido e valor

para seu destinatário. Este interpreta o significado, tira conclusões e faz deduções a
partir deles. Os dados processados por um programa aplicativo têm uso mais
específico e maior valor agregado do que aqueles simplesmente recuperados de um
banco de dados. Esse aplicativo pode ser um sistema de gerenciamento de estoques,
um sistema de matrículas online de uma universidade, ou um sistema de Internet para
compra e venda de ações”. (Turban, McLean e Wetherbe, 2004, pg. 63).
18.1.3. O que é conhecimento?
“Conhecimento consiste de dados e informações organizados e processados para

transmitir compreensão, experiência, aprendizado acumulado e técnica, quando se
aplicam a determinado problema ou atividade. Os dados processados para extrair
deduções críticas e para refletir experiência e perícia anteriores fornecem a quem os
recebe conhecimento organizacional, de alto valor potencial”. (Turban, McLean e
Wetherbe, 2004, pg. 63).
18.1.4. Dado, Conhecimento e Informação.
Observe nas imagens abaixo a distinção entre Dados, Informações e Conhecimento:

Resultado do processo cognitivo, iniciado por um

novo estímulo qualquer. Informação valiosa da
mente humana. Inclui reflexão, síntese e contexto.
Frequentemente tácito. De difícil estruturação,
captura em máquinas e transferências.
São dados dotados de relevância e

propósito. Requer unidade de análise.
Exige consenso em relação ao significado
e é necessária a mediação humana.
Simples observações sobre o

estado do mundo. Facilmente
estruturado, obtido por máquina e
transferível. Frequentemente
Figura 84 - Dado, Informação e Conhecimento
Tabela 20 - Dado, Informação e Conhecimento (9)
DADO INFORMAÇÃO CONHECIMENTO

Simples observações Dados dotados de Informação valiosa da
sobre o estado do mundo relevância e propósito mente humana. Inclui
reflexão, síntese,
contexto.
Facilmente estruturado Requer unidade de análise De difícil estruturação
Facilmente obtido por Exige consenso em De difícil captura em
máquinas relação ao significado máquinas
Frequentemente Exige necessariamente a Frequentemente tácito
quantificado mediação humana
Facilmente transferível De difícil transferência
Exemplo
Através dos conceitos acima, já podemos ter uma ideia do significado de dados,
informações e conhecimentos para um Sistema de Informação. Vamos analisar um
exemplo:
Milena é aluna de uma EEEP. Assim como todos os demais, possui um boletim com
notas de diversas disciplinas. Essas notas nada mais são do que números que de
alguma forma foram friamente calculados, gerados e impressos em um papel através
de uma programação. As notas ali contidas são nada mais do que dados.
Se analisarmos seu boletim, podemos observar que todas as suas notas são boas, pois
estão bem acima da média. Contextualizando esses dados, obtemos uma informação:
Milena é uma ótima aluna.
Indo mais além, analisando o seu comportamento, temos que ela é uma aluna proativa
em sala de aula, administra bem o seu tempo, utiliza as aulas de estudo para de fato
estudar e pratica a TESE como sua filosofia de vida. Contextualizando essas
informações chegamos a um conhecimento sobre a pessoa de Milena.

18.2. O que é um sistema
Para termos uma real compreensão do que é um Sistema de Informação, faz-se

necessário anteriormente entender o que é um Sistema. Nesse sentido, é válida a
definição apontada no site Wikipédia, em junho de 2012: “Sistema (do grego sietemiun)
é um conjunto de elementos interconectados, de modo a formar um todo organizado. É
uma definição que acontece em várias disciplinas, como biologia, medicina,
informática, etc. Vindo do grego o termo “sistema” significa “combinar”, “ajustar”,
“formar um conjunto””.
Segundo Chiavenato (1999) e Oliveira (2002), o sistema apresenta os seguintes

componentes:
 Objetivos: é a finalidade para o qual o sistema foi criado;

 Entradas do Sistema: é o que inicia o sistema, traz a informação para a
operação do sistema;
 Processamento: fenômeno que realiza as mudanças, é o mecanismo que
converte as entradas em saídas;
 Saídas do Sistema: são os resultados do processamento.
 Retroalimentação ou feed back do sistema: é a informação gerada pelo
sistema que informa sobre o comportamento do mesmo;
 Ambiente: é o meio que envolve externamente o sistema.
De posse da definição podemos definir o Sistema de Informação ou simplesmente SI,

como sendo um conjunto organizado de dados, cujo elemento principal é a informação.
Sua função principal é o armazenamento, tratamento e fornecimento de informação
que de forma organizada servem de apoio a funções ou processos de uma empresa,
por exemplo. Um SI não necessita, necessariamente, ser computadorizado. As fichas
organizadas dos alunos em uma academia de musculação formam, por exemplo, um
sistema de informações.
Os sistemas de Informação podem ser divididos em subsistemas e, em muitos modelos

aparecem dois deles, sendo um com processos, pessoas, documentos e informações,
enquanto o outro apresenta os meios automatizados como, por exemplo, as máquinas,
redes de comunicação e computadores. Ao primeiro chamamos de subsistema social e
o segundo denomina-se subsistema automatizado. Do apresentado até aqui fica fácil
perceber que o Sistema de Informações é conteúdo bastante amplo, já que inclui
pessoas, dados, processos, programas (softwares), maquinários (hardware), etc.
Todos os aspectos que envolvem o Sistema possuem importância significativa, já que

funcionam como uma verdadeira engrenagem, ou seja, uma fase depende da outra,
uma peça ajuda a outra, enfim, todos se complementam. Assim, hardware, software,
fator humano e qualidade das informações, são igualmente válidos para o
funcionamento com excelência.
Tomemos por exemplo uma lanchonete que buscou implantar um Sistema de

Informação com o intuito de garantir maior agilidade no atendimento dos clientes. Para
tanto pensou em um cardápio fixo, comprou computadores eficazes e alocou código de
barras nas embalagens. Aparentemente esta medidas poderiam sim agilizar o

atendimento, porém, se os colaboradores não forem capacitados para utilizar as
ferramentas, certamente ao invés de garantir maior agilidade no atendimento, pode até
mesmo causar maior embaraço.
Os sistemas de informação são poderosas ferramentas e, nesta concepção

apresentam diversas aplicações e benefícios, dentre eles podemos citar:
organizar/incrementar a produtividade; fortalecer estratégias de marketing; formatar a
qualificação dos colaboradores; estabelecer rotinas de controle de produtos (entrada e
saída – preços – lucros, etc.).
18.3. Como construir um Sistema de informação baseado em computador
Dizemos que um Sistema de informação é baseado em computador quando ele realiza

parte - ou mesmo todas – as tarefas desejadas por meio da computação. Para que um
sistema de informação obtenha sucesso na realização de suas rotinas, é preciso que
se entenda todos os processos e procedimentos relacionados à tarefa a ser executada.
Ou seja, é indispensável que se tenha um convívio direto com os problemas e soluções
diárias naquele contexto em que o sistema será implantado, pois esse conhecimento
profundo é o que vai dar embasamento para o desenvolvimento de um Sistema de
Informação que seja realmente eficiente.
Em posse de um objetivo, qual seja planejar e desenvolver a construção de um

Sistema de Informação eficiente para determinada situação, devemos analisar outros
fatores decisivos nesse processo. O ambiente no qual o sistema será implantado é um
deles, e pode influenciar de forma direta ou indireta no funcionamento de um sistema.
Por exemplo, poderemos obter resultados completamente diferentes ao implantar um
sistema on-line em uma cidade capital de estado, onde o acesso à internet é
incorporado ao cotidiano dos supostos usuários, e em uma pequena cidade do interior
onde o acesso à rede ainda é um privilégio restrito a poucos. Nesse caso, o fator
internet é determinante para o sucesso ou insucesso do Sistema de Informação.
Outro fator que influencia de forma direta o desenvolvimento do sistema são os

chamados recursos de sistema, que são os recursos indispensáveis à construção de
um Sistema de Informação. São exemplos deles: dinheiro, máquinas, pessoas
capacitadas, ambiente físico, papéis, etc.
Além dos fatores citados, outro a ser considerado é a análise dos dados relevantes
para o Sistema de Informação. Tais dados devem ser cuidadosamente examinados,
ponderados e utilizados de forma consistente, a fim de gerarem informações que de
fato sejam úteis aos usuários. Um sistema que considera a entrada de dados
inconsistentes em seu funcionamento, como data em branco ou preços com valores
nulos, certamente não chegará a uma saída interessante.
Mas, afinal, a quem compete este trabalho?

18.4. O papel do Analista de Sistemas
O profissional da Tecnologia da Informação responsável por todo este trabalho é o

Analista de Sistemas. Ele é, na prática, um solucionador de problemas e exerce uma
função bastante complexa, que é concretizar em um software todo um sistema de
informação.
Um bom analista de sistemas tem como principais características:
 Conhecimento teórico e prático de computação;

 Ampla visão organizacional e empresarial;
 Bom senso na tomada de decisões;
 Bom relacionamento interpessoal para lidar com todos envolvidos no projeto;
Figura 85 - Qualidades do analista de sistemas
“É muito difícil criar produtos usando grupos foco. Muitas vezes, as pessoas
não sabem o que elas querem até que você mostre a elas.”
Steve Jobs
18.5. Fases do desenvolvimento de sistemas
Já sabemos o que é um sistema de informação, quais seus fatores principais e quem é

o responsável por desenvolvê-lo. Vamos agora entender como se dá todo esse
processo, desde o início da ideia até a conclusão de seus trabalhos.
Como vimos, a construção de um software é um processo complexo e para que se

obtenha sucesso, seu desenvolvimento deve seguir uma exigente metodologia de
trabalho. Vejamos cada uma das fases desse processo:
18.5.1. Concepção do Sistema
É uma fase de descobertas. Requer que todos os envolvidos – desenvolvedores e

usuários - mantenham postura colaborativa para que os requisitos levantados sejam o

mais próximo possível da realidade. Baseado nessas informações, o analista de

sistemas consegue fazer um diagnóstico da situação e uma previsão de ações.
18.5.2. Estudo da Viabilidade
Após a apropriação do contexto na fase anterior, é feito um estudo para avaliar se o

projeto é ou não viável de ser implementado, do ponto de vista organizacional,
tecnológico e financeiro. A decisão da continuidade ou não do projeto cabe aos
analistas e aos gestores da organização que será beneficiada.
Nessa fase, são analisados os seguintes questionamentos:
 O sistema poderá contribuir de fato para realização dos objetivos previstos?

 O sistema poderá ser implementando, apesar de restrições de cunho
tecnológico, organizacional e temporais?
 Existe outro modo eficiente de realização dessas tarefas sem a necessidade
de criação desse sistema?
 O sistema atual realmente pode resolver os problemas não solucionados
pelos anteriores?
 É possível sua integração a sistemas já em funcionamento?
Caso os responsáveis optem pela continuidade do projeto, o mesmo será submetido à

fase seguinte. Caso contrário, o ciclo termina aqui.
18.5.3. Processo de Análise
Essa etapa consiste em realizar um levantamento de dados e de fatos, a fim de

entender o que realmente precisa ser feito para solucionar o problema. O contato entre
analista de sistemas e usuários deve se estreitar nesse momento, pois é preciso um
entendimento detalhado e técnico por parte do analista. Caso já exista algum sistema
em funcionamento, este é o momento em que o analista se apropria de maiores
detalhes do mesmo.
Deverá ser criado um modelo lógico do sistema, constituído, entre outros, do diagrama
de fluxo de dados, dicionário de dados e principais algoritmos.
Até o término dessa fase, já devem ser de conhecimento do analista os objetivos

principais do sistema em questão, quais setores da empresa serão impactados pelo
sistema, como este deverá funcionar, qual será o fluxo de dados, quais serão os
arquivos utilizados e a forma como serão atualizados, qual setor será responsável pela
população do sistema, qual o prazo para que esses dados sejam processados e
apresentado algum resultado aos usuários.
18.5.4. Projeto do Sistema
Nesse momento, o analista propõe soluções para o problema baseado em conclusões

das fases anteriores. Para cada alternativa sugerida, apresenta-se aos gestores da
organização um diagrama de fluxo de dados, para que seja feita uma escolha baseada
em custos e benefícios. O modelo lógico foi sendo transformado em modelo físico.

Ao final da fase, já deverá estar definido pelo analista um relatório contendo qual tipo
de banco de dados será adotado pelo sistema, os arquivos que serão utilizados, a
definição dos arquivos de dados e seus layouts, relatórios a serem emitidos e os tipos
de dispositivos de armazenamento de dados.
18.5.5. Projeto Detalhado
Tomada a decisão, é hora de dar início a implementação do sistema. O analista de

sistemas já sabe o que deve ser feito, tecnicamente, para dar inicio a esse processo.
Nesse momento, os relatos dos usuários ainda podem ser de grande valia para a
condução do sistema. O analista de sistemas deve definir quais programas irão compor
o sistema, e produzir as especificações referentes a cada um deles, especificações
essas que serão posteriormente entregues e codificadas pelos programadores.
Exemplos de especificações definidas nesta fase:
 Aprimoramento do fluxo de dados da alternativa escolhida;

 Identificação do banco de dados ou arquivos a serem utilizados;
 Detalhamento de arquivos de dados e seus layouts;
 Criação de layouts de relatórios a serem emitidos pelo sistema;
 Especificação de todos os programas que irão compor o sistema;
 Revisão na estimativa de custos;
 Preparação da documentação inicial do sistema;
 Definição dos tipos de dispositivo de armazenamento;
 Elaboração de um plano de testes;
18.5.6. Implementação
A fase de implementação é quando de fato o programa começa ser construído na

plataforma escolhida, tendo como base as especificações produzidas. É, de todas, a
fase mais cara.
Os programas que se referem ao gerenciamento do sistema em geral deverão ser os

primeiros a serem construídos, e só após, os demais.
Inicia-se, após a finalização dos programas, os testes. Todo o sistema deve ser testado
exaustivamente antes de ser posto em funcionamento. Ainda nesta fase, os erros
detectados na homologação (testes) são corrigidos e testados novamente.
Uma vez sem erros, a equipe deve dedicar-se a escrever os manuais do usuário, um
tutorial contendo todas as informações necessárias para seu funcionamento.
18.5.7. Implantação e Manutenção
Finalmente, chegamos à implantação e manutenção, última fase da criação de um

sistema. Implantar significa colocar o sistema em fase de operação, ou seja, realizar as
instalações necessárias para o uso do sistema no local predefinido. Uma vez
implantado, os usuários deverão ser treinados a operar corretamente o sistema.

Ao ser submetido ao uso real, o sistema ainda poderá apresentar alguma falha,
portando a equipe de analista e programadores ainda pode realizar ajustes.
Agora, é apenas manter em pleno funcionamento, desenvolvendo pequenas melhorias

e adequações quando necessário.
Figura 86 - Fases do desenvolvimento de sistemas

Aula - 19. Requisitos
19.1. Introdução
Os requisitos de um sistema são os elementos que a equipe de desenvolvimento

precisa conhecer para que o software seja desenvolvido. São as necessidades que
deverão ser atendidas pelo sistema de informação que será proposto. Em posse
dessas informações, o analista tem propriedade para propor soluções, especificar e
desenvolver um sistema de informação. Segundo Sewbok, “Um requisito de software é
uma propriedade que deve ser implementada para resolver um problema do mundo
real”.
Acontece que tomar conhecimento desses requisitos é uma tarefa que, na prática, não
é tão simples como parece. Muitas vezes os próprios gestores e usuários não
conseguem expressar claramente seus objetivos. Por desconhecerem os
procedimentos técnicos que regem um Sistema de Informação, muitas vezes eles
ocultam informações de extrema importância, fundamentais para o planejamento da
solução.
Nesse ponto, a atuação do analista de sistemas é decisiva para o sucesso ou não do

trabalho. Dificilmente todas essas informações irão estar reunidas em uma pessoa só,
portando o analista tem que conversar com pessoas de todos os setores que irão
utilizar o sistema, pois precisa ter uma visão de todas as funcionalidades que irá
implementar. É preciso conhecer a dinâmica de trabalho de cada envolvido. Por
exemplo, dificilmente o gerente de vendas de uma empresa saberá com precisão como
o almoxarifado controla a saída de produtos, ou como exatamente a cozinha mantém o
controle sobre seu estoque, portando, é atribuição do analista capturar esse processo
pessoalmente.
19.2. Levantamento de requisitos
Como vimos, o analista de sistemas é o responsável intermediar e identificar os

requisitos. Para isso, ele dispõe de algumas técnicas que o auxiliam a estreitar as
relações com os usuários, visando obter dos clientes o máximo de informações úteis.
Entre as técnicas utilizadas para este processo, podemos destacar, entre outras, as
seguintes:
19.2.1. Entrevista
É uma das formas mais eficientes de se obter as informações desejadas. Não existe
uma fórmula ou receita certa para a sua condução, mas, para obter um melhor
resultado, o analista deve atuar de forma racional e metódica, com certa flexibilidade,
porém, sem improvisações desnecessárias.
O analista deve ter manter na entrevista um clima amistoso, deixando o entrevistado à

vontade. Ele deve entender que a entrevista não é um julgamento, pois se por algum
motivo se sentir acanhado, poderá não prezar pela veracidade das informações.

Outros fatores importantes em uma entrevista são: bom relacionamento interpessoal do

entrevistador, habilidade ao se comunicar e humildade.
19.2.2. Pesquisa
Embora a entrevista seja uma técnica altamente eficaz, não deve ser a única fonte de
levantamento de requisitos. Outra forma de se obter dados interessantes é a pesquisa.
O analista poderá analisar documentos e relatórios gerados em diversos setores, além
de arquivos, e baseado neles tirar outras conclusões, que podem vir a somar com o
resultado já obtido na entrevista.
19.2.3. Questionário
Quando o sistema envolve um número muito grande de usuários, a aplicação de

questionários é uma boa estratégia de pesquisa. Com perguntas sucintas, objetivas e
sem dubiedade, é possível observar o padrão de respostas e dele retirar pertinentes
conclusões.
19.2.4. Reuniões
São encontros com a participação de alguns usuários envolvidos, para discussões em

grupo. Deve ser conduzida de forma hábil pelo mediador, mantendo sempre o foco,
qual seja a discussão sobre as rotinas da organização para uma maior percepção dos
requisitos por parte do analista.
19.2.5. Observações
Mesmo utilizando técnicas como entrevista ou reunião, algumas informações podem

passar despercebidas. Observar o comportamento e o ambiente de trabalho dos
usuários pode ser uma técnica eficaz para perceber alguma dessas informações que
porventura não foi levada em consideração em outro momento.
19.3. Análise de Requisitos
19.3.1. Requisitos Funcionais
Requisitos funcionais são aqueles que descrevem funcionalidades que o sistema deve
ter para atender às expectativas dos usuários. Por exemplo:
 O software deverá calcular a média de notas dos alunos;

 O software deverá enviar, a cada semestre, um email para os pais com o
boletim de seus filhos em anexo;
 O software deverá emitir relatório de compras quinzenalmente;
 O software deverá alertar ao chefe do restaurante quando o estoque estiver
abaixo do estabelecido.
19.3.2. Requisitos Não Funcionais
Já os requisitos não funcionais são aqueles que descrevem as características do

sistema, como usabilidade, desempenho, confiabilidade, custo, etc. São exemplos de
requisitos não funcionais:
 O acesso às funcionalidades de gestão deve ser restrito aos diretores da

empresa;
 Se o tempo de resposta ultrapassar 30 segundos, redirecionar para página
de erro;
 O software deverá ser desenvolvido para operar no sistema operacional
Linux;
 O prazo de entrega do sistema ao cliente deve ser de 2 anos.
19.3.3. Requisitos do usuário
Requisitos de usuário são declarações escritas, em linguagem natural, das

funcionalidades que o sistema oferece. No documento, deve constar basicamente a
descrição dos requisitos funcionais, requisitos não funcionais, devendo conter inclusive
as restrições operacionais do sistema. Este material destina-se ao cliente, portanto
deve ser escrito em linguagem clara e compreensível, além de conter tabelas e
diagramas, visto que os usuários não possuem conhecimentos técnicos em
desenvolvimento de sistemas.
A quem interessa:
 Gerentes de clientes
 Usuários finais do sistema
 Engenheiros do cliente
 Gerentes do fornecedor
 Arquitetos do sistema
19.3.4. Requisitos do sistema
Consiste em um documento estruturado, que estabelece detalhes das funcionalidades

e restrições do sistema. Pode ser elaborado como forma de contrato entre o cliente e
contratante.
A quem interessa:
 Usuários finais do sistema

 Engenheiros da organização cliente
 Arquitetos do sistema
 Desenvolvedores de software
19.3.5. Especificação de Software
É um documento que consiste em uma minuciosa descrição do sistema, que vem a

servir como base para a implementação do mesmo. As especificações de software são
destinadas aos próprios desenvolvedores.
A quem interessa:
 Engenheiros da organização cliente

 Arquitetos do Sistema
 Engenheiros de Software
Aula - 20. Unified Modeling Language – UML
20.1. O que é UML
A Unified Modeling Language (UML), ou em português, Linguagem de Modelagem

Unificada, é uma linguagem visual que permite a especificação, visualização e
documentação de artefatos pertencentes a um Sistema de Informação orientado a
objeto. Pode ser utilizada ao longo de todo o processo de construção do software, e
tem como propósito auxiliar o entendimento entre os envolvidos no projeto, quais sejam
desenvolvedores e usuários, pois permite que os trabalhos possam ser visualizados em
diagramas padronizados. Seu principal propósito é facilitar a percepção do sistema em
sua totalidade, ajudando também na concepção de ideias.
Foi desenvolvida em 1994 por Grady Booch, James Rumbaugh e Ivar Jacobson,
criadores das três metodologias mais conceituadas de modelagem de sistemas
orientados a objetos, que juntos, resolveram fazer uma compilação dessas três
técnicas, trazendo as melhores ideias de cada uma delas.
A UML surgiu como uma tentativa de padronizar o processo de modelagem de tal

modo que qualquer sistema possa ser modelado de forma correta e consistente, tendo
fácil integração a outras aplicações, simples de ser atualizado e compreensível aos
humanos e às máquinas. Serve para dar um maior suporte a problemas até então
enfrentados por desenvolvedores.
A falta de uma notação padronizada e eficaz durante os processos do desenvolvimento

de um software fazia com que a modelagem de sistemas orientados a objeto se
tornasse numa tarefa de difícil execução, onde nem os desenvolvedores entre si
conseguiam se entender, ficando essa comunicação ainda mais complicada quando se
tratava de terceiros alheios aos conhecimentos técnicos da computação, como os
clientes. Não se trata de uma metodologia de desenvolvimento, pois não irá conduzir o
que deve ser feito primeiro ou como o sistema deve ser modelado, mas auxilia, através
de seus diagramas, na visualização do projeto como um todo.
Hoje, a UML é considerada a linguagem mais expressiva para modelagem de sistemas

de informação orientado a objeto.
Vejamos uma definição formal:
“UML (Unified Modeling Language) é uma família de notações gráficas, apoiadas por
um metamodelo único, que ajuda na descrição e no projeto de sistemas de software,
particularmente daqueles construídos utilizando o estilo orientado a objetos (OO).”
Fonte: FOWLER, Martin. UML Essencial. 3 ed. Porto Alegre: Bookman,2005.

20.2. Diagramas UML
Mas, como a UML faz tudo isso? Utilizando diagramas. Os diagramas são ilustrações
gráficas de uma coleção de elementos, que descrevem o sistema, capturando
diferentes aspectos do mesmo.
São divididos em e Diagramas Estruturais e Diagramas Comportamentais, como

mostra o texto e a imagem abaixo. (Fonte: http://www.infoescola.com/engenharia-de-
software/uml/, em 06/2012).
Diagramas Estruturais:
 De Classe: Este diagrama é fundamental e o mais utilizado na UML e serve

de apoio aos outros diagramas. O Diagrama de Classe mostra o conjunto de
classes com seus atributos e métodos e os relacionamentos entre classes.
 De Objeto: O diagrama de objeto esta relacionado com o diagrama de
classes e, é praticamente um complemento dele. Fornece uma visão dos
valores armazenados pelos objetos de um Diagrama de Classe em um
determinado momento da execução do processo do software.
 De Componentes: Está associado à linguagem de programação e tem por
finalidade indicar os componentes do software e seus relacionamentos.
 De Pacotes: Representa os subsistemas englobados de forma a determinar
partes que o compõem.
 De Estrutura: Descreve a estrutura interna de um classificador.
Diagramas Comportamentais:
 De Caso de Uso (Use Case): Geral e informal para fases de levantamento

e análise de Requisitos do Sistema.
 De Máquina de Estados: Procura acompanhar as mudanças sofridas por um
objeto dentro de um processo.
 De Atividades: Descreve os passos a serem percorridos para a conclusão de
uma atividade.
 De Interação: Dividem-se em:
o De Sequência: Descreve a ordem temporal em que as mensagens
são trocadas entre os objetos.
o Geral interação: Variação dos diagramas de atividades que fornece
visão geral dentro do sistema ou processo do negócio.
o De comunicação: Associado ao diagrama de Sequência,
complementando-o e concentrando-se em como os objetos estão
vinculados.
o De tempo: Descreve a mudança de estado ou condição de uma
instância de uma classe ou seu papel durante o tempo.

Figura 87 - Diagramas da UML
A seguir, falaremos de três deles.
20.2.1. Diagramas de Classe
Ao estudarmos Programação Orientada a Objetos, aprendemos como representar uma

classe. Relembremos:
Figura 88 - Representação de uma classe
Na UML, representamos a acessibilidade dos atributos e métodos através dos sinais de

“+” e “-” à frente do atributo / método. Vejamos:
Tabela 21 - Sinais de acessibilidade de atributos e métodos
+ atributo / método público public
# atributo / método potregido protected
- atributo / método privado private
O Diagrama de classes representa a estrutura estática do sistema. As classes devem

ser retiradas através de uma análise do domínio do problema, e seus nomes devem
conter o que elas representam no sistema. A seguir, veremos alguns com
questionamentos que podem auxiliar a identificação de classes de um sistema,

retirados da após (fonte: http://www.slideshare.net/glaucocardozo/apostila-uml-
8177684, em 06/2012):
 Existem informações que devem ser armazenadas ou analisadas? Se existir

alguma informação que tenha que ser guardada, transformada ou analisada
de alguma forma, então é uma possível candidata para ser uma classe.
 Existem sistemas externos ao modelado? Se existir, eles deverão ser vistos
como classes pelo sistema para que possa interagir com outros externos.
 Existem classes de bibliotecas, componentes ou modelos externos a serem
utilizados pelo sistema modelado? Se sim, normalmente essas classes,
componentes e modelos conterão classes candidatas ao nosso sistema.
 Qual o papel dos atores dentro do sistema? Talvez o papel deles possa ser
visto como classes, por exemplo, usuário, operador, cliente e daí por diante.
Figura 89 - Exemplo de daigrama de classe UML
20.2.2. Diagramas de Sequencia
Os diagramas de sequencia representam a ordem temporal dos objetos envolvidos na

interação. Exibe a colaboração dinâmica entre determinados objetos, mostrando a
troca de mensagens entre eles em um determinado cenário. Sua ilustração auxilia os
desenvolvedores a visualizar a implementação dos métodos, e se a comunição entre
as classes está se dando de forma coerente. Vejamos:

Figura 90 - Exemplo de diagrama de sequência UML
20.2.3. Diagrama de Caso de Uso
“O diagrama de casos de uso especifica um conjunto de funcionalidades, através do

elemento sintático “casos de uso”, e os elementos externos que interagem com o
sistema, através do elemento sintático “ator”” (SILVA, 2007).
Figura 91 – Interação entre ator e funcionalidade UML
Representam as funcionalidades do sistema vistas a olhos externos, proporcionando

um maior entendimento de seu comportamento no contexto do seu ambiente.
É composto por:
 Atores: pessoas que interagem de alguma forma com o sistema ou

entidades externas, como por exemplo, outros sistemas, que também
exercem alguma interação com o sistema;
 Casos de Uso: descrevem as funcionalidades do sistema percebidas por
olhares externos, e são geralmente descritos textualmente;
 Relacionamentos: é a relação existente entre atores e casos de uso.

Figura 92 - Exemp0lo de diagrama de caso de uso UML
Tabela 22 - Descrição de um Caso de Uso UML
Gerenciar Contas Usuários

Quem inicia Ator Administrador
Pré-Condição Nenhum outro administrador deve estar logado no sistema
1. O Administrador informa seu login/senha
2. O sistema verifica na ACL se o usuário tem privilégios
especiais
3. Se o usuário não for um super-usuário interrompe o
Cenário 1: processo
Criar Nova Conta 4. O sistema mostra a lista de usuários e grupos
5. O Administrador entra com as seguintes informações:
-nome do novo usuário, diretório home, senha inicial, privilégios,
data de expiração da conta
6. As informações da nova conta são gravadas na ACL
Fluxo de exceção
Exemplos de ferramentas UML

DIA: Umbrello: ArgoUML:
http://projects.gnome.org/dia/ http://www.umbrello.org/ http://argouml.tigris.org/
DBDesigner: ASTAH:
http://www.fabforce.net/ http://www.astah.net/

Exercício Prático
Bibliografia
1. Antonio Manso, Célio Marques, Pedro Dias. http://www.dei.estt.ipt.pt/portugol. s.l. : Instituto
Politécnico de Tomar.
2. Caelum Ensino e Inovação. Java e Orientação a Objetos. [www.caelum.com - 10/05/2012]. São Paulo,
São Paulo, Brasil : www.caelum.com, 10 de 05 de 2012.
3. Wikipedia. Java (linguagem de progração).

[http://pt.wikipedia.org/wiki/Java_%28linguagem_de_programa%C3%A7%C3%A3o%29 – 10/05/2012]
2012.
4. School of Information System. Java Virtual Machine.

[https://wiki.smu.edu.sg/is200/Java_Virtual_Machine - 09/05/2012] s.l. : Singapore Management
University.
5. Wikipedia. Java Runtime Environment. [http://pt.wikipedia.org/wiki/Jre – 11/05/2012] 2011.
6. —. Java Development Kit. [http://pt.wikipedia.org/wiki/Jre – Em: 11/05/2012] 2011. a.
7. Kathy Sierra, Bert Bates. Use a Cabeça - Java. Rio de Janeiro : O'Reilly, 2005.
8. ScriBD. Desenvolvimento de Software Orientado a Objetos.

[http://pt.scribd.com/doc/56735259/2/Desenvolvimento-de-Softwares-orientado-a-objetos]
01/06/2012.
9. DAVENPORT, T H e PRUSAK, L. Conhecimento empresarial. Rio de Janeiro : Campus, 1988.
10. Balagtas, Florence Tiu. Projeto J.E.D.I. Students Manual. s.l. :

http://edu.netbeans.org/contrib/jedi/Intro-to-Programming-1/student-manual.pdf, 2006.
11. de Souza, Marcos Antônio Furlan e Goncílio, Marcelo Marques. Algoritmos e Lógica de
Programação. s.l. : Thomson.
12. Deitel, Harvey M. e Deitel, Paul J. Java como Programar 8ª Ed. s.l. : Pearson.
13. Ascencio, Ana Fernanda Gomes e Ven, Edilene Aparecida. Fundamentos da Programação de
Computadores – Algoritmos, Pascal, C/C++, JAVA 2 Edição. s.l. : Pearson Prentice Hall.
14. Forbellone, André Luiz Villar. Lógica de Programação – A Construção de Algoritmos e Estruturas de
Dados. São Paulo : Makron, 1993.
15. Puga, Sandra e Rissetti, Gerson. Lógica de Programação e Estruturas de Dados. s.l. : Pearson.
16. Lingagem de Modelagem Unificada. S.l.: s.n. : [http://apostilando.net.br/swf/2038.swf], junho de

2012.

17. Evolução Educação e Tecnologia. Orientação a Objetos com Java. [www.evolucao.com.br – junho de
2012].

Apêndice A – Exercícios Práticos
Aula 1 – Introdução a Lógica de Programação
1. Através das premissas a seguir, assinale as sentenças que correspondem à

conclusão correta.
A. Se o semáforo com a luz vermelha é para o motorista parar e o verde para
seguir, estando eu a pé para atravessar a rua então concluo que:
B. Posso atravessar a rua com a luz vermelha.
C. O semáforo tem duas luzes.
D. Só devo atravessar a rua com a luz verde.
2. Patos são animais. Patos têm duas patas. Logo:
E. Todo o animal tem duas patas.
F. Patos têm duas patas.
G. Patos tem bico.
3. Desafio dos nove pontos o objetivo é traçar quatro linhas retas passando por
todos os nove pontos, sem tirar o lápis/caneta do papel. Para facilitar o
raciocínio e a resolução, marque os nove pontos em uma folha de papel e tente
resolver.
Resposta: Segue o resultado do desafio

do jogo dos nove pontos. Para quem
ainda não entendeu como resolver, o
lápis saiu do número 7.
Aula 3 – Introdução aos Algoritmos

4. Crie uma sequência lógica para tomar banho:
5. Descreva com detalhes a sequência lógica para Trocar um pneu de um carro.
6. Faça um algoritmo para trocar uma lâmpada. Descreva com detalhes:
7. Escreva um algoritmo que receba 2 números e exiba o resultado da sua soma.
8. Escreva um algoritmo que receba 2 números e ao final exiba o resultado da

subtração, multiplicação e divisão dos números lidos.

9. Escreva um algoritmo que receba o ano atual, ano de nascimento de uma

pessoa e mostre a sua idade.
10. O Sr. João necessita saber o consumo médio de um automóvel, e solicitou para
você desenvolver um algoritmo que sendo fornecido a distancia total percorrida
pelo automóvel e o total de combustível gasto, mostrar o consumo do
automóvel.
11. Escreva um algoritmo que leia o nome de um vendedor, o seu salário fixo e o
total de vendas efetuadas por ele no mês (em dinheiro). Sabendo que este
vendedor ganha 15% de comissão sobre suas vendas efetuadas, informar o seu
nome, o salário fixo e o salário no final do mês.
12. Ler uma temperatura em graus Celsius e apresenta-la em Fahrenheit. A fórmula

de conversão é: F=(9*C+160)/5, sendo F Fahrenheit e C Celsius.
13. A loja ELETROMOVEIS esta vendendo os seus produtos no cartão em 5 vezes

sem juros, Faça um algoritmo que receba o valor da compra e mostre o valor
das parcelas.
Aula 4 – Elementos Utilizados nos Algoritmos em Pseudocódigo
14. O que é uma constante? Dê dois exemplos.
15. O que é uma variável? Dê dois exemplos.
Aula 4 – Elementos Utilizados nos Algoritmos em Pseudocódigo (Teste de

Mesa)
16. Tendo as variáveis SALARIO, IR e SALLIQ, e considerando os valores abaixo.
Informe se as expressões são verdadeiras (V) ou falsas (F).
17. Sabendo que A=3, B=7 e C=4, informe se as expressões abaixo são verdadeiras
ou falsas.
A. a) (A+C) > B ( )
B. b) B >= (A + 2) ( )
C. c) C = (B –A) ( )
D. d) (B + A) <= C ( )
E. e) (C+A) > B ( )
18. Sabendo que A=5, B=4 e C=3 e D=6, informe se as expressões abaixo são
verdadeiras ou falsas.
A. a) (A > C) AND (C <= D) ( )
B. b) (A+B) > 10 OR (A+B) = (C+D) ( )
C. c) (A>=C) AND (D >= C) ( )
Aula 5 – Estruturas de Controle

19. João Papo-de-Pescador, homem de bem, comprou um microcomputador para
controlar o rendimento diário de seu trabalho. Toda vez que ele traz um peso de
peixes maior que o estabelecido pelo regulamento de pesca do estado de São
Paulo (50 quilos) deve pagar um multa de R$ 4,00 por quilo excedente. João
precisa que você faça um diagrama de blocos que leia a variável P (peso de
peixes) e verifique se há excesso. Se houver, gravar na variável E (Excesso) e
na variável M o valor da multa que João deverá pagar. Caso contrário mostrar
tais variáveis com o conteúdo ZERO.
20. Elabore um diagrama de bloco que leia as variáveis C e N, respectivamente

código e número de horas trabalhadas de um operário. E calcule o salário
sabendo-se que ele ganha R$ 10,00 por hora. Quando o número de horas
exceder a 50 calcule o excesso de pagamento armazenando-o na variável E,
caso contrário zerar tal variável. A hora excedente de trabalho vale R$ 20,00. No
final do processamento imprimir o salário total e o salário excedente.
21. Desenvolva um diagrama que:

 Leia 4 (quatro) números;
 Calcule o quadrado de cada um;
 Se o valor resultante do quadrado do terceiro for >= 1000, imprima-o e
finalize;
 Caso contrário, imprima os valores lidos e seus respectivos quadrados.
22. Faça um diagrama de bloco que leia um número inteiro e mostre uma
mensagem indicando se este número é par ou ímpar, e se é positivo ou
negativo.
23. A Secretaria de Meio Ambiente que controla o índice de poluição mantém 3

grupos de indústrias que são altamente poluentes do meio ambiente. O índice
de poluição aceitável varia de 0,05 até 0,25. Se o índice sobe para 0,3 as
indústrias do 1º grupo são intimadas a suspenderem suas atividades, se o índice
crescer para 0,4 as indústrias do 1º e 2º grupos são intimadas a suspenderem
suas atividades, se o índice atingir 0,5 todos os grupos devem ser notificados a
paralisarem suas atividades. Faça um diagrama de bloco que leia o índice de
poluição medido e emita a notificação adequada aos diferentes grupos de
empresas.
24. Elabore um algoritmo que dada a idade de um nadador classifique-o em uma

das seguintes categorias:
 Infantil A = 5 a 7 anos
 Infantil B = 8 a 11 anos
 Juvenil A = 12 a 13 anos
 Juvenil B = 14 a 17 anos
 Adultos = Maiores de 18 anos
25. Elabore um algoritmo que gera e escreve os números ímpares dos números
lidos entre 100 e 200.
26. Construa um algoritmo que leia 500 valores inteiros e positivos e:

 Encontre o maior valor
 Encontre o menor valor
 Calcule a média dos números lidos
Aula 7 – Subprogramas
27. A Secretaria de Meio Ambiente que controla o índice de poluição mantém 3
grupos de indústrias que são altamente poluentes do meio ambiente. O índice
de poluição aceitável varia de 0,05 até 0,25. Se o índice sobe para 0,3 as
indústrias do 1º grupo são intimadas a suspenderem suas atividades, se o índice
crescer para 0,4 as indústrias do 1º e 2º grupo é intimado a suspenderem suas
atividades, se o índice atingir 0,5 todos os grupos devem ser notificados a
paralisarem suas atividades. Faça um programa que leia o índice de poluição
medido e emita a notificação adequada aos diferentes grupos de empresas.
28. Elabore um programa que gera e escreve os números ímpares dos números
lidos entre 100 e 200, estes valores devem ser passados pelo usuário.

29. Desenvolva um programa que leia 500 valores inteiros e positivos e:

 Encontre o maior valor
 Encontre o menor valor
 Calcule a média dos números lidos
30. Uma rainha requisitou os serviços de um monge e disse-lhe que pagaria

qualquer preço. O monge, necessitando de alimentos, indagou à rainha sobre o
pagamento, se poderia ser feito com grãos de trigo dispostos em um tabuleiro de
xadrez, de tal forma que o primeiro quadro deveria conter apenas um grão e os
quadros subsequentes, o dobro do quadro anterior. A rainha achou o trabalho
barato e pediu que o serviço fosse executado, sem se dar conta de que seria
impossível efetuar o pagamento. Faça um algoritmo para calcular o número de
grãos que o monge esperava receber.
Para todos os exercícios propostos, apresente a resolução em pseudocódigo e o

respectivo fluxograma:
31. Escreva um algoritmo para mudar uma lâmpada fundida de um candeeiro.
32. Escreva um algoritmo para calcular o maior de três números inteiros.
33. Escreva um algoritmo para calcular o maior e o menor de três números inteiros.
34. Escreva um algoritmo para calcular, dados três números inteiros, a soma dos
dois maiores.
35. Escreva um algoritmo para calcular o máximo divisor comum de dois números
inteiros.
36. Escreva um algoritmo para calcular o mínimo múltiplo comum de dois números
inteiros.
37. Escreva um algoritmo para calcular a soma dos números positivos, inferiores ou
iguais a 1000.

38. Escreva um algoritmo para calcular o fatorial de um número.

 Utilizando a instrução: Repita ... AtéQue ... ;
 Utilizando a instrução: Enquanto ... Faça ... ;
 Utilizando a instrução Para ... = ... Até ... Faça ...
39. Escreva um algoritmo que calcule e imprima a tabuada do 8 entre (1 a 10).
40. Ler três valores (A,B e C) representando as medidas dos lados de um triângulo e
escrever se formam ou não um triângulo. Obs. Para forma um triângulo, o valor
de cada lado deve ser menor que a soma dos outros dois lados.
41. Ler o nome de dois times e o número de gols marcados na partida (para cada
time ). Escreva o nome do vencedor. Caso não haja vencedor deverá ser
impressa a palavra EMPATE!.
Aula 9 – IDE NetBeans
42. Um empresário quer premiar seus vendedores de acordo com sua eficiência. O
vendedor recebe o prêmio de 10% do montante vendido.
Aula 11 – Estruturas de Controle
43. Dado uma sequencia de IF aninhado, reconstruir as estruturas de uma forma

diferente tendo o mesmo resultado.
44. Um empresário quer premiar seus vendedores de acordo com sua eficiência.
 Quando o vendedor atingir a meta de R$ 1.000,00 ele ganha 10% do
valor que ele vendeu.
 Quando o vendedor atingir o montante de R$ 5.000,00, sua premiação
será da ordem de 15%
 Acima de R$ 10.000,00 ele recebe R$ 1.200,00.
45. Multiplicação usando a soma
46. Divisão usando a subtração

Aula 12 – Estruturas de Dados Indexadas
47. Faça um programa em Java e em Portugol que armazene uma lista de contatos
com 10 posições.
48. Escreva um algoritmo no Portugol que receba 10 números e exiba a ordem

inversa desses números lidos, depois transcreva para linguagem Java.
49. Escreva em pseudocódigo e um programa em Java, uma matriz de 4x4 que será
preenchida pelo usuário e exibida o resultado na tela.
50. Vamos desenvolver um programa que receba os valores de uma matriz 2x2,
calcule e mostre a matriz resultante da multiplicação dos elementos da matriz
2x2 pelo seu maior elemento.
Aula 14 – Orientação a Objetos
Fonte dos exercícios: Balagtas, Florence Tiu. Projeto J.E.D.I. Students Manual.s.l..
51. Sua tarefa é criar uma classe que contenha um Registro de Agenda. A tabela
abaixo descreve as informações que um Registro de Agenda deve conter:
Crie os seguintes métodos:

 Forneça todos os métodos acessores e modificadores necessários para
todos os atributos
 Construtores
52. Crie uma classe Agenda que possa conter entradas de objetos tipo Registro de
Agenda (utilize a classe criada no primeiro exercício). Devem ser oferecidos os
seguintes métodos para agenda:
 Adicionar registro
 Excluir registro
 Visualizar registros
 Modificar registro

Aula 17 – Polimorfismo
53. Neste exercício, queremos criar um registro mais especializado de Student que
contém informações adicionais sobre um estudante de Informática. Sua tarefa é
estender a classe StudentRecord que foi implementada nas lições anteriores e
acrescentar atributos e métodos que são necessários para um registro de um
estudante de Informática. Utilize override para modificar alguns métodos da
superclasse StudentRecord, caso seja necessário.
54. Crie uma classe abstrata chamada Shape com os métodos getArea() e
getName(). Escreva duas de suas subclasses Circle e Square. E acrescente
métodos adicionais a estas subclasses.
Fonte: Balagtas, Florence Tiu. Projeto J.E.D.I. Students Manual.s.l..
Aula 20 – Unified Modeling Language – UML
55. Projeto: Faça a análise de um sistema de informação de sua escolha, que

possa de alguma forma ajudar a sua EEEP ou sua comunidade. Faça todo o
processo de análise, identificando o problema, determinando seu escopo,
avaliando sua viabilidade, produzindo suas especificações, diagramas UML, etc.
Ao final, implemente o sistema na linguagem de programação Java.

Analise e Programacao

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Analise e Programacao

Transféré par

Droits d'auteur :

Formats disponibles

Análise e Programação

MANUAL DO (A) PROFESSOR (A)

Assessora Institucional do Gabinete

OBJETIVOS DE APRENDIZAGEM ...................................................................................................8

CONTEÚDO PROGRAMÁTICO .......................................................................................................9

CRONOGRAMA DE ATIVIDADES ................................................................................................. 17

CONTEÚDOS INTERDISCIPLINARES ............................................................................................ 25

MAPA DE ANÁLISE DE AVALIAÇÃO............................................................................................. 26

FASE I : LÓGICA DE PROGRAMAÇÃO ................................................................................ 32

AULA - 1. INTRODUÇÃO A LÓGICA DE PROGRAMAÇÃO ............................................................. 32

FASE II – LINGUAGEM DE PROGRAMAÇÃO ...................................................................... 70

AULA - 8. INTRODUÇÃO A LINGUAGEM JAVA ............................................................................ 70

FASE III – PROGRAMAÇÃO ORIENTADA A OBJETOS ...................................................................... 99

AULA - 14. ORIENTAÇÃO A OBJETOS ................................................................................................. 99

FASE IV – ANÁLISE DE SISTEMAS .................................................................................... 120

AULA - 18. INTRODUÇÃO A SISTEMAS .................................................................................... 120

APÊNDICE A – EXERCÍCIOS PRÁTICOS ......................................................................................... 139

AULA 1 – INTRODUÇÃO A LÓGICA DE PROGRAMAÇÃO ............................................................................ 139

Elaborado no intuito de qualificar o processo de formação, este Manual é um

É importante que o (a) professor (a) compreenda o propósito do método do

Esperamos contribuir com a consolidação do compromisso e envolvimento de todos

Aula - 1. Introdução a Lógica de Programação

Aula - 2. Conceitos de Programação

Aula - 3. Introdução aos algoritmos

Aula - 4. Elementos utilizados nos Algoritmos

Aula - 5. Estruturas de Controle

Aula - 6. Estrutura de Dados Indexada

FASE II – LINGUAGEM DE PROGRAMAÇÃO

Aula - 8. Introdução a Linguagem Java

Aula - 9. IDE NetBeans

Aula - 10. Elementos Utilizados na Programação

Aula - 11. Estruturas de Controle

Aula - 12. Estruturas de Dados Indexados

Aula - 13. Métodos

FASE III –PROGRAMAÇÃO ORIENTAD A OBJETOS

Aula - 14. Orientação a Objetos

Aula - 15. Encapsulamento

Aula - 16. Herança

Aula - 17. Polimorfismo

FASE IV - ANÁLISE DE SISTEMAS

Aula - 19. Requisitos

Aula - 20. Diagramas UML

INTENÇÃO A SER ALCANÇADA

 Construir algoritmos consistentes, em português estruturado, para a solução

FASE 1: Lógica de Programação

 Possibilitar a execução de várias atividades na resolução de problemas com

FASE 1: Lógica de Programação

QUADRO RESUMO DAS COMPETÊNCIAS:

ELEMENTOS DA COMPETÊNCIA CRITÉRIOS DE DESEMPENHO

COMPETÊNCIA 02 CONTEXTO DE REALIZAÇÃO

Utilizando: NetBeans IDE

Ambiente: Laboratório de Ensino de

ELEMENTOS DA COMPETÊNCIA CRITÉRIOS DE DESEMPENHO

COMPETÊNCIA 03 CONTEXTO DE REALIZAÇÃO

Utilizando: UML2 – plug in do

Ambiente: Laboratório de Ensino de

ELEMENTOS DA COMPETÊNCIA CRITÉRIOS DE DESEMPENHO

Aula Núcleo de Conteúdos Descrição

Fase I - Lógica de Programação

Aula Núcleo de Conteúdos Descrição

Estrutura de Seleção - Decisão Simples

FILOSOFIA: Lógica aristotélica, abstração, eficiência e eficácia

MATEMÁTICA: Lógica matemática (proposições lógicas, tabelas verdade e álgebra de