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.1. Entrada e Saída de Dados
10.2. Tipos de Dados Primitivos
10.3. Variáveis
10.4. Atribuição
10.5. Operadores
Aula - 11. Estruturas de Controle
11.1. Estrutura de Seleção
11.2. Estruturas de Repetiçã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
COMPETÊNCIA 02 CONTEXTO DE REALIZAÇÃO
Desenvolver aplicações com
interfaces gráficas em linguagem Java
respeitando o paradigma de
orientação a objetos.
A partir de:
Utilizando: NetBeans 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. 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.
COMPETÊNCIA 03 CONTEXTO DE REALIZAÇÃO
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
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. 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
Avaliação de Competências
Intervenção Pedagógica
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
Avaliação de Competências
Intervenção Pedagógica
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.
Avaliação de Competências
Intervenção Pedagógica
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
Tipos de Dados Primitivos
Variáveis
Constantes
Atribuição
Operadores aritimeticos, Lógicos e relacionais
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
7ª.Aula Estruturas de Controle.
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
Estruturas de repetição
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
Tipos de Dados Primitivos
Variáveis
Constantes
Atribuição
Casting
Operadores aritimeticos, Lógicos e relacionais
15ª.Aula Estruturas de Controle.
Estrutura de Seleção(Decisão, Simples,composta, encadeada, Múltipla escolha) - Exercicio pratico.
Exercício prático
Estruturas de repetição
Exercício prático
Vetores e Matrizes Classe Array
16ª.Aula Declarando e criando arrays
Exercício prático
17ª.Aula Intervenção Pedagógica
18ª.Aula Avaliação da Fase
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
24ª.Aula Intervenção Pedagógica
25ª.Aula Avaliação da Fase
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
29ª.Aula Intervenção Pedagógica
30ª.Aula Avaliação da Fase
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
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 26
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
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 27
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.
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 28
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].
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 29
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
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 30
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
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
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 31
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
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 32
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
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 33
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
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 34
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.
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 35
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
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 36
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.
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 37
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.
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 38
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.
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 39
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.
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 40
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.
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 41
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.
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 42
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.
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 43
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
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 44
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 45
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.
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 46
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.
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 47
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.
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 48
Texto Conjuntos de caracteres "Sequências de
caracteres"
"entre aspas"
"" (vazio)
Exercício Prático
4.2. Entrada e Saída de Dados
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.
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 49
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)
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 50
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
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 51
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:
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 52
“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
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 53
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
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 54
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
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 55
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 56
Aula - 5. Estruturas de Controle
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.
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 57
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
se expressão_lógica entao //Código se expressão_lógica for verdadeira
senao //Código se expressão_lógica for falsa
Fimse
b – Portugol a – Fluxograma
Figura 11 - Status do aluno para sua média – condição composta
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 58
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
se expressão_lógica entao //Código se expressão_lógica for verdadeira
senao //Código se expressão_lógica for falsa
fimse
b – Portugol a – Fluxograma
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
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 59
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
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 60
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
escrever (B – 2), “ é divisor”
fimse
B % (B – 3) = 0 ? se B % (B – 3) = 0 entao
escrever (B – 3), “ é divisor”
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
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 61
A <- A – 1
B % (B – 2) = 0 ? se B % A = 0 entao
escrever A, “ é divisor”
fimse
A <- A – 1
B % (B – 3) = 0 ? se B % A = 0 entao
escrever A, “ é divisor”
fimse
A <- A – 1
...
B % (1) = 0 ? se B % A = 0 entao
escrever A, “ é divisor”
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)
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 62
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.
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 63
Figura 17 - Pseudocódigo em Portugol – Divisores – Para
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 64
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
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 65
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
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 66
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
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 67
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
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 68
Aula - 7. Subprogramas
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
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 69
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.
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 70
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]
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 71
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
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 72
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.
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 73
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
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 74
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
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 75
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
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 76
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
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 77
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
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 78
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
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 79
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
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 80
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.
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 81
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.
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 82
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();
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 83
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:
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 84
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
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 85
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;
10.1. Entrada e Saída de Dados
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.
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 86
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).
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 88
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
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 89
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
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 90
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)
Aula - 11. Estruturas de Controle
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.
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 91
Tabela 18 - Estrutura de seleção
Java Portugol if (expressão_lógica){ //Código se expressão_lógica for verdadeira
}
se expressão_lógica entao //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
}
se expressão_lógica entao //Código se expressão_lógica for verdadeira
senao //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
11.2. Estruturas de Repetição
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
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 92
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.
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 93
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.
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 94
Figura 43 - Problema dos Divisores usando for
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 95
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.
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 96
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
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 97
Aula - 13. Subprogramas
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.
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 98
Figura 47 – Código Java para cálculo da força resultante
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 99
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
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 100
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.
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 101
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.
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 102
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:
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 103
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
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 104
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..
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 105
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.
Veja como fica em Java:
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 106
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.
Dicas de Programação
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.
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 107
Veja como fica em Java:
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.
Dicas de Programação
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
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 108
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
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 109
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.
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 110
Veja como fica em Java:
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.
Veja como fica em Java:
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 111
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
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 112
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.
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 113
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
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 114
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()).
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 115
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:
Figura 70 – Saída 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
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 116
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
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 117
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:
Figura 77 – Saída do programa
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
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 118
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
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 119
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.
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 120
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:
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 121
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
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 122
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
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 123
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?
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 124
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
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 125
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.
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 126
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.
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 127
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
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 128
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.
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 129
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:
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 130
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
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 131
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.
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 132
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.
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 133
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
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 134
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:
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 135
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.
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 136
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/
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 137
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.
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 138
17. Evolução Educação e Tecnologia. Orientação a Objetos com Java. [www.evolucao.com.br – junho de
2012].
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 139
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.
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 140
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) ( )
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 141
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
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 142
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.
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 143
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.
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 144
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
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 145
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
Escola Estadual de Educação Profissional Ensino Médio Integrado a Educação Profissional
Redes de Computadores – Análise e Programação 146
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.