Análise e Programação

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

Construir algoritmos consistentes em

português estruturado, a partir de

técnicas de modularização e

refinamentos sucessivos, usando os

conceitos fundamentais de construção

de algoritmos.

A partir de:

Utilizando: Portugol IDE

Com a ajuda de: Livros, apostilas,

anotações no caderno e orientações

do professor.

Ambiente: Laboratório de Ensino de

Informática

ELEMENTOS DA COMPETÊNCIA CRITÉRIOS DE DESEMPENHO

1. Estruturar a solução de problemas a partir das técnicas de elaboração de algoritmos.

1.1. Identificar corretamente entradas e saídas dos problemas

1.2. Apresentar compreensão clara sobre elaboração de algoritmos

1.3. Opinar com coerência no momento das discussões

2. Elaborar algoritmos corretos com as estruturas básicas do português estruturado.

2.1. Explicar algoritmos elaborados 2.2. Construir algoritmos corretos

para resolução de problemas 2.3. Corrigir algoritmos elaborados

por outras pessoas do grupo


Desenvolver aplicações com

interfaces gráficas em linguagem Java

respeitando o paradigma de

orientação a objetos.

A partir de:

Utilizando: NetBeans IDE



do professor.


Informática


1. Construir interfaces na IDE NetBeans usando componentes

1.1. Construir interfaces na IDE NetBeans usando componentes

2. Elaborar programas usando conceitos básicos de programação

2.1. Elaborar programas usando conceitos básicos de programação

3. Corrigir erros de sintaxe da linguagem Java

3.1. Corrigir erros de sintaxe da linguagem Java.


Interpretar e elaborar Diagramas de

Classes e Diagramas de Casos de

Uso descritos pela UML.

A partir de: Estudo de Casos

Utilizando: UML2 – plug in do

Eclipse; UMLet



do professor.


Informática


1. Identificar processos do mundo real que podem ser mapeados para sistemas informatizados

1.1. Determinar corretamente a sequência de passos de um processo

1.2. Relacionar corretamente processos do mundo real que podem ser mapeados no mundo computacional

2. Analisar e elaborar conjunto de requisitos necessários a um projeto de software, de acordo com os tipos de requisitos estudados

2.1. Identificar requisitos para sistema proposto

3. Compreender o ciclo de vida do 3.1. Descrever corretamente as

desenvolvimento de software etapas necessárias ao desenvolvimento de um softeware

4. Criar diagramas de classes e casos de uso para documentação de sistemas

4.1. Identificar corretamente elementos em diagramas exibidos

4.2. Analisar diagramas elaborados por outras pessoas do grupo

4.3. Corrigir erros em diagramas 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

Apresentação da disciplina.

Plano de ensino, método de trabalho, bibliografia e formas de avaliação.

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

Introdução

Noções de lógica

Exercício prático

2ª.Aula Conceitos de Programação. Tipos de Linguagens de programação

Paradigmas de Programação

3ª.Aula Introdução aos Algoritmos O que é um algoritmo?

Tipos de Algoritmos

4ª.

Aula Elementos utilizados nos algoritmos

Declaração de Variáveis

Entrada e Saída de Dados

Operadores

Teste de mesa

Exercício prático

5ª.Aula Estruturas de Controle.

Estrutura de Decisão

Exercício prático

Estruturas de repetição

Exercício prático

6ª.Aula Estrutura de Dados Indexada

Vetores

Matrizes

Exercício prático

7ª.Aula Subprogramas

Características Gerais

Procedimentos

Funções

Exercício prático

Avaliação de Competências

Intervenção Pedagógica

Fase II - Linguagem de Programação

8ª.Aula Introdução a linguagem java

História

Características do JAVA

Tecnologias Java

9ª.Aula IDE Netbeans.

Criação do Projeto

Aplcação Olá Mundo

Criação da Interface Gráfica

Criação dos Programas

Exercício prático

10ª.Aula Elementos utilizados na Programação

Entrda e Saída de Dados

Tipos de Dados Primitivos

Variáveis

Atribuição

Operadores aritimeticos, Lógicos e relacionais

Exercício prático

11ª.Aula Estruturas de Controle

Estrutura de Seleção

Exercício prático

Estruturas de Repetição

Exercício prático

12ª.Aula Vetores e Matrizes

Vetores

Matrizes

Exercício prático

13ª.Aula Subprogramas Procedimentos

Funções

Exercício prático



Fase III - Programação Orientada a Objetos

14ª.Aula Orientação a Objetos

Introdução

Histórico

Fundamentos de Orientação a Objetos

15ª.Aula Encapsulamento O que é encapsulamento

Modificadores de Acesso

16ª.Aula Herança

O que é Herança

Superclasses e subclasses

Herança múltipla

Classe Object

17ª.Aula Polimorfismo

O que é Polimorfismo

Sobrecarga de métodos

Classes e métodos abstratos



Fase IV – Análise de Sistemas

18ª.Aula Introdução a sistemas

O que é um sistema?

Como Construir um Sistema de Informação Baseado em Computador

O Papel do Analista de Sistemas

Fases do Desenvolvimento de Sistemas

19ª.Aula Requisitos

Introdução

Levantamento de Requisitos

Análise de requisitos

Exercício prático - pesquisar sobre sistemas e elaborar os requisitos do sistema pesquisado.

20ª.Aula Diagramas UML

O que é UML

Diagramas UML

Exercício prático - os alunos devem apresentar a proposta 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

1ª.Aula Apresentação da disciplina. Plano de ensino, método de trabalho, bibliografia e formas de avaliação.

2ª.Aula Introdução a Lógica de Programação.

Noções de lógica

Raciocinio lógico

Exercicio pratico - problemas lógicos com palitos de fósforo, testes lógicos da Coquetel etc

3ª.Aula Introdução aos Algoritmos.

O que é um algoritmo?

Algoritmos usados na resolução de problemas.

Tipos de Algoritimo

Pseudocódigo (mostrar exemplos, construir junto com os 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.

4ª.Aula Conceitos de Programação.

Linguagem de Baixo nível e de Alto nível.

Linguagems de programação.

Tipos de Linguagens de programação (Conceitos sobre programação Linear, Estruturada, orientada a objetos)

5ª.Aula

Elementos utilizados nos algoritmos


Variáveis

Constantes

Atribuição


Teste de mesa

6ª.Aula

Exercício prático - elaborar algoritmos em pseudocódigo com problemas usando fórmulas matemáticos (integração 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

Estrutura de Seleção - Mútipla Escolha

Exercício prático


Exercício prático

8ª.Aula Estrutura de Dados Indexada

Vetores

Matrizes

Exercício prático

9ª.Aula Subprogramas

Parâmetros

Retorno

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

12ª.Aula Introdução a linguagem Java

História, Tecnologias da linguagem

JVM -JRE –JDK

Bytecode

javac (compilador)

java (interpretador)

Características do JAVA

Erros de sintaxe e de runtime

13ª.Aula IDE Netbeans.

Criação de Projetos, Plugins, Plataformas

Visão geral dos componentes Swing

Exercício prático

14ª.Aula Elementos utilizados em Programação


Variáveis

Constantes

Atribuição

Casting



Estrutura de Seleção(Decisão, Simples,composta, encadeada, Múltipla escolha) - Exercicio pratico.

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

19ª.Aula Introdução a orientação a Objetos Histórico da orientação a objetos

Linguagens orientadas a objetos

20ª.Aula Introdução a Classes e objetos

Classes vs Objetos

Modificadores de Acesso de Objetos

Variáveis de instâncias

Construtores (inicializando objetos com construtores)

Exercício Prático

21ª.Aula Encapsulamento O que é encapsulamento

Métodos get e set

22ª.Aula Herança

Conceito de herança

Superclasses e subclasses

Herança múltipla

Classe Object

23ª.Aula Polimorfismo

Conceito de polimorfismo

Sobrecarga de métodos

Classes e métodos abstratos

Interface



FASE IV – Análise

26ª.Aula

Introdução a sistemas

O que é um sistema?

Sistemas de Informação e seus tipos.

Fases da concepção de sistemas de 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.)

27ª.Aula Requisitos

Estudo de viabilidade

Técnicas de entrevistas e levantamentos de necessidades

Analise de requisitos

Requisitos funcionais e Não funcionais

Requisitos do usuário

Requisitos do sistema

Exercício prático

28ª.Aula Diagramas UML

Elaboração de diagrama de classes

Elaboração de diagrama de casos de uso

Exercício prático



Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional

Redes de Computadores – Análise e Programação 25

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



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

ED – Em desenvolvimento O Aluno já passou por uma avaliação

de competência, e ainda não foi

satisfatório em alguma das habilidades.

MB – Muito Bom

O Aluno passou pela a avaliação de

competência e teve um resultado

muito bom, este esta no nível

intermediário a Avançado.

B – Básico O Aluno passou pela a avaliação de

competência e teve um resultado bom,

este esta no nível básico.

MC – Muito Critico Quando a aluno não esta conseguindo

adquirir os elementos da competência.

Campo Vazio Significa que o aluno não passou por

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].

http://apostilando.net.br/swf/2038.swf



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

http://pt.wikipedia.org/wiki/Computador

http://pt.wikipedia.org/wiki/Programa_de_computador



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.

http://pt.wikipedia.org/wiki/C%C3%B3digo_fonte

http://pt.wikipedia.org/wiki/Software

http://pt.wikipedia.org/wiki/C%C3%B3digo_de_m%C3%A1quina

http://pt.wikipedia.org/wiki/C%C3%B3digo_de_m%C3%A1quina

http://pt.wikipedia.org/wiki/Processador

http://pt.wikipedia.org/wiki/Programa%C3%A7%C3%A3o_de_computadores

http://pt.wikipedia.org/wiki/Engenharia_de_software

http://pt.wikipedia.org/wiki/Fortran



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.



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.

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.



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.



Figura 1 - Fluxograma da média de duas notas

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.

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.

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

DADOS DE ENTRADA PROCESSAMENTO SAÍDA



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 variavel real prova2 variavel real prova3 variavel real prova4 variavel real media

Declaração de variáveis

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 ler prova2 ler prova3 ler prova4 media<- (prova1+ prova2+ prova3+ prova4)/4 escrever "sua media é " escrever media

Corpo do algoritmo

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.



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

bits

-2 147 483 648

2 147 483 647

0

Real Valores com parte decimal definidos com

64 bits

-1.7 E 308

1.7 E 308

0.0

Lógico Valore lógicos - 1 bit verdadeiro

falso

falso

Carácter Caracteres da Tabela ASCII ASCII(0)

ASCII(255)

" " (espaço)

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.



Texto Conjuntos de caracteres "Sequências de

caracteres"

"entre aspas"

"" (vazio)

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 verdadeiras

E



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

OU

Um expressão (NÃO) inverte o valor da expressão ou condição, se verdadeira inverte para falsa e vice-versa

NAO

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

Sugestão:

Uma animação interessante sobre um exemplo de teste de mesa simples

pode ser vista em http://www.brasilacademico.com/ed/testemesa.htm.

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.

4. Preste atenção nas estruturas condicionais (porque pode haver instruções que não serão

executadas) e nas estruturas de repetição (porque pode haver trechos de instruções que devem

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.

Figura 9 - Algoritmo em Portugol para calcular a média entre dois números

1 2 3

4

5 6

7

8

9 10

11 12 13 14 15



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 executado apenas quando uma expressão lógica for verdadeira

se expressão_lógica entao //Código se 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 quando uma expressão lógica for verdadeira e um bloco diferente para ser executado quando a expressão lógica for falsa


senao //Código se expressão_lógica for falsa

Fimse


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 quando uma expressão lógica for verdadeira e um bloco diferente para ser executado quando a expressão lógica for falsa



fimse


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 parada, ou seja expressão_lógica seja falsa. Neste caso o teste é feito antes que se comece a execução do bloco do enquanto.

enquanto expressão_lógica faz //Código se expressão_lógica for verdadeira

Fimenquanto

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 parada, ou seja expressão_lógica seja falsa. Neste caso o testeé feito depois que a primeira iteração do laço seja executada.

Faz //Código se expressão_lógica for verdadeira

enquanto (expressão_lógica)



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, atualizada e testada de acordo com o que está na definição do laço

para contador de inicio ate fim passo p //Código se expressão_lógica for verdadeira

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.

[0] [1] [2] [3] [4] [5] [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],

Valores que serão

armazenados no vetor

Os índices determinam a posição do

elemento inserido na estrutura, onde cada

posição do vetor contém o valor que

poderá ser manipulado



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]

http://pt.wikipedia.org/wiki/Linguagem_de_programa%C3%A7%C3%A3o

http://pt.wikipedia.org/wiki/Hist%C3%B3ria_da_computa%C3%A7%C3%A3o

http://pt.wikipedia.org/wiki/Hist%C3%B3ria_da_computa%C3%A7%C3%A3o

http://pt.wikipedia.org/wiki/Internet

http://pt.wikipedia.org/wiki/Navegador

http://pt.wikipedia.org/wiki/Mainframe

http://pt.wikipedia.org/wiki/Sistema_operacional

http://pt.wikipedia.org/wiki/Sistema_operacional

http://pt.wikipedia.org/wiki/Celular

http://pt.wikipedia.org/wiki/PDA

http://pt.wikipedia.org/wiki/1997

http://pt.wikipedia.org/wiki/ISO

http://pt.wikipedia.org/wiki/IEC

http://pt.wikipedia.org/wiki/ECMA

http://pt.wikipedia.org/wiki/Java_Community_Process


http://pt.wikipedia.org/wiki/Software_Livre

http://pt.wikipedia.org/wiki/GNU_General_Public_License

http://pt.wikipedia.org/wiki/GNU_General_Public_License

http://pt.wikipedia.org/wiki/8_de_maio


http://www.youtube.com/watch?v=WAy9mgEYb6o

http://www.youtube.com/watch?v=b-Cr0EWwaTk



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

Vantagens

Desvantagens

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).

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.

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

Criação do

projeto

Criação da

interface

Criação dos

programas

Identificação do

problema

Elaboração da

solução

Implementação

da solução

http://netbeans.org/kb/index_pt_BR.html



transcrevemos um pseudocódigo para uma linguagem de programação, então vamos

conhecer nossa ferramenta de trabalho.

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

1

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.

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

1

2 3

4



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

2 Nesta área ficam os projetos e arquivos que foram criados, com o botão direito do mouse em cima do pacote ou projeto na opção novo também podemos criar um arquivo *.java que é denominado classe.

3 Nesta área escrevemos o algoritmo, abaixo veremos uma comparação com o pseudocódigo para entendermos a sintaxe da linguagem.

4 Neste item da imagem é gerada a saída do algoritmo, assim como é no 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.

Figura 29 - Início e Fim de bloco no Java

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 codificar estará entre as chaves. Na Figura 29 você pode obervar o local

(Onde você digitará seu código)

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.

Figura 30 - Execução do projeto OlaMundo

(Onde você digitará seu código)

O resultado do print sai no console



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.

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.

Sugestão:

http://netbeans.org/kb/trails/matisse_pt_BR.html - Em: 04/06/2012

http://netbeans.org/kb/trails/matisse_pt_BR.html



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 Scanner(System.in); valor = leia.nextDouble();

ler valor

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: De:

byte short Char int long float double

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){ //Código se expressão_lógica for verdadeira

}


fimse

if (expressão_lógica){ //Código se expressão_lógica for verdadeira

}else{ //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){ //Código se expressão_lógica for verdadeira

}

enquanto expressão_lógica faz //Código se expressão_lógica for verdadeira

fimenquanto

do{ //Código se expressão_lógica for verdadeira

}while (expressão_lógica)

Faz //Código se expressão_lógica for verdadeira

enquanto (expressão_lógica)

for (cont = inicio;critério parada;atualiza do

cont){ //Código se expressão_lógica for verdadeira

}

para contador de inicio ate fim passo p //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.

Exercício Prático

Sugestão:

Pesquisar como funcionam os operadores ++ e --, bem como suas

variações.



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:

http://vidadeprogramador.com.br/



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

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

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..



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

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.


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.




Figura 54 – Método que calcula a média geral do aluno

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.


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



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:



Figura 84 - Dado, Informação e Conhecimento

Tabela 20 - Dado, Informação e Conhecimento (9)

DADO INFORMAÇÃO CONHECIMENTO Simples observações sobre o estado do mundo

Dados dotados de relevância e propósito

Informação valiosa da mente humana. Inclui reflexão, síntese, contexto.

Facilmente estruturado Requer unidade de análise De difícil estruturação

Facilmente obtido por máquinas

Exige consenso em relação ao significado

De difícil captura em máquinas

Frequentemente quantificado

Exige necessariamente a mediação humana

Frequentemente tácito

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.

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



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.

http://www.infoescola.com/engenharia-de-software/uml/

http://www.infoescola.com/engenharia-de-software/uml/

http://www.infoescola.com/engenharia-de-software/analise-de-requisitos/



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:

http://www.slideshare.net/glaucocardozo/apostila-uml-8177684

http://www.slideshare.net/glaucocardozo/apostila-uml-8177684



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

Cenário 1: Criar Nova Conta

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

processo 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:

http://projects.gnome.org/dia/

Umbrello:

http://www.umbrello.org/

ArgoUML:

http://argouml.tigris.org/

DBDesigner: http://www.fabforce.net/

ASTAH: http://www.astah.net/

http://projects.gnome.org/dia/

http://www.umbrello.org/

http://argouml.tigris.org/

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.

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.

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.



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.

Análise e Programação

Documents

Transcript of Análise e Programação