lógica de programação - portal de cursos...

Lógica de

Programação

2

UNIDADE 1 - INTRODUÇÃO À LÓGICA DE PROGRAMAÇÃO ........................................................................................... 3

1.1 VISÃO GERAL DO PROCESSO DE DESENVOLVIMENTO DE APLICAÇÕES ........................................................................................ 3 1.2 LÓGICA DE PROGRAMAÇÃO ............................................................................................................................................ 4 1.3 SEQUÊNCIA LÓGICA ....................................................................................................................................................... 4 1.4 INSTRUÇÕES ................................................................................................................................................................ 5 1.5 ALGORITMO ................................................................................................................................................................ 5 1.6 EXERCÍCIOS SUGERIDOS ................................................................................................................................................. 9

UNIDADE 2 - DIAGRAMAS DE FLUXO .......................................................................................................................... 10

2.1 DIAGRAMA DE NASSI-SHNEIDERMAN ............................................................................................................................. 10 2.2 FLUXOGRAMAS .......................................................................................................................................................... 12 2.3 LINGUAGEM NATURAL ................................................................................................................................................. 14 2.4 PSEUDOCÓDIGO ......................................................................................................................................................... 14

UNIDADE 3 - ELEMENTOS BÁSICOS DO CÓDIGO ......................................................................................................... 16

3.1 VARIÁVEIS E CONSTANTES ............................................................................................................................................ 16 3.2 TIPOS PRIMITIVOS DE DADOS ........................................................................................................................................ 16 3.3 DECLARAÇÃO DE VARIÁVEIS .......................................................................................................................................... 17

UNIDADE 4 - COMANDOS DE ATRIBUIÇÃO, ENTRADA E SAÍDA DE DADOS ................................................................. 22

4.1 COMANDO DE ATRIBUIÇÃO........................................................................................................................................... 22 4.2 COMANDO DE ENTRADA DE DADOS ............................................................................................................................... 23 4.3 COMANDO DE SAÍDA DE DADOS .................................................................................................................................... 23

UNIDADE 5 - ESTRUTURAS DE SEQUENCIAÇÃO, SELEÇÃO E REPETIÇÃO ..................................................................... 24

5.1 SEQUÊNCIA ............................................................................................................................................................... 24 5.2 SELEÇÃO ................................................................................................................................................................... 24 5.3 REPETIÇÃO ................................................................................................................................................................ 27

UNIDADE 6 - VETORES E MATRIZES (ARRAYS) ............................................................................................................. 31

6.1 VETORES ................................................................................................................................................................... 31 6.1 MATRIZES ................................................................................................................................................................. 32

UNIDADE 7 - SUBROTINAS (PROCEDIMENTOS E FUNÇÕES) ......................................................................................... 33

7.1 UTILIZAÇÃO DE SUBROTINAS ......................................................................................................................................... 33 7.2 PROCEDIMENTOS ........................................................................................................................................................ 34 7.3 FUNÇÕES .................................................................................................................................................................. 34

UNIDADE 8 - CONTEÚDO DINÂMICO........................................................................................................................... 36

8.1 CONTEÚDO DINÂMICO - CONCEITO ................................................................................................................................ 36 8.2 LINGUAGENS: ............................................................................................................................................................ 37

UNIDADE 9 - LINGUAGEM PHP.................................................................................................................................... 38

9.1 COMO CRIAR UM ARQUIVO PHP ................................................................................................................................... 38 9.2 DELIMITANDO O CÓDIGO PHP ...................................................................................................................................... 38 9.3 DELIMITADORES ALTERNATIVOS ..................................................................................................................................... 39 9.4 SEPARADORES DE INSTRUÇÕES ...................................................................................................................................... 39 9.5 COMENTÁRIOS ........................................................................................................................................................... 40 9.6 ESTRUTURAS DE DADOS ............................................................................................................................................... 41 9.7 VARIÁVEIS ................................................................................................................................................................. 41 9.8 CONSTANTES ............................................................................................................................................................. 41

3

9.9 ARRAYS .................................................................................................................................................................... 42 9.10 TIPOS DE DADOS SUPORTADOS ..................................................................................................................................... 43 9.11 ESTRUTURAS DE CONTROLE .......................................................................................................................................... 46

UNIDADE 10 - LINGUAGEM C .................................................................................................................................... 52

10.1 ESTRUTURA BÁSICA DE UM PROGRAMA EM C ................................................................................................................... 52 10.2 COMANDO IF ............................................................................................................................................................. 53 10.3 ESTRUTURAS DE REPETIÇÃO .......................................................................................................................................... 54 10.4 ARRAYS (VETORES E MATRIZES) ..................................................................................................................................... 54 10.5 FUNÇÕES (SUBROTINAS) .............................................................................................................................................. 55

UNIDADE 11 - FUNDAMENTOS ORIENTAÇÃO A OBJETOS ......................................................................................... 56

11.1 CONCEITOS BÁSICOS .................................................................................................................................................... 56 11.2 CLASSE ..................................................................................................................................................................... 59 11.3 COLABORAÇÃO .......................................................................................................................................................... 60 11.4 BENEFÍCIOS DA ORIENTAÇÃO A OBJETOS ......................................................................................................................... 61

UNIDADE 12 - EXERCÍCIOS DE FIXAÇÃO .................................................................................................................... 63

Unidade 1 - Introdução à Lógica de Programação

1.1 Visão geral do processo de desenvolvimento de aplicações

Antes de começarmos a estudar lógica de programação, é importante que tenhamos uma visão geral do processo de desenvolvimento de aplicações, uma vez que estudaremos lógica de programação com o objetivo de conseguir um bom embasamento para a prática da programação de computadores.

Podemos encontrar na literatura em informática várias formas de representação das etapas em que consiste o processo de desenvolvimento de um programa ou aplicação. Estas formas de representação podem variar tanto na quantidade de etapas como nas atividades que devem ser realizadas por cada etapa.

A seguir apresentaremos uma forma de representação do processo de desenvolvimento de software que é bastante encontrada na literatura:

Na figura, podemos ver o processo de desenvolvimento de programas dividido em seis etapas. A seguir daremos uma rápida explicação das atividades realizadas em cada etapa.

Planejamento Na etapa de planejamento é onde deve ser desenvolvido um plano inicial de desenvolvimento, levando em considerações questões como definição da abrangência do sistema, missão e objetivos do sistema, cronogramas de desenvolvimento, análise custo x benefício, levantamento inicial de informações, etc.

Planejamento

Análise

Projeto

Implementaçã

o

Manutenção

Testes

Lógica de Programação

4

Análise Também chamada de análise de requisitos, é onde deve se obter um claro entendimento sobre o sistema. A análise proporciona a base para uma boa implementação do software.

Projeto Também chamada de especificação do projeto, é onde propomos uma arquitetura de implementação para o software, que atenda aos requisitos do sistema identificados na análise. Aqui, passamos a nos preocupar com os diversos aspectos computacionais necessários para uma boa implementação do software. Os algoritmos dos programas a serem implementados são construídos nesta fase.

Implementação A etapa de implementação é onde os programas são efetivamente construídos, a partir da arquitetura de implementação feita na etapa anterior. Nesta etapa é onde a atividade de codificação ocorre de forma massiva.

Teste Nesta etapa os programas construídos serão testados de forma exaustiva. Existe uma grande variedade de testes que são realizados, indo desde o teste unitário dos módulos de programas até o teste de integração de todo o sistema de software.

Manutenção É onde ocorrem ajustes do software implementado, que podem ser ocasionados por vários motivos: erros de projeto identificados após a implementação e o teste do software, inovações tecnológicas, evolução do sistema, etc..

1.2 Lógica de Programação

A lógica trata da correção do pensamento. Como filosofia ela procura saber por que pensamos de uma forma e não de outra. Poderíamos dizer, também, que a Lógica é a arte de pensar corretamente e, visto que a forma mais complexa de pensamento é o raciocínio, a Lógica estuda ou tem em vista a "correção do pensamento".

A Lógica de Programação é necessária para pessoas que desejam trabalhar com desenvolvimento de sistemas e programas, ela permite definir a sequência lógica para o desenvolvimento.

Então, o que é Lógica?

Lógica de Programação é a técnica de encadear pensamentos para atingir determinado objetivo.

1.3 Sequência Lógica

Os pensamentos podem ser descritos como uma sequência de instruções, que devem ser seguidas para cumprir uma determinada tarefa.

Podemos dar uma definição concreta:

Sequência Lógica são os passos executados até atingir um objetivo ou solução de um problema.


5

1.4 Instruções

Na linguagem comum, entende-se por instruções "um conjunto de regras ou normas definidas para a realização ou emprego de algo".

Em informática, porém, instrução é a informação que indica a um computador uma ação elementar a ser executada.

Convém ressaltar que uma ordem isolada não permite realizar o processo completo, para isso é necessário um conjunto de instruções colocadas em ordem sequencial lógica.

Por exemplo, se quisermos fazer uma omelete de batatas, precisaremos colocar em prática uma série de instruções: descascar as batatas, bater os ovos, fritar as batatas, etc...

É evidente que essas instruções têm que ser executadas em uma ordem adequada – não se pode fritar as batatas para depois descascá-las.

Dessa maneira, uma instrução tomada em separado, não tem muito sentido. Para obtermos o resultado, precisamos colocar em prática o conjunto de todas as instruções, na ordem correta.

Instruções são um conjunto de regras ou normas definidas para a realização ou emprego de algo. Em informática, é o que indica a um computador uma ação elementar a executar.

1.5 Algoritmo

A palavra algoritmo, à primeira vista, parece-nos estranha. Embora possua designação desconhecida, fazemos uso constantemente de algoritmos em nosso cotidiano: a maneira como uma pessoa toma banho é um algoritmo, por exemplo.

Outros algoritmos frequentemente encontrados são:

instruções para se utilizar um aparelho eletrodoméstico;

uma receita para preparo de algum prato;

guia de preenchimento para declaração do imposto de renda;

a regra para determinação de máximos e mínimos de funções por derivadas sucessivas;

a maneira como as contas de água, luz e telefone são calculadas mensalmente, dentre outros.

São vários os conceitos para algoritmo. Escolhemos alguns para serem apresentados aqui.

"Um conjunto finito de regras que provê uma sequência de operações para resolver um tipo de problema específico"

Ronald Knuth


6

"Sequência ordenada, e não ambígua, de passos que levam à solução de um dado problema"

Tremblay

"Processo de cálculo, ou de resolução de um grupo de problemas semelhantes, em que se estipulam, com generalidade e sem restrições, as regras formais para a obtenção do resultado ou da solução do problema"

Dicionário Aurélio

Por que precisamos dele?

No desenvolvimento de programas, estaremos tratando constantemente com a complexidade inerente aos problemas que desejamos que nosso programa de computador resolva. Para tratarmos da complexidade dos problemas desenvolvemos algoritmos que devem expressar de forma objetiva e clara a forma de solucionarmos esse problema.

A partir do algoritmo desenvolvido fica fácil construirmos o programa, basta conhecermos a linguagem de programação que se pretende adotar. Uma vez construído o algoritmo, podemos transportá-lo para qualquer linguagem de programação, o que nos dá uma flexibilidade para a efetiva implementação do programa.

Características

Todo algoritmo deve apresentar algumas características básicas:

ter fim;

não dar margem à dupla interpretação (não ambíguo);

capacidade de receber dado(s) de entrada do mundo exterior;

poder gerar informações de saída para o mundo externo ao do ambiente do algoritmo;

ser efetivo (todas as etapas especificadas no algoritmo devem ser alcançáveis em um tempo finito).

Formas de Representação

Existem várias ferramentas que podem ser utilizadas para a representação de algoritmos, entre elas: linguagem natural, pseudocódigo (ou português estruturado), diagrama de Nassi-Shneiderman (ou Chapin), fluxogramas, etc.

A seguir, veremos em nível de detalhe algumas delas.

Descrição Narrativa

Faz-se uso da linguagem natural para descrever algoritmos.

Exemplo:

Receita de Bolo


7

Providencie ingredientes.

Misture os ingredientes.

Despeje a mistura na forma de bolo.

Leve a forma ao forno.

Espere 20 minutos.

Retire a forma do forno.

Deixe esfriar.

Prove.

Vantagens Desvantagens

O idioma é bastante conhecido por nós.

Imprecisão.

Pouca confiabilidade (a imprecisão acarreta a desconfiança).

Extensão (normalmente, escreve-se muito para dizer pouca coisa).

Existem três estruturas básicas para a construção de algoritmos: sequenciacão, seleção e repetição. A combinação destas três estruturas permite-nos a construção de algoritmos para a resolução de problemas extremamente complexos. A programação estruturada baseia-se nestas três estruturas básicas.

Imagine a seguinte situação: precisamos elaborar um algoritmo para trocar uma lâmpada.

Início

- pegue uma escada

- coloque-a embaixo da lâmpada

- busque uma lâmpada nova

- suba na escada com a lâmpada nova

- retire a lâmpada velha

- coloque a lâmpada nova

- desça da escada

Fim


8

Observe que este algoritmo resolve o nosso problema da troca de lâmpada. No entanto, trata-se de um algoritmo bastante simples, que se utiliza apenas da estrutura de sequenciação, ou seja, nenhuma seleção ou repetição de procedimentos aparece no algoritmo. Uma estrutura de sequência, caracteriza-se por possuir uma única sequência de ações, que é executada apenas uma vez.

No entanto, antes de trocarmos a lâmpada devemos nos certificar de que ela realmente esteja queimada, para então trocá-la. Assim, podemos melhorar nosso algoritmo.

Início

- ligue o interruptor

- se a lampada não acender, então:

- pegue uma escada






- desça da escada

Fim

Agora o nosso algoritmo, além da estrutura, de sequência, passa a utilizar uma estrutura de seleção. Na estrutura de seleção, uma condição deve ser analisada e, a partir do resultado da análise, um "caminho" do algoritmo será executado. Em outras palavras, uma estrutura de seleção escolhe ações a serem executadas a partir de uma condição (que pode ser simples ou composta).

Embora nosso algoritmo tenha melhorado, ainda podemos deixá-lo mais completo. Quando verificamos que a lâmpada está queimada, subimos para trocá-la, mas não consideramos a hipótese da lâmpada nova também estar queimada. Se isso ocorrer, precisaremos executar algumas ações novamente, até que possamos efetivamente resolver nosso problema.

Início

- ligue o interruptor

- se a lâmpada não acender, então:

- pegue uma escada


- enquanto a lâmpada não acender, faça:





- desça da escada

Fim


9

Neste algoritmo, somente iremos parar de trocar a lâmpada quando colocarmos uma lâmpada que acenda. Portanto, um conjunto de ações será executado repetidamente enquanto a condição de repetição for verdadeira. Assim, inserimos uma estrutura de repetição no nosso algoritmo, que passa a trabalhar com as três estruturas básicas de construção de algoritmos.

É importante salientar que existem várias formas de se construir um algoritmo, pois as pessoas pensam de formas diferentes. No entanto, devemos sempre buscar a forma mais otimizada possível (dentro dos limites impostos pela situação).

1.6 Exercícios Sugeridos

1) Crie uma sequência lógica para tomar banho.

a) Solução somente com estrutura sequencial:

b) Solução usando estrutura de seleção:

c) Solução com as três estruturas – sequência, seleção e repetição:

2) Descreva os passos necessários para somar dois números e multiplicar o resultado pelo primeiro número.

2) Descreva com detalhes a sequência lógica para trocar um pneu de um carro.


10

Unidade 2 - Diagramas de Fluxo

2.1 Diagrama de Nassi-Shneiderman

Também conhecido como diagrama de Chapin, esta ferramenta de representação oferece grande clareza para a representação de sequenciação, seleção e repetição num algoritmo, utilizando-se de uma simbologia própria.

A idéia básica deste diagrama é representar as ações de um algoritmo dentro de um único retângulo, subdividindo-o em retângulos menores, que representam os diferentes blocos de sequência de ações do algoritmo. Seleção e repetição também são representadas de forma gráfica, dentro dos retângulos

Sequência

Seleção

Ação - 1

Ação - 2

Ação - 3

Condição

V F

Ações Ações


11

Repetição

Exemplo

Queremos resolver o seguinte problema: Calcular a média de todos os alunos que cursaram uma disciplina X, a partir da leitura das notas da 1ª e 2ª prova, passando por um cálculo de média aritmética. Após a média calculada, devemos anunciar se o aluno foi aprovado ou reprovado por nota. Somente estão aprovados os alunos com média maior ou igual à 5,0.

Repetir até (condição)

Ações

Enquanto (cond) faça

Ações

Enquanto (não for fim da lista de alunos) faça

Leia nota3

Media = (nota1+nota2)/2

Media >= 5.0

V F

Aluno Aprovado Aluno Reprovado

Leia nota2

Leia nota1


12

Embora os diagramas N-S ofereçam uma representação muito clara do algoritmo, à medida que os algoritmos vão se tornando mais complexos, fica difícil realizar os desenhos necessários numa única página, prejudicando a sua visualização.

2.2 Fluxogramas

O fluxograma foi utilizado por muito tempo para a representação de algoritmos. No entanto, o seu grande problema é permitir o desenvolvimento de algoritmos não estruturados. Com o advento das linguagens de programação estruturada o fluxograma caiu em desuso.

O fluxograma utiliza-se de símbolos específicos para a representação de algoritmos. Existe uma certa variação na simbologia empregada, mas mesmo assim, apresentaremos a seguir uma simbologia tradicionalmente usada:

Processo

Decisão

Leitura

Escrita

Conector

Terminal

Setas de Fluxo de Controle


13

Exemplo

Com base no exemplo anterior, feito com N-S, complete o fluxograma abaixo:

Vantagens Desvantagens

É uma das ferramentas mais conhecidas.

Pouca atenção aos dados, não oferecendo recursos para descrevê-los ou representá-los.

Figuras dizem muito mais do que palavras.

Complica-se à medida que o algoritmo cresce.

Padrão mundial.


14

2.3 Linguagem Natural

A representação de algoritmos através de linguagem natural é a forma mais espontânea de representação de algoritmos, pois descrevemos os passos do algoritmo utilizando o nosso linguajar cotidiano, escrevendo o algoritmo como um texto simples.

Representação

Para todos os alunos da disciplina X, faça: ler as notas da 1ª e 2ª prova, somar as notas e dividir por dois, chegando assim, ao resultado da média do aluno. Se a média do aluno for maior ou igual a 5,0, então o aluno está aprovado, senão o aluno está reprovado. Fazer para o próximo aluno.

O problema da representação de algoritmos com linguagem natural é que quanto maior a complexidade do problema, maior a dificuldade de entendermos o texto que procura descrever os passos do algoritmo, pois não se emprega nenhum recurso diagramático, e não há uma rigidez na estruturação das ações.

2.4 Pseudocódigo

O pseudocódigo vem sendo amplamente utilizado por projetistas de softwares e programadores, pois obriga o uso de estruturas que facilitem o entendimento do algoritmo, e também facilitam a transformação do mesmo em códigos reais.

O pseudocódigo também recebe outros nomes, como: português estruturado, PDL (Program Design Language), pascalóide, etc.. Utilizaremos neste curso o pseudocódigo como a forma de representação padrão para algoritmos. Um dos ambientes que “entende” o pseudocódigo ou português estruturado é o AMBAP (Ambiente de Aprendizado de Programação desenvolvido pela UFAL – Universidade Federal de Alagoas).

O exemplo anterior será representado através de pseudocódigo.

//Algoritmo MediaAluno

variaveis

numerico nota1, nota2, media

inicio

faca enquanto (não for fim da lista de alunos)

leia (nota1)

leia (nota2)

media = (nota1+nota2)/2

se (media >= 5.0)entao

escreva ("Aluno aprovado")

senao

escreva ("Aluno reprovado")


15

fim_se

fim_enquanto

fim

Observe que no pseudocódigo, somos obrigados a utilizar algumas estruturas básicas de controle (sequência, seleção e repetição), de forma a estruturar e organizar melhor os passos do algoritmo.


16

Unidade 3 - Elementos Básicos do Código

3.1 Variáveis e Constantes

Variáveis e constantes são conceitos fundamentais para a construção de algoritmos e programas de computadores, pois são através deles que um algoritmo "guarda" os dados do problema.

Todo dado que tem a possibilidade de ser alterado (portanto, sofrer variação) no decorrer do tempo, deverá ser tratado como uma variável do problema e, portanto, deverá ser definido como tal no algoritmo a ser desenvolvido.

Quando um dado não tem nenhuma possibilidade de variar com o decorrer do tempo, ele deverá ser tratado como uma constante, e dessa forma definido e tratado como tal no algoritmo.

Por exemplo, considere o desenvolvimento de um algoritmo para o seguinte problema: calcular as áreas de cinco triângulos com medidas diferentes. Sabemos que a fórmula para o cálculo da área de um triângulo é "b*h / 2", onde "b" é o valor da base e "h" é o valor da altura do triângulo. Sendo assim, "b" e "h" são dados que irão variar no decorrer do "tempo de execução" do algoritmo, portanto deverão ser tratados como variáveis. O número "2" da fórmula é um dado constante e não sofrerá variação no decorrer do algoritmo, portanto, deve ser tratado como constante.

Variáveis e constantes são, em um algoritmo ou programa, nomes que identificam os valores tratados no problema. Estes nomes devem seguir algumas normas e regras para poderem funcionar corretamente:

Devem começar por um caractere alfabético;

Podem ser seguidos por mais caracteres alfabéticos e/ou numéricos;

Não é permitido o uso de caracteres especiais, como: @, #, &, *, +, ?, etc. (exceto o sublinhado), nem espaços em branco.

De maneira geral, devem ser legíveis e de fácil compreensão dentro do contexto, a fim de viabilizar o entendimento para outros programadores.

Exemplos:

X, x3, teste, altura1, nota2, abc213, a1b2c3, etc.

3.2 Tipos Primitivos de Dados


17

Todo dado a ser tratado num algoritmo deve pertencer a algum tipo, que irá determinar o domínio de seu conteúdo. Os tipos mais comuns de dados são conhecidos como tipos primitivos de dados, são eles: numérico, texto (ou caracter) e lógico1.

Neste curso, usaremos para a construção de nossos exercícios somente estes três tipos, mas saiba que existem vários outros e que, em outras bibliografias serão mais detalhistas.

Numérico: todos os valores do tipo numérico seja ele positivo, negativo, zero, ponto flutuante, decimal, etc.

Texto: todo e qualquer dado composto por um conjunto de caracteres alfanuméricos (números, letras e caracteres especiais), desde que estejam entre aspas.

Lógico: todo e qualquer dado que só pode assumir duas situações – verdadeiro ou falso (biestáveis).

3.3 Declaração de Variáveis

Para elaborarmos nossos algoritmos deveremos, antes de tudo, "listar" todas as variáveis que utilizaremos na construção do programa. Esse método é muito útil principalmente para códigos muito extensos, uma vez que, na maioria das linguagens de scripts não é necessário declararmos as variáveis.

Fazemos a declaração de variáveis obedecendo ao seguinte padrão:

//Algoritmo TesteVariaveis

variaveis

tipo: nome_variavel, nome2_variavel, etc

inicio

1 Na Unidade 14 encontram-se maiores explicações sobre a linguagem PHP, e na Unidade 15 sobre a linguagem C.


18

<desenvolvimento>

fim

Onde:

Tipo pode ser numérico, caracter ou lógico.

Nome_variavel é o identificador da variável.

Operadores (aritméticos, relacionais e lógicos)

Quando construímos algoritmos é comum trabalharmos com expressões matemáticas para a resolução de alguns problemas. As expressões matemáticas podem fazer uso de operadores aritméticos e relacionais.

Chamamos de operadores aritméticos o conjunto de símbolos que representa as operações básicas da matemática, conforme tabela a seguir:

Operações Operadores Linguagem C Linguagem PHP

Adição +

Subtração –

Multiplicação *

Divisão /

Potenciação ^ Não possuem um símbolo, fazem por função da linguagem

Módulo (resto da divisão)

Resto(x,y) % %

Há também um operador aritmético especial para obter o resto de uma divisão inteira. Usaremos para essa operação a função "resto".

Exemplo: resto(20, 3) = 2.

Um outro grupo importante de operadores é formado pelos operadores relacionais. Quando queremos fazer comparações entre valores, ou entre expressões (tanto matemáticas como lógicas), precisamos utilizar esta categoria de operadores. Os operadores relacionais são:

Operações Operadores Linguagem C

Linguagem PHP

Igualdade = ==

Diferença <> !=

Maior >

Menor <

Maior ou >=


19

igual

Menor ou igual

<=

O resultado de uma relação é sempre um valor lógico (verdadeiro ou falso).

Exemplos:

a) 2+5 = 3+2 F (falso)

b) 3*5 <> 2*3 V (verdadeiro)

Uma terceira categoria de operadores que podemos utilizar na construção de algoritmos é chamada de operadores lógicos. Estes operadores funcionam como conectivos para a formação de novas proposições.

Os principais operadores lógicos são:

Operações Operadores Linguagem C Linguagem PHP

Conjunção (e) E &&

Disjunção (ou) OU ||

Negação (não)

NAO !

Os resultados das operações lógicas são sempre valores lógicos (verdadeiro ou falso).

Para trabalharmos adequadamente com operadores lógicos, temos que conhecer a tabela verdade para cada um dos operadores. Uma tabela verdade é o conjunto de todas as possibilidades combinatórias entre os valores das variáveis lógicas, conforme apresentado a seguir:

A B A E B

F

F

V

V

F

V

F

V

F

F

F

V

A B A OU B

F F F


20

F

V

V

V

F

V

V

V

V

A NÃO( A)

F

V

V

F

Exemplos:

a) 3 > 6 OU 4 < 5

F OU V

Resultado: V

b) 4 < 7 E 5 > 9

V E F

Resultado: F

Na resolução das expressões aritméticas, lógicas e relacionais, os operadores e as funções matemáticas possuem uma hierarquia de prioridade.

Parênteses mais internos

Funções matemáticas

^

*

/

resto

+

-

operadores relacionais

não

e

ou


21

Exemplo:

Não( 2^3 < 4^2) ou abs(int(15/-2)) < 10

Não 8 < 16 ou abs (int(-7,5)) < 10

Não 8 < 16 ou abs (-7) < 10

Não 8 < 16 ou 7 < 10

Não( V ) ou V

F ou V

V

Exercícios Sugeridos

1) Sabendo que A=3, B=7 e C=4, informe se as expressões abaixo são verdadeiras ou falsas.

(A+C) > B ( )

B >= (A+2) ( )

C = (B-C) ( )

(B+A) <= C ( )

(C+A) > B ( )

2) Sabendo que A=5, B=4, C=3 e D=6, informe se as expressões abaixo são verdadeiras ou falsas.

(A>C) AND (C<=D) ( )

(A+B) > 10 OR (A+B) = (C+D) ( )

(A>=C) AND (D>=C) ( )


22

Unidade 4 - Comandos de Atribuição, Entrada e Saída de Dados

4.1 Comando de Atribuição

O comando de atribuição permite-nos atribuir um valor para uma variável, sendo que tipo do dado atribuído para a variável deve ser compatível com o tipo declarado para a variável. A sintaxe utilizada será:

Identificador := expressão2

onde identificador é o nome da variável que receberá o valor da expressão.

Exemplo:

X := 0

Y := 10 + 7

A := 0.098

Nome := "teste de atribuição"

Z := verdadeiro

2 Nas linguagens C e PHP o símbolo de atribuição é =, por exemplo, x = 5. Já, nestas linguagens a igualdade é

representada por ==.


23

4.2 Comando de Entrada de Dados

Na prática de construção de programas, será muito comum o uso de comandos que proporcionam a entrada de dados para o computador. Assim, devemos ter uma representação correspondente em nível de algoritmo para a entrada de dados. Utilizaremos o comando ler para efetuar a entrada de dados para o algoritmo, conforme sintaxe abaixo.

Ler variável

Sendo que variável receberá um valor vindo de "fora" do algoritmo para que algum processamento ocorra.

4.3 Comando de Saída de Dados

Além do comando de entrada de dados será muito comum o uso de comandos que proporcionem a saída de dados gerados pelo computador. Assim, devemos ter uma representação correspondente em nível de algoritmo para a saída de dados. Utilizaremos o comando escrever para efetuar a saída de dados do algoritmo, conforme sintaxe abaixo:

Escrever variável, constante, expressão

Neste exemplo, o algoritmo mostrará os valores de variáveis, constantes e/ou expressões.

//Algoritmo Exemplo

variaveis

numerico x, y, a, res

caracter nome

INICIO

Escrever "Entre com o primeiro valor:"

Ler x

Escrever "Entre com o segundo valor:"

Ler y

Escrever "Entre com o nome da pessoa:"

Ler nome

a:= x * 3 / y

res := (a * 2.4)/3

Escrever "O resultado foi: ", res

FIM


24

Unidade 5 - Estruturas de Sequenciação, Seleção e Repetição

5.1 Sequência

A estrutura de sequência é a estrutura mais simples que utilizamos na construção de algoritmos estruturados. Ela é formada por um conjunto de instruções (ou comandos) que serão executadas numa sequência linear de cima para baixo e da esquerda para a direita, ou seja, da mesma forma como elas foram escritas. Utilizamos as palavras inicio e fim para delimitar o bloco de sequência, conforme abaixo:

Exemplo:

INICIO

Ler a

Ler b

c := a + b

Escrever c

FIM

5.2 Seleção

Uma estrutura de seleção permite a escolha de um conjunto de ações e/ou estruturas que serão executadas a partir do resultado de uma condição (simples ou composta), representada por uma expressão lógica.

Utilizaremos a seguinte representação para estruturas de seleção:

se (condição) entao

comando 1

comando 2

comando 3

...

fim_se

No caso acima, os comandos somente serão executados se a condição for verdadeira, caso contrário, o programa continua executando os próximos passos logo após o símbolo de fechamento de chaves.

Temos ainda a possibilidade de outras representações mais elaboradas, como as que seguem:


25


comandos

...

senao

comandos

...

fim_se

ou


comandos

...

senao


comandos

...

senao

se (condição)entao

comandos

...

senao

comandos

...

fim_se

fim_se

fim_se

Nesses dois casos descritos acima, serão executados os comandos apenas de uma das condições e somente se ela for verdadeira. Caso não haja condições verdadeiras serão executados os comandos definidos dentro do bloco senão.

Teste de Mesa

É uma simulação da execução de um programa ou plano, usando para isso simplesmente papel e lápis para registrar o que teoricamente ocorre em cada passo. Serve para visualizarmos todas as etapas que o computador realiza durante a execução do algoritmo.

Exemplo de Algoritmo

Receba a nota da prova1


26

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

Faça o teste de mesa:

Nota da Prova 1

Nota da Prova 2

Nota da Prova 3

Nota da Prova 4

Utilize a tabela abaixo:

Exercícios

1) Identifique os dados de entrada, processamento e saída no algoritmo abaixo.

Receba código da peça

Receba valor da peça

Receba quantidade de peças

Calcule o valor total da peça

Mostre o código da peça e seu valor total

2) Faça um algoritmo para calcular o estoque médio de uma peça, sendo informado o estoque mínimo e o estoque máximo.

3) Construa um algoritmo que leia a cotação do dólar, leia valores em dólar, converta esse valor para real e mostre o resultado.

4) Desenvolva um algoritmo que leia 4 números, calcule o quadrado de cada um, some todos os resultados e mostre o resultado.

5) Construa um algoritmo para pagamento de comissão de vendedores de peças, levando em consideração que sua comissão será de 5% do total da venda e que você tem os seguintes dados: preço unitário da peça e quantidade vendida.

6) João 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 (50 quilos) deve pagar uma multa de R$ 4,00 por quilo excedente. João precisa que você faça um algoritmo que leia a variável P (peso do peixe) e verifique se há


27

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.

7) Elabore um algoritmo que leia as variáveis C e N, respectivamente código e número de horas trabalhadas de um operário. Após, 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 mostrar o salário total e o salário excedente.

8) Escreva um algoritmo que leia quatro números, calcule o quadrado de cada um e some todos. Se o quadrado do terceiro for maior que mil (1000), mostre o número original e finalize o programa. Caso contrário, mostre o resultado de todos.

9) Escreva um algoritmo que leia um número inteiro e mostre uma mensagem dizendo se este número é par ou ímpar, positivo ou negativo.

10) A Secretaria do Meio Ambiente que controla o índice de poluição mantém três 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,30 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 são intimadas a suspenderem suas atividades. Se o índice atingir 0,50 todos os grupos devem ser notificados a paralisarem suas atividades. Faça um algoritmo que leia o índice de poluição medido e emita a notificação adequada aos diferentes grupos de empresas.

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

5.3 Repetição

Laços Condicionais e Contados

A estrutura de repetição permite que uma sequência de comandos seja executada um certo número de vezes até que uma determinada condição seja satisfeita. Por exemplo, pode-se citar o caso em que se deseja realizar o mesmo processamento para um conjunto de dados diferentes, como a folha de pagamento de uma empresa de 100 funcionários. Neste caso o mesmo cálculo é efetuado para cada um dos funcionários. Para solucionar este problema precisaríamos escrever o algoritmo em questão uma vez para cada funcionário, ou seja, sendo 100 funcionários teríamos que escrevê-lo 100 vezes.

Outro modo de resolver essa questão seria utilizar a mesma sequência de comandos, ou seja, fazer a repetição de um conjunto de comandos 100 vezes sem ter que reescrevê-lo novamente.


28

A estrutura de repetição é também chamada de laço ou loop e se divide em:

Laços Condicionais

Quando não se conhece o número de vezes que um conjunto de comandos no interior do laço será repetido. A repetição ou não dos comandos dependerá do resultado de uma condição. As estruturas de repetição que implementam esse tipo de laço usam testes no início e testes no final do laço.

Laços Contados

Quando se conhece, previamente, quantas vezes o conjunto de comandos será executado. Esse tipo de estrutura usa variável de controle.

Repetição com Teste no Início

Caracteriza-se por uma estrutura que efetua um teste lógico no início do laço. Se o resultado do teste for verdadeiro o laço é executado retornando novamente ao teste lógico e assim o processo será repetido enquanto a condição testada for verdadeira.

Sintaxe:

faca enquanto (cond)

comando 1

comando 2

...

fim_enquanto

Repetição com Teste no Final


29

Caracteriza-se por uma estrutura que permite que um laço seja executado até que o resultado do teste lógico seja verdadeiro. Neste caso o laço é executado pelo menos uma vez e então a condição é testada, se o resultado for falso o laço é executado novamente e este processo é repetido até que o resultado da condição seja verdadeiro. A diferença que existe dessa estrutura para a anterior é o fato de ser executada pelo menos uma vez antes de passar pela condição de teste3.

Sintaxe:

faca

comando 1

comando 2

...

enquanto (cond)

Repetição com Variável de Controle

É utilizada quando se conhece previamente o número de vezes que se deseja executar um determinado conjunto de comandos. Esse tipo de laço nada mais é que uma estrutura dotada de mecanismos próprios para contar o número de vezes que o laço vai ser executado obedecendo os limites fixados.

Sintaxe:

para variavel de valor_inicio ate valor_final passo incremento

comando 1

comando 2

...

3 No AMBAP é implementada somente repetição teste condicional no início, porém, em várias linguagens de

programação existem as duas formas apresentadas, por isso constam na apostila.


30

proximo

onde: variável é inicializada com o valor de valor_inicio e, subsequentemente, incrementada de incremento, executando comando1, comando2, ... até que variável atinja o valor_final. Caso a expressão passo seja omitida, o valor padrão 1 é assumido.


1) Escreva um algoritmo que leia as notas finais dos alunos de uma disciplina e calcule a média da turma.

2) Escreva um algoritmo que leia o nome o sexo a altura e o peso de um grupo de 250 pessoas e informe: Média das alturas das mulheres e o nome do homem mais pesado.

3) Escreva um algoritmo que leia dois números inteiros (inicial e final) e mostre os números pares desse intervalo. Além disso, deve mostrar também quantos são e qual é a soma desses números.

4) Construa um algoritmo que leia 500 valores inteiros positivos e encontre o maior valor, o menor valor e calcule a média dos números lidos.


31

Unidade 6 - Vetores e Matrizes (Arrays)

6.1 Vetores

Vetores são estruturas de dados que permitem o armazenamento de um conjunto de dados, que podem ser referenciados por um mesmo nome e acessados por um índice.

Diferentes linguagens implementam vetores de diferentes formas, podendo restringir seu uso apenas a vetores homogêneos (em que todos os dados da estrutura tem o mesmo tipo) ou aceitar vetores heterogêneos (em que cada dado pode ser de um tipo diferente). Também pode ser possível construir vetores multi-dimensionais, indexados por mais de um índice.

No exemplo abaixo observamos um exemplo de um vetor homogêneo unidimensional (o tipo mais utilizado e que deve ser o primeiro que o aluno deve entender e dominar).

Exemplo:

//Algoritmo Soma_Valores

variaveis

matriz numerico vet[50]

numerico soma, i, val

INICIO

val := 50

escrever "entre com ", val, " valores"

para i de 1 ate val

ler vet[ i ]

proximo

soma:=0

para i de 1 ate val

soma = soma + vet[ i ]

proximo

escrever "a soma foi", soma

FIM

Observando o código anterior, o uso do vetor é razoavelmente claro. Inicialmente ele é utilizado para armazenar os valores que vão sendo lidos, e em seguida é utilizado no cálculo da variável Soma.


32

Obviamente o exemplo acima poderia ser reproduzido sem o uso de vetores, com o cálculo da variável Soma durante a leitura. Porém, isto pode não ser possível em exemplos mais complexos, como os sugeridos a seguir.

6.1 Matrizes

A matriz mais comum é a de duas dimensões (linha e coluna), por se relacionar diretamente com a utilização de tabelas. Trabalharemos somente com matrizes de 2 dimensões, por serem mais comuns, mas podem ser necessárias, em algum momento, matrizes de 3 ou mais dimensões.

Uma matriz de 2 dimensões estará sempre fazendo menção a linhas e colunas e será representada por seu nome e tamanho. Dessa forma, uma matriz Tabela[8,5] indica que tem 8 linhas e 5 colunas, conforme a figura.

A matriz pode ser declarada da seguinte forma:

variaveis

matriz numerico M[10,10]


1) Crie uma novo algoritmo, com base no algoritmo sobre vetores, em que após a leitura de todos os dados, pergunte ao usuário se ele deseja a multiplicação dos dados lidos, sua soma ou o cálculo de sua média. Conforme a entrada informada pelo usuário, uma resposta diferente é fornecida pelo sistema.

2) Faça um algoritmo também baseado no exemplo, que após terminada a entrada de dados, exiba todos os números do vetor de forma ordenada.


33

Unidade 7 - Subrotinas (procedimentos e funções)

7.1 Utilização de subrotinas

À medida que a complexidade de um algoritmo aumenta, surge a necessidade de dividir um grande problema em problemas menores, para que seja compreendido mais facilmente. Dessa forma, cada parte menor (módulo) tem um algoritmo mais simples, e esse trecho menor é chamado de subrotina.

Além de facilitar a compreensão do algoritmo, as subrotinas possibilitam que determinados trechos de programas sejam aproveitados em outros programas. Isso facilita a correção, pois, se uma rotina para verificar se um número é ou não primo está incorreta, por exemplo, sabe-se exatamente qual é o trecho do programa que deve ser arrumado.

Rotinas que ficam demasiado complexas podem ainda ser divididas em diversas outras rotinas mais simples. O processo de dividir uma subrotina em outras é denominado refinamento sucessivo.

O processo de se programar um computador torna-se bastante simples quando aplicado algum método para utilização das subrotinas. Um dos métodos mais utilizados na programação estruturada é o método TOP-DOWN (de cima para baixo) que se caracteriza por:

Antes de iniciar a construção do programa, o programador deverá ter em mente as tarefas principais que esse programa deverá executar. Não é necessário saber como funcionarão, somente saber quais são.

Deve-se ter em mente como será o funcionamento do programa principal, que controlará todas as tarefas distribuídas em subrotinas.

Uma vez definido o programa principal, detalha-se então as subrotinas. São definidos vários algoritmos, um para cada rotina em separado, para que se tenha uma visão do que será executado em cada módulo de programa. Isso também facilita a manutenção (alterações posteriores necessárias).

O método Top-Down pode ser graficamente visualizado conforme a figura:


34

Existem dois tipos de sub-rotinas a serem utilizados na programação, conhecidos como procedimentos (procedures) e funções (functions). As diferenças entre eles são apresentadas a seguir.

7.2 Procedimentos

São, na realidade, trechos de programas independentes mas que, para serem processados, devem ser solicitados pelo programa principal. Exemplo:

procedimento NomeProcedimento ( lista de parâmetros )

inicio

<comandos>

fim

A lista de parâmetros, definida no cabeçalho do procedimento, produz a comunicação de dados entre o procedimento e quem o chamou. O procedimento pode ter de nenhum a vários parâmetros, sendo que também pode ter vários parâmetros de entrada, de saída ou ambos. Exemplos:

...

limpa_tela // sem nenhum parâmetro

...

limpa_tela(01,01,24,80) // com parâmetros de entrada somente

...

Fatorial (5; retorno) // 5 é parâmetro de entrada e retorno é parâmetro de

saída

escrever retorno

...

7.3 Funções

É um caso particular de procedimentos. A diferença porém, é que apenas uma informação é retornada ao programa que a chamou, ou seja, os parâmetros, se existentes, são todos de entrada e obrigatoriamente há uma e somente uma saída ou retorno para o programa principal.

Algumas linguagens obrigam que a chamada de função nunca seja sozinha, como os procedimentos, mas sim fazendo parte de um comando de atribuição ou de uma expressão. A sua declaração segue o seguinte formato:

Funcao NomeFunção ( lista de parâmetros)

inicio

<comandos>

retornar ( parâmetro )

fim

Exemplos do uso de funções:

variaveis


35

numerico A,B

Funcao Soma (A, B)

variaveis

numerico x

inicio

x := A + B

retornar(x)

fim

//Programa principal

Inicio

Ler A

Ler B

escrever "Soma de A e B:", Soma(A,B)

Fim

As rotinas podem ficar no início de um programa, no final ou ainda em um arquivo separado, dependendo da linguagem utilizada. Uma função pode ainda retornar um valor verdadeiro (v) ou Falso (f).

Nesse caso, as rotinas 1, 1.1 e 2 "enxergam" as variáveis A e B, porém, dentro da Rotina 1, a variável A é definida novamente. Dessa forma, o novo valor da variável será válido para a rotina 1.1.

As variáveis X e Y não serão visualizadas pelo programa principal.

A variável X presente na rotina 2 não interfere na variável X que está na rotina 1 (são independentes).

A estas peculiaridades denomina-se Escopo de Variáveis.


36

Unidade 8 - Conteúdo Dinâmico

8.1 Conteúdo Dinâmico - Conceito

A linguagem HTML permite a criação de páginas para a Web contendo texto, imagens, etc, mas uma limitação desta linguagem é que não é possível produzir conteúdo que sofra mudanças de acordo com fatores externos.

Para isso criou-se as linguagens conhecidas como Server side, ou seja, linguagens que são processadas no servidor web e nos permitem uma gama de recursos que até então não existiam, como por exemplo:

- Utilização de variáveis

- Processamento de dados de formulários

- Acesso a bancos de dados

Quando navegamos por um site chamado estático, ou seja, com conteúdo imutável, a cada clique disparamos o seguinte processo:

1- O navegador solicita ao servidor uma página HTML.

2- O servidor procura por este arquivo e o retorna para o navegador.

Agora veja a diferença quando navegamos por um site com conteúdo dinâmico:


37

1. O navegador solicita ao servidor um arquivo de linguagem server side.

2. O servidor procura por este arquivo e passa para o interpretador desta linguagem, que processa os comandos contidos neste arquivo.

3. Após o processamento o interpretador retorna para o servidor Web o resultado deste processamento, formatado em HTML.

4. O Servidor então, retorna ao navegador este resultado.

8.2 Linguagens:

Entre as linguagens mais populares atualmente no desenvolvimento de sites dinâmicos podemos citar o ASP (Active Server Pages, mantido pela Microsoft), JSP (Java Server Pages, mantido pela SUN) e o PHP (PHP Hypertext Preprocessor, mantido pelo PHP Group).

Resumo:

- Websites dinâmicos possuem como principal característica páginas que têm conteúdos que podem variar de acordo com fatores externos ao código HTML.

- As duas principais linguagens utilizadas no desenvolvimento de websites dinâmicos são o ASP, da Microsoft e o PHP, do PHP Group.


38

Unidade 9 - Linguagem PHP

PHP é uma linguagem server side que foi criada originalmente pelo programador Rasmus Lerdorf para utilização em seu site pessoal. Originalmente a sigla queria dizer Personal Home Page, significado que demonstrava bem que a linguagem ainda dava seus primeiros e despretensiosos passos.

A linguagem que mais influenciou o PHP foi à linguagem Perl, utilizada no início da web principalmente para o tratamento de dados de formulários com os famosos “scripts CGI”.

Após a adição de um pacote para tratamento de dados de formulário e outro que dava suporte à conexão com bancos de dados mSQL (miniSQL), a linguagem foi disponibilizada para o público e passou a receber contribuições de diversos programadores.

A primeira versão do PHP utilizada em larga escala foi à versão 3, que embora contendo pequenos bugs, já era utilizada por milhares de websites.

Hoje o PHP se encontra na versão 5 e possui suporte à conexão com os mais diversos bancos de dados, Orientação a Objetos, geração dinâmica de gráficos, LDAP, XML, etc...

9.1 Como criar um arquivo PHP

Por ser uma linguagem interpretada, um arquivo PHP nada mais é do que um arquivo texto. Devido a esta característica, um arquivo PHP pode ser criado em praticamente qualquer editor disponível no mercado, desde os mais avançados até os mais simples, como o Bloco de Notas.

Todo arquivo PHP deve possuir a extensão .php, para possibilitar ao servidor web distingui-lo dos demais arquivos (HTML, JavaSript, XML, etc...).

É esta extensão que permite ao servidor web “saber” que este arquivo deve ser repassado ao interpretador PHP antes de retornar o resultado para o navegador.

Mas não basta que informemos ao servidor web que este arquivo deve ser passado para o interpretador, devemos informar ao interpretador que partes deste arquivo devem ser processadas como código PHP, o que nos leva ao nosso próximo tópico:

9.2 Delimitando o código PHP

Vejamos a diferença de uma página HTML comum, que cumprimenta o usuário que está entrando em nosso site, e uma página PHP que fará a mesma coisa, porém chamando o usuário pelo seu nome. Não se preocupe neste momento com sintaxe e comandos PHP. Este exemplo apenas ilustra a utilização de delimitadores.

Exemplo 1: index.html

<html>

<head>

<title>Teste 1</title>


39

</head>

<body bgcolor=”#FFFFFF”>

Olá, Usuário!

</body>

</html>

Exemplo 2: index.php

<html>

<head>


</head>

<?php $usuario = „Paulo‟; ?>


Olá, <?php echo $usuario; ?>!

</body>

</html>

Note que temos dois pares de tags que não são HTML, representados pela tag <?php e a sua tag de fechamento, ?>. Tudo o que estiver entre estas duas tags é automaticamente processado pelo interpretador PHP como código, enquanto que o restante é tratado como HTML comum, e por consequência, ignorado pelo interpretador.

9.3 Delimitadores alternativos

Embora as tags de delimitação de código PHP que são utilizadas como padrão pelos programadores sejam as tags <?php e ?>, o interpretador reconhece como válidas as seguintes alternativas:

- <? e ?>

Não recomendável pela possibilidade de confusão com arquivos XML, que possuem uma tag que inicia exatamente pelos caracteres < e ?.

- <% e %>

Não recomendável pela possibilidade de confusão com arquivos ASP, que utilizam exatamente à mesma notação.

- <script language=”php”> e </script>

Não recomendável por se tratar da notação padrão para scripts client side (que são executados no lado cliente), como JavaScript, por exemplo.

A não ser que haja um forte motivo para utilizar um dos delimitadores acima, recomendamos enfaticamente

o uso dos delimitadores padrão: <?php e ?>.

9.4 Separadores de instruções

Existem duas formas de separar instruções em PHP:


40

- Para separar linhas de comandos utilizamos o ponto e vírgula, como no exemplo abaixo:

Exemplo: Delimitando comandos

<?php

$usuario = „Paulo‟;

echo “Olá, $usuario!”;

?>

- Para delimitar blocos de códigos em Estruturas de Controle (que veremos mais adiante) utilizamos chaves:

Exemplo: Delimitando blocos

if ($usuario == „Paulo‟)

{

echo “Olá, $usuario!”;

}

Note que o comando que define o bloco de código não é terminado por ponto e vírgula.

9.5 Comentários

Comentários servem, principalmente para auxiliar o programador ou à equipe de programadores a se orientar dentro de um código e para ajudar na tarefa de debug de um arquivo PHP. Comentários são absolutamente ignorados pelo interpretador.

Existem duas formas de comentários disponíveis em PHP:

- Comentários de uma linha ou linhas comentadas: São comentários curtos que começam e terminam na mesma linha. Para comentar uma linha utilizamos duas barras:

Exemplo: Comentário de uma linha

<?php

// Este é um comentário de uma linha.

?>

Comentários em mais de uma linha, ou blocos comentados: São comentários mais extensos, utilizados para grandes descrições ou para anular a execução de uma série de linhas de código. Para isso utilizamos uma notação semelhante à tags HTML: iniciamos o comentário por uma barra e um asterisco e o finalizamos com um asterisco e uma barra:

Exemplo: Bloco comentado

<?php

/* Este é um comentário

em mais de uma linha. Todo

este bloco será ignorado pelo

interpretador PHP. */

?>


41

9.6 Estruturas de dados

Estruturas de dados podem ser entendidas como “compartimentos” que nos permitem armazenar informações. Utilizamos estruturas de dados para que possamos trabalhar mais de uma vez com o mesmo dado em um programa.

Em PHP existem três estruturas básicas de dados, que veremos com mais detalhes a seguir:

- Variáveis

- Constantes

- Arrays

9.7 Variáveis

Variáveis são a estrutura de dados mais comumente utilizada. Uma variável é uma estrutura de dado que nos permite guardar apenas um valor por vez. Variáveis, assim como os arrays em PHP são denominadas pelo sinal de dólar.

Veja o exemplo, ainda utilizando a variável $usuario:

Exemplo: Utilizando variáveis

<?php

$usuario = „Paulo‟; // Inicializamos a variável usuario com o valor

Paulo

$usuario = „João‟; /* A partir deste momento a variável usuario troca

completamente de valor, contendo o valor João.*/

?>

9.8 Constantes

Constantes, ao contrário das variáveis, são estruturas de dados cujo valor é definido apenas uma vez, não podendo ser modificado. Embora o PHP aceite o nome de constante escrito em caracteres minúsculos, é uma boa prática de programação definirmos o nome de uma constante sempre utilizando apenas caracteres maiúsculos.

Constantes são declaradas através do comando define, com a seguinte sintaxe: define(nome_da_constante, valor [, insensibilidade_à_caixa]);

Veja o exemplo:

Exemplo: Declarando constantes

<?php

define (USUARIO, „Paulo‟);

define (Pais, „Brasil‟, FALSE);

?>


42

O parâmetro insensibilidade_à_caixa, que tem como parâmetros possíveis TRUE (verdadeiro) ou FALSE (falso) é opcional. Por default este parâmetro é TRUE, ou seja, a constante deve ser chamada sempre se respeitando maiúsculas e minúsculas.

Na segunda linha de nosso exemplo, a constante pode ser chamada de qualquer forma – Pais, PAIS, pais, PaIs, etc... – enquanto que na primeira linha o interpretador PHP só reconhecerá a constante se ela for chamada exatamente como foi definida, ou seja, toda em caixa alta.

9.9 Arrays

Arrays são vetores ou matrizes, estruturas de dados chamada compostas, pois têm como característica a possibilidade de armazenar mais de um dado ao mesmo tempo.

Estes dados são acessados através do que chamamos de índice.

Em PHP os arrays são definidos de uma forma mista: ao mesmo tempo em que declaramos o nome do array com o sinal de dólar, devemos utilizar o comando array para indicar que esta estrutura é de fato uma matriz.

Veja o exemplo de uma definição de array:

Exemplo: Definindo um array

<?php

$usuarios = array(„Paulo‟, „João‟);

?>

Neste exemplo definimos um array chamado usuarios contendo dois elementos: Paulo e João. Como não definimos explicitamente os índices deste array, eles são automaticamente definidos pelo interpretador de acordo com a ordem dos elementos.

É importante notar que, ao contrário do uso coloquial, o primeiro elemento de um array ordenado é sempre definido pelo índice zero. Caso queiramos chamar um elemento específico deste array, João, por exemplo, utilizamos a seguinte notação:

$nome_do_array[indice];

Assim sendo nosso exemplo de saudação ao usuário, utilizando um array, poderia ser escrito da seguinte forma:

Exemplo: Acessando um elemento de um array


43

<html>

<head>


</head>

<?php $usuarios = array(„Paulo‟, „João‟); ?>


Olá, <?php echo $usuarios[1]; ?>!

</body>

</html>

Podemos também criar o que chamamos de arrays associativos, ou seja, arrays cujo índice é explicitamente definido por nós:

Exemplo: Declarando um array associativo

<?php

$usuarios = array( „Paulo‟ => „Paulo da Silva‟, „João‟ => „João Paulo

da Costa‟);

?>

E para chamarmos algum dos elementos deste array utilizamos exatamente à mesma forma mencionada anteriormente:

Exemplo: Acessando um elemento de um array associativo

<?php

echo $usuarios[„Paulo‟];

?>

Resumo:

- Para delimitarmos comandos em PHP utilizamos o ponto e vírgula, enquanto que para blocos de códigos em estruturas de controle usamos as chaves.

- Comentários em PHP são marcados por duas barras quando forem comentários de apenas uma linha ou delimitados por barra e asterisco e asetrisco e barra quando forem comentários em mais de uma linha.

- Em PHP possuímos três estruturas básicas de dados: Variáveis, Constantes e Arrays, sendo estes últimos chamados de estruturas compostas, pois podem armazenar mais de um dado ao mesmo tempo. Todas as estruturas de dados em PHP são representadas pelo sinal de dólar.

9.10 Tipos de Dados Suportados

Existem 3 tipos básicos suportados pelo interpretador PHP:

- Strings ou texto.

- Numéricos – inteiros e de ponto flutuante.

- Booleanos

Veremos a seguir cada um destes tipos com maiores detalhes.

Strings


44

Strings podem ser compreendidas como texto. Este texto pode conter qualquer tipo de caractere, sejam números, letras, acentos, caracteres especiais, etc.

Strings são sempre delimitadas por aspas, que podem ser tanto duplas quanto simples. Os dois exemplos abaixo são variáveis que contém strings em seu valor:

Exemplo: Declarando strings

<?php

$var1 = „Teste‟;

$var2 = “Teste”;

?>

A diferença no uso das aspas simples ou duplas está na forma como o interpretador PHP tratará o conteúdo da string. No caso das aspas duplas poderá ocorrer o que chamamos de interpolação, ou seja, se uma string contiver uma variável, o interpretador PHP automaticamente converterá a variável para seu valor. As aspas duplas também permitem ao interpretador reconhecer caracteres especiais, como o caractere de nova linha, por exemplo.

No caso da utilização de aspas simples a interpolação não ocorre, assim como não ocorre o reconhecimento de caracteres especiais. Veja o seguinte exemplo para uma melhor compreensão das diferenças:

Exemplo: Utilização de aspas simples e duplas

<?php

$var1 = “teste”;

$var2 = „teste‟;

echo “Isto é um $var2”;

echo „Isto é um $var1‟;

?>

O primeiro comando echo resultará no texto:

Isto é um teste

Enquanto que o segundo produzirá como resultado:

Isto é um $var1

Numéricos

Numéricos são os tipos que representam números. São eles:

- Inteiros

- De ponto flutuante, também conhecidos como float ou double.

Tipos numéricos são representados pela ausência de aspas:

Exemplo: Declarando variáveis numéricas


45

<?php

$var1 = 10;

$var2 = 0.5;

$var3 = -5;

?>

Booleanos

Um tipo booleano é o que representa apenas dois valores possíveis: verdadeiro ou falso. Normalmente estes valores são representados pelas palavras reservadas TRUE e FALSE:

Exemplo: Declarando uma variável booleana

<?php

$ativo = TRUE;

?>

É importante ressaltar que o interpretador PHP sempre considerará um valor como sendo verdadeiro, a não ser nos seguintes casos:

- O booleano FALSE

- O inteiro 0 (zero)

- O float 0.0

- A string vazia „‟ ou “”

- A string “0” ou „0‟

- Um array vazio

Conversão de tipos

A exemplo de outras linguagens web, PHP procura fazer a conversão de tipos automaticamente.

Exemplo: conversão automática de tipos

<?php

$var1 = “1”;

$var1 += 5;

$var1 += 2.7;

?>

Neste exemplo nossa variável $var1 começa contendo uma string. Na segunda linha ela passa a conter um inteiro, enquanto que a partir da terceira linha seu valor passa a ser um float.

Também é possível alterar o tipo de dado de uma variável utilizando-se o comando settype, que possui a seguinte sintaxe:

settype(variável, tipo);

O parâmetro tipo deve conter um destes possíveis valores:


46

- Boolean

- integer

- float

- string

Sendo assim, nosso exemplo de transformação de tipos poderia ser reescrito de forma à não ser necessário modificar o valor da variável:

Exemplo: modificando o tipo de uma variável com a função settype

<?php

$var1 = “1”;

settype($var1, „integer‟);

settype($var1, „float‟);

?>

Resumo

- PHP suporta os seguintes tipos básicos: string, numérico e booleano.

- Para realizar a conversão entre tipos efetuamos operações com a variável ou utilizamos o comando settype.

9.11 Estruturas de Controle

Estruturas de controle são comandos que nos permitem controlar a forma como nosso programa será executado. Existem dois tipos de estruturas de controle:

- Condicionais

- Loops

Veremos agora cada uma das estruturas com mais detalhes.

Condicionais

Estruturas condicionais, como o próprio nome já diz, são estruturas que impõem uma condição para que um ou mais comandos sejam executados. São elas:

If Sintaxe:

if (condição)

{

comandos

}

Descrição:

O if é a estrutura condicional mais simples. Os comandos contidos no bloco delimitado pelas chaves só serão executados no caso da condição ser verdadeira.

Exemplo: Utilizando uma condicional if


47

if ($usuario == „Paulo‟)

{

echo “Olá, Paulo.”;

}

O if suporta, ainda, múltiplas condições e o que fazer se a condição for falsa. Isto é feito através das condições else if e else:

if (condição1)

{

comandos

}

else if (condição2)

{

comandos

}

else

{

comandos

}

Switch sintaxe:

switch(variável)

{

case valor1:

comandos

break;

case valor2:

comandos

break;

default:

comandos

}

Descrição: O condicional switch é comumente utilizado para evitar instruções if-else if muito longas, ou seja, quando queremos testar uma gama muito grande de condições.

Cada instrução case testa pela igualdade da variável com o valor. Note que a limitação que ocorre com o condicional switch é que apenas a igualdade é testada. A instrução break é obrigatória entre cases, pois é ela que separa os blocos de instruções que serão executadas dependendo de cada condição.

A instrução default é opcional e diz para o interpretador PHP o que fazer se todas as condições expostas nas instruções case forem falsas.

Exemplo: Utilizando uma condicional switch


48

switch($usuario)

{

case „Paulo‟:

echo “Olá Paulo.”;

break;

case „João‟:

echo “Olá João”;

break;

default:

echo “Usuário desconhecido”;

}

Loops (laços de repetição)

Loops são estruturas que causam a repetição de uma série de instruções dependendo ou não de uma condição. São elas:

For sintaxe:

for (inicialização_variável; condição_variável; operação)

{

comandos

}

Descrição:

Um loop for é uma estrutura de controle que causará a repetição de comandos com um número finito de iterações. Para isso criamos uma variável contadora, testamos uma condição e a incrementamos ou decrementamos para que o loop tenha continuidade.

Exemplo: Utilizando um loop for

for ($c = 0; $c < 10; $c++)

{

echo “Esta é a $c ª iteração de nosso loop de exemplo.”;

}

Em nosso exemplo teremos 10 iterações em nosso loop (de 0 a 9).

While sintaxe:

while(condição)

{

comandos

}


49

Descrição:

Um loop while é executado quantas vezes forem necessárias até que a condição especificada seja satisfeita (seja verdadeira).

Exemplo: Utilizando um loop while

$c = 0;

while ($c < 10)

{

echo “Esta é a $c ª iteração de nosso loop de teste.”;

$c++;

}

Note que para reproduzir o comportamento de nosso loop for com um loop while precisamos incluir duas instruções explícitas:

Na primeira linha inicializamos nossa variável com o valor zero. Se esta linha estivesse dentro do bloco a ser executado pelo loop teríamos o que chamamos de loop infinito, pois a cada iteração a variável seria reinicializada com o valor zero e, portanto, seria sempre menor do que 10.

Na última linha de nosso bloco de instruções incrementamos a variável (o equivalente à operação $c = $c + 1;). Se esta linha estivesse fora do bloco a ser executado pelo loop também teríamos um loop infinito, pois o incremento jamais aconteceria e a variável seria sempre menor do que 10.

do-while sintaxe:

do

{

comandos

}

while (condição)

Descrição:

O loop do-while é extremamente parecido com o loop while, mas possui uma diferença importantíssima: o bloco de comandos será executado sempre pelo menos uma vez, já que a condição é testada apenas no final da primeira iteração.

Exemplo: Utilizando um loop do-while

$c = 0;

do

{

echo “Esta é a $c ª iteração de nosso loop de teste.”;

$c++;

}

while ($c < 10)

Note que se tivéssemos inicializado a nossa variável contadora com o valor 1 e testássemos à condição $c < 1 ainda assim teríamos uma execução do loop, pois a condição só começa a ser testada após a primeira iteração.


50

Arrays (vetores e matrizes)

Para sabermos quantos elementos existem em um array utilizamos à função count:

count (array [, modo]);

Exemplo: Retornando o número de elementos em um array

$numero_usuarios = count ($usuarios);

O parâmetro modo é opcional e pode conter um dos seguintes valores:

1 ou COUNT_RECURSIVE – Conta recursivamente o número de elementos em um array multidimensional.

0 (zero) – É o modo default, ou seja, faz a contagem de forma não-recursiva, sendo o array multidimensional ou não.

Obtendo-se o número de elementos de um array temos condições de percorrer um array com um loop for:

Exemplo: percorrendo um array com um loop for

for ($c = 0; $c < count($usuarios); $c++)

{

echo “Olá, “.$usuarios[$c].”<BR>”;

}

Note que esta forma de percorrer um array, ao contrário do loop foreach, só funcionará com arrays de índices numéricos.

Funções (subrotinas)

A sintaxe básica para definir uma função é:

function nome_da_função([arg1, arg2, arg3]) {

Comandos;

... ;

[return <valor de retorno>];

}


51

Qualquer código PHP válido pode estar contido no interior de uma função. Como a checagem de tipos em PHP é dinâmica, o tipo de retorno não deve ser declarado, sendo necessário que o programador esteja atento para que a função retorne o tipo desejado. É recomendável que esteja tudo bem documentado para facilitar a leitura e compreensão do código. Para efeito de documentação, utiliza-se o seguinte formato de declaração de função:

tipo function nome_da_funcao(tipo arg1, tipo arg2, ...);

Este formato só deve ser utilizado na documentação do script, pois o PHP não aceita a declaração de tipos. Isso significa que em muitos casos o programador deve estar atento ao tipos dos valores passados como parâmetros, pois se não for passado o tipo esperado não é emitido nenhum alerta pelo interpretador PHP, já que este não testa os tipos.


52

Unidade 10 - Linguagem C

A linguagem C foi primeiramente criada por Dennis M. Ritchie e Ken Thompsom no laboratório Bell em 1972, baseada na linguagem B de Thompson que era uma evolução da antiga linguagem BCPL.

A linguagem ficou contida nos laboratórios até o final da década de 70, momento que começou a popularização do sistema operacional UNIX e consequentemente o C (o UNIX é desenvolvido em C).

As principais características da linguagem C são:

A união de conceitos de linguagem de montagem e programação de alto nível (o programador usufrui recursos de hardware sem a necessidade de conhecer o assembly da máquina);

Linguagem compilada;

Linguagem estruturada;

Possui poucos comandos;

Não possui crítica eficiente para erros de execução;

Uma linguagem em constante evolução. Existem versões orientadas a objeto e visuais como C++ e C++ Builder, entre outras.

10.1 Estrutura básica de um programa em C

Um programa em C consiste em uma ou várias funções, uma das quais precisa ser denomindada main. O programa sempre começará executando a função main. Definições de funções adicionais podem preceder ou suceder a função main.

Para escrever um programa em linguagem C é necessário seguir algumas regras gerais:

Toda função deve ser iniciada por uma chave de abertura { e encerrada por uma chave de fechamento };

Toda função é sucedida de parêntesis ( );

Todo programa deverá conter a função main;

As linhas de código são sempre encerradas por um “; (ponto-e-vírgula)” ;

A formatação dos programas é completamente livre, mas temos por conveniência manter a legibilidade;

Os comandos são executados na ordem em que foram escritos;

Os comentários devem ser delimitados por /* no início e */ no final. Podem ser usados também os caracteres // para comentários de uma linha.

Sintaxe básica:


53

/* Os comentários podem ser colocados em qualquer parte do programa */

Declaração de variáveis globais void main (void)

{

Declaração de variáveis locais

...

Comandos;

...

}

Tipo função (lista de argumentos)

{

Declaração das variáveis locais à função

...

Comandos;

...

}

Exemplo de um programa em C: #include <stdio.h>

#include <conio.h>

float processa(float r); //declaração da função processa

void main (void) // função principal main

{

float raio, area; //delcaração de variáveis locais

clrscr (); // comando para limpar a tela

printf(“Raio: “);

scanf(“%f”, &raio);

area = processa(raio);

printf(“Area: %f”, área);

getche();

}

float processa (float r) //implementação da função processa

{

float a; //declaração de variáveis locais

a=3.1415*r*r;

return(a);

}

10.2 Comando if

O comando if instrui o computador a tomar uma decisão simples. Se o valor entre parênteses da expressão de controle for verdadeiro ele executa as instruções, caso seja falso, as instruções serão ignoradas, ou executadas as que estão contidas no bloco do else.

O comando if encadeado e o comando switch possuem a mesma sintaxe da linguagem PhP.

Exemplo: if (x%2)


54

printf (“x é impar”);

else

printf (“x é par “);

10.3 Estruturas de repetição

Comando for: for (inicialização; teste; incremento)

{

comandos;

}

Exemplo: for (a=1; a<100; a++)

{

printf(“\n %i”, a);

}

Comando While sintaxe: while (expressão teste)

{

comandos;

}

Exemplo: while (conta < 10)

{

total = total + conta;

printf(“conta = %i, total = %i”, conta, total);

conta++

}

Comando do..while: do

{

comandos;

} while (expressão teste);

Exemplo: do

{

y--;

x++;

} while (y);

10.4 Arrays (vetores e matrizes)


55

Um vetor ou matriz é um tipo de dado usado para representar uma certa quantidade de valores homogêneos.

A linguagem C não valida limites dos vetores, cabe ao programador verificar o correto dimensionamento. O primeiro índice é o zero. Vetores possuem uma ou mais dimensões, como convenção, os vetores bidimensionais são chamados de matrizes.

Declaração: tipo variavel [tamanho]; //vetor

tipo variavel [tamanho] [tamanho]; //matriz

10.5 Funções (subrotinas)

Uma função é uma unidade de código de programa autônoma desenhada para cumprir uma tarefa particular.

A função recebe um certo número de parâmetros e retorna apenas um valor.

Da mesma maneira que são declaradas as variáveis, deve-se declarar a função. A declaração de uma função é chamada de protótipo e é uma instrução geralmente colocada no início do programa que estabelece o tipo da função e os argumentos que ela recebe.

Declaração tipo nome_função (declaração dos parâmetros)

void main(void)

{

a=nome_função(lista dos parâmetros);

}

tipo nome_função(lista dos parâmetros)

{

declaração das variáveis locais

comandos;

return (valor);

}

O tipo de uma função é determinado pelo tipo de valor que ela retorna pelo comando return e não pelo tipo de seus argumentos.


56

Unidade 11 - Fundamentos Orientação a Objetos

Orientação a Objetos é o nome que os pesquisadores da computação, na década de 70, usaram para batizar este novo paradigma. Esse nome foi dado porque, de acordo com a visão de mundo desses pesquisadores, tudo é objeto. Ou ao mínimo, se pretende que seja.

Um paradigma é uma maneira diferente de se tentar enxergar uma mesma coisa, um mesmo mundo. O paradigma da Orientação a Objetos (OO) busca bases filosóficas para tentar traduzir um mundo mais humano às instruções que o processador realmente entende. E são de viagens deste tipo, combinadas à estrutura de linguagens imperativas, como o C ou Pascal, que surgem as linguagens orientadas a objetos. E estas últimas se responsabilizaram pela existência da maioria dos grandes softwares produzidos nos dias atuais em todo o mundo.

A Crise do Software, ocorrida entre as décadas de 1960 e 1970, caracterizou-se principalmente por um motivo: complexidade. O modelo de desenvolvimento de sistemas da época já não atendia à demanda e não conseguia suprir, de forma adequada, todas as necessidades e/ou tarefas que envolviam a construção de um sistema de informação. Essa forma de trabalho acarretava diversos problemas, tais como:

Falta de produtividade das equipes;

Falta de qualidade e confiabilidade do software;

Grande dificuldade de manutenção;

Atraso na entrega do software ao usuário;

Tempo de vida do software curto;

Custos elevados de desenvolvimento e, principalmente, de manutenção.

Toda essa situação acabou levando os profissionais da época a buscar uma solução alternativa, pois a complexidade dos sistemas já havia chegado a tal ponto que nem os programadores conseguiam dominá-la mais. Sabia-se que as linguagens estruturadas, bem como o próprio paradigma, não davam mais suporte às necessidades, e esta, possivelmente, tenha sido a principal causa do surgimento da Orientação a Objetos.

O desenvolvimento orientado a objetos impõe (implicitamente) uma disciplina que diminui, se não todos, a grande maioria dos esforços inúteis provenientes da programação estruturada e/ou técnicas baseadas em banco de dados. Problemas, que muitas vezes, são complicados de serem resolvidos pela programação estruturada, são facilmente solucionados pela orientação a objetos.

Na Orientação a Objetos não existe um conceito de sistema, como na visão estruturada. Isto se deve ao fato de que aqui a ênfase é em objetos e classes, e não em sistemas e subsistemas. Um programa será então um grande objeto composto de outros objetos formando assim o que se chama de mecanismo, o qual define um contexto de negócio e seus respectivos cenários.

11.1 Conceitos básicos


57

Para compreender a essência da Orientação a Objetos é necessário conhecer e entender alguns conceitos. Alguns deles foram herdados do paradigma estruturado e receberam um enfoque um pouco diferente de sua aplicação. Para analisar problemas complexos, a metodologia de orientação a objetos utiliza os seguintes métodos:

Abstração;

Hierarquização;

Encapsulamento;

Modularização;

Classificação;

Relacionamento.

Abstração

Abstração é a habilidade de ignorar os aspectos não relevantes de um assunto para o propósito em questão, tornando possível uma concentração maior nos assuntos principais. Quando se quer diminuir a complexidade, seleciona-se parte do que está sendo analisado, em vez de tentar compreender o todo.

Selecionados os objetos, é necessário definir os procedimentos desses objetos, ou seja, definir o comportamento de cada objeto selecionado. Isto vem de acordo com o escopo do sistema. Só serão definidos os procedimentos que ajudarão a resolver o problema pelo qual o sistema está sendo criado. Definir procedimentos errados pode significar que o escopo do sistema e seus objetivos não foram bem entendidos e atendidos.

Abstrações permitem gerenciar a complexidade e concentrar a atenção nas características essenciais de um objeto. Uma abstração é dependente da perspectiva: o que é importante em um contexto pode não ser importante em outro. Levando em consideração essa definição, pode-se afirmar que o Princípio da Abstração é aplicado em todos os demais Princípios da Orientação a Objetos.

Hierarquização

Após dividir uma forma complexa em várias partes, é comum a hierarquização destas partes, ou seja, ordenação e organização delas. Essa organização, normalmente, parte do mais geral para o mais específico. É o que se chama de hierarquização. Por exemplo, a figura projeta uma hierarquia com a percepção do tipo de objeto Pessoa no nível mais alto, o que significa que Pessoa é um tipo mais geral de objeto que Empregado e que Estudante. Empregado e Estudante são subtipos de Pessoa, ou, da forma reversa, Pessoa é um supertipo de Empregado e de Estudante. Todavia, hierarquizar um todo não significa priorizar determinada parte.


58

O nível de detalhe do exercício da hierarquização depende única e exclusivamente do observador. A hierarquização de um sistema dá origem, normalmente, a poucos subsistemas, porque estes utilizam elementos comuns. Por exemplo, no microcomputador, o elemento memória é utilizado por todos os componentes: CPU, teclado e vídeo. Outro fato a se considerar para o nível de detalhamento da hierarquização é o objetivo e contexto do negócio, ou seja, para um bom entendimento do problema e, consequentemente, a criação de uma solução adequada a ele, é importante não perder o foco do objetivo que se deseja e o contexto do negócio ao qual se está trabalhando. Isso ajuda a delimitar o nível de detalhe do trabalho de hierarquização.

Encapsulamento

Encapsulamento é um mecanismo que utilizamos para esconder detalhes de estruturas complexas, que de outra forma iriam interferir na análise. O objetivo do encapsulamento é restringir ou definir o escopo da informação, para obter legibilidade, manutenibilidade e principalmente reutilizabilidade no desenvolvimento de sistemas.

O encapsulamento protege os dados de um objeto contra corrupção. Se todos os programas pudessem acessar os dados de qualquer maneira que os usuários desejassem, os dados poderiam se facilmente adulterados ou usados para fins indevidos. O encapsulamento protege os dados contra utilização arbitrária e que fujam aos objetivos.

O encapsulamento esconde, dos usuários de um objeto, os detalhes da implementação interna. Os usuários compreendem quais operações podem ser solicitadas de um objeto, mas não conhecem os detalhes de como a operação é executada. Todas as características específicas dos dados de um objeto e a codificação de suas operações ficam escondidas.

Classificação

Classificar é associar o objeto analisado a uma determinada categoria. Cada categoria possui características próprias. Ao se comparar as características do objeto analisado com as características daquela categoria, é que se pode dizer se um objeto pode ser ou não classificado como pertencente àquela categoria, definindo-se assim um tipo de objeto.

Um tipo de objeto é uma categoria de objeto.


59

Os tipos de objeto são importantes porque eles criam os elementos conceituais básicos para se projetar os sistemas. Na programação baseada em objetos, esses elementos básicos orientam o projetista na definição de classes e suas estruturas. Além disso, os tipos de objeto fornecem os índices para a operação do sistema. Por exemplo, operações tais como Contratar, Promover e Demitir estão intimamente ligadas ao tipo de objeto Empregado, porque elas alteram o estado de um empregado. Em outras palavras, um objeto só deve ser manipulado via operações associadas ao seu tipo. Sem tipos de objeto, portanto, as operações não podem ser definidas adequadamente.

Modularização

Modularizar é juntar partes com algumas semelhanças. Para melhor entendermos um sistema complexo, juntamos categorias com algumas características comuns em módulos.

Este conceito é bem empregado na fase de projeto do software. É através da aplicação dele que conseguimos organizar melhor os componentes de sistema, auxiliando no entendimento da construção, da manutenção e, muitas vezes, na implantação do software.

Relacionamento

Para o funcionamento do todo, é necessário que as partes funcionem separadamente, mas em conjunto. Este funcionamento em conjunto (cooperação) é possível porque as partes se relacionam entre si. O relacionamento entre os objetos é feito através de mensagens, passadas de uma parte para outra. Uma empresa, por exemplo, é composta de diversos departamentos, funcionando autonomamente. Mas, para que a empresa como um todo atinja seu objetivo (ou seja, lucre), é necessário um relacionamento entre estes departamentos, para que funcionem em conjunto. Este relacionamento é possível através da troca de mensagens entre os integrantes dos departamentos.

No paradigma da Orientação a Objetos, as mensagens trocadas entre os objetos podem ser entendidas como solicitações. Essa solicitação faz com que uma determinada operação seja ativada. A operação executa o método adequado e, opcionalmente, devolve uma resposta. A mensagem que constitui a solicitação contém o nome do objeto, o nome da operação e, às vezes, um grupo de parâmetros. Dessa forma, é possível realizar uma modelagem que espelha, o mais fiel possível, a realidade. Afinal, empresas, departamentos, setores e pessoas relacionam-se através de mensagens enviadas uns aos outros, ou seja, através de solicitações.

Objetos podem ser muito complexos, porque objetos podem ser feitos de outros objetos, que, por sua vez, podem ser feitos de outros objetos, e assim por diante. O usuário de um objeto não precisa tomar conhecimento de sua complexidade interna, apenas precisa saber como se comunicar com ele e como ele reage.

11.2 Classe

O termo classe se refere à implementação, no software, do tipo de objeto. Tipo de objeto é uma noção conceitual. Ele especifica uma família de objetos, sem estipular como eles são implementados. Os tipos de objeto são identificados durante as fases de Levantamento de Requisito e Análise. Os detalhes das classes são determinados na Análise e no Projeto.

Uma classe é uma implementação de um tipo de objeto. Ela tem uma estrutura de dados e métodos que especificam as operações que podem ser feitas com aquela estrutura de dados.


60

11.3 Colaboração

Os objetos colaboram entre si, a fim de disponibilizar as funcionalidades requeridas pelo sistema. Esta disponibilização de funcionalidades se dá através de troca de mensagens entre os objetos. Se um objeto precisa de uma informação que não é sua, ou seja, que está em outro objeto, este deve pedir para ele enviando uma mensagem. Um objeto Aluno, por exemplo, não pode cancelar sua própria matrícula. Ele deve enviar uma mensagem ao objeto Setor de Matrículas, solicitando o cancelamento de sua matrícula.

A seguir, veremos os tipos de colaboração que podem existir entre objetos.

Agregação

Agregar significa juntar, colar, grudar. Neste contexto, dizemos que agregação é o ato de agregar duas ou mais classes para formar uma nova classe, onde podemos identificar um relacionamento do tipo Todo-Parte. Esse relacionamento (todo-parte) pode ser visto de duas formas:

Composição: quando o todo não existe sem as partes. Por exemplo: um objeto da classe Aluno, para uma

universidade, não existe sem seu Currículo. O Currículo de um Aluno é algo pessoal e intransferível. Se um

Aluno for excluído, seu Currículo deve ser excluído junto.

Referência: quando o todo somente faz referência às partes. Por exemplo: um objeto da classe Nota Fiscal

faz referência a objetos do tipo Produto. A Nota Fiscal é composta, entre outras coisas, de uma lista de

produtos, mas se ela for excluída os produtos não precisam ser excluídos de seu cadastro original.

Generalização/Especialização

Especialização é quando, dada uma determinada classe ou categoria, criamos uma outra, com novos atributos ou serviços que a tornam mais restrita. Generalização é a operação inversa, ou seja, é a remoção de uma ou mais características de determinada classe, de modo a formar uma classe mais abrangente.

É importante entender que generalização é o mecanismo para expressar a similaridade entre classes. Esse princípio permite representar membros comuns, serviços e atributos uma só vez. Permite a reutilização de especificações comuns. Por exemplo: uma empresa possui o seu cadastro de Clientes. Podemos especializar a classe Cliente em Pessoa Física e Pessoa Jurídica.

Em programação, o conceito de generalização é visto como herança. Podemos, então, identificar basicamente dois tipos de herança: herança de INTERFACE e de IMPLEMENTAÇÃO. Herdar uma interface significa assumir o compromisso de oferecer as operações definidas pela interface, ou seja, todos os métodos declarados. Dessa forma, diz-se que se herda a interface da classe. Herdar a implementação significa que instâncias da classe especializada terão parte de seus estados definidos e também controlados pela classe mais geral, mas em compensação, as operações definidas na classe mais geral também se aplicam à classe especializada, o que permite reaproveitamento de código.

Polimorfismo


61

Muito provavelmente em alguns dos primeiros programas estruturados que criamos nos deparamos com uma pequena dúvida: “...será que eu poderia criar um procedimento em que o número de parâmetros modificasse em tempo de execução?”. A questão anterior na verdade que saber se é possível criar uma operação que mude seu código em tempo de execução. Esse tipo de questionamento é o princípio do polimorfismo. Ou seja, fazer a mesma coisa de várias formas ou de forma diferente (poli = muito; morfismo = formas).

A grande vantagem de serem permitidas implementações de polimorfismo é a flexibilidade. Por exemplo: Levando em consideração o desenho abaixo – Um Aluno comunica-se com o Setor de Matrículas – podemos entender que um Aluno pode solicitar a realização de sua matrícula, em um determinado curso ou disciplinas, para o Setor de Matrículas. Contudo, a forma com que sua matrícula vai se realizar vai depender do nível de ensino do curso em que ele quer se matricular: extensão, especialização, graduação, etc.

Para a matrícula em um curso de extensão necessita-se somente do nome e do RG da pessoa. Já para a matrícula de um curso de especialização é necessário o RG e a identificação do curso que a pessoa deseja seguir. E para a matrícula em um curso de graduação precisa-se somente do RG da pessoa e do código da disciplina que ela deseja cursar. Somente com o polimorfismo é que se pode realizar a mesma ação – no caso aqui se trata da ação de Matricular – de várias formas distintas, dando maior flexibilidade ao sistema.

11.4 Benefícios da Orientação a Objetos

A programação orientada encapsula dados (atributos) e métodos (comportamentos) em objetos; os dados e os métodos de um objeto estão intimamente associados entre si.

Estão listados a seguir os principais ganhos para o desenvolvedor, caso este troque a Metodologia Tradicional pela Orientada ao Objeto:

Exatidão – Devido à característica do desenvolvimento estruturado, onde se elabora um projeto e DEPOIS se faz os programas, podemos ter no final um sistema que não atenda perfeitamente seus objetivos depois de implementado. No desenvolvimento OOP, o desenvolvimento pode ser feito de maneira quase que interativa com o usuário, o que faz com que este risco caia significativamente. A pouca quantidade de código programável também reduz os problemas inerentes às mudanças das especificações durante o desenvolvimento do projeto.

Potencialidade – Definimos como potencialidade, a forma como o programa reage aos erros imprevistos tais como uma falha na impressora, ou um disco cheio. Quanto maior for a potencialidade, maior a capacidade do programa em causar o menor dano possível aos dados e evitar uma saída drástica do sistema.


62

Extensibilidade – Dizemos que quanto maior for a extensibilidade do software, maior será sua capacidade em adequar-se as especificações definidas pelos analistas.

Reutilização – A capacidade de se otimizar a produtividade do programador depende diretamente da maneira como o software disponibiliza a reutilização do código gerado. De fato, a maioria dos programadores profissionais já reutiliza códigos criados, porém a perfeita reutilização consiste na utilização COMPLETA de um código gerado para algum sistema SEM qualquer outra adaptação prévia.

Exercícios

Descrever os atributos de uma classe Pessoa.

Descrever os atributos de uma classe Carro.

Descrever os atributos de uma classe ContaCorrente.

Descrever os métodos de uma classe Pessoa.

Descrever os métodos de uma classe Carro.

Descrever os métodos de uma classe ContaCorrente.


63

Unidade 12 - Exercícios de Fixação

1. Escreva um algoritmo para calcular a média entre dois números quaisquer.

2. Escreva um algoritmo para calcular a área de um triângulo, exibindo o resultado final.

3. Escreva um algoritmo para calcular o valor de y como função de x, segundo a função y(x)=3x+2, num domínio real.

4. Escreva um algoritmo para efetuar a leitura de um número inteiro e apresentar o resultado do quadrado deste número.

5. Escreva um algoritmo para ler dois números quaisquer, calcular a soma deles e após mostrar os números lidos e o resultado da soma precedido da palavra "Resultado:".

6. Escreva um algoritmo para ler dois números quaisquer, dividir o primeiro pelo segundo. Mostrar os números lidos e o resultado calculado.

7. Escreva um algoritmo para ler três números quaisquer e calcular a média aritmética entre eles. Escrever os números lidos e a média calculada.

8. Escreva um algoritmo para ler dois inteiros (variáveis OP1 e OP2) e efetuar as operações de adição, subtração, multiplicação e divisão de OP1 por OP2 apresentando ao final os quatro resultados obtidos.

9. Escreva um algoritmo para ler dois inteiros (variáveis OP1 e OP2) e imprimir o resultado do quadrado da diferença do primeiro valor pelo segundo.

10. Escreva um algoritmo para ler dois números. Multiplicar o primeiro por 4 e o segundo por 6. Calcule a média aritmética dos resultados obtidos. Escrever os valores lidos, os calculados e a média aritmética.

11. Escreva um algoritmo para ler os seguintes números: OP1, OP2 e OP3. Após, calcular o valor de RESULTADO segundo a expressão:

12. RESULTADO = OP1^2 - 4OP2*OP3 e mostrar os valores lidos e o resultado.

13. Escreva um algoritmo para calcular e escrever o consumo médio de um automóvel (medido em Km/l), fornecida a distância total percorrida e o volume do combustível consumido para percorrê-la (medido em litros).

14. Escreva um algoritmo para calcular a média de quatro números inteiros e exibir o resultado final.

15. Faça um algoritmo que leia três notas de um aluno e calcule e escreva a média final deste aluno. Considerar que a média é ponderada e que os pesos das notas são 2, 3 e 5, respectivamente.

16. Escreva um algoritmo para calcular a função f(x,y)=2x+3y2, num domínio real.


64

17. Escreva um algoritmo que efetue e cálculo do salário líquido de um professor. Para fazer este programa você deverá possuir alguns dados, tais como: valor da hora aula, número de aulas dadas no mês e percentual de desconto do INSS. Em primeiro lugar, deve-se estabelecer qual será o seu salário bruto para efetuar o desconto e ter o valor do salário líquido. Ao final do algoritmo deve ser mostrado o salário bruto e o salário líquido do professor.

18. Faça um algoritmo que calcule a média ponderada de um aluno, a partir de suas 3 notas obtidas no curso, sabendo-se que a primeira avaliação tem peso 2, a segunda tem peso 4 e a terceira tem peso 4. Mostre, ao final, a mensagem : “A MEDIA FINAL DE ... FOI ...” . Informar também se o aluno foi aprovado, mostrando a mensagem “APROVADO” caso a nota final seja maior ou superior a 7,0.

19. Modifique o algoritmo da média do aluno para informar:

APROVADO ............ caso a nota final esteja no intervalo [10, 7]

RECUPERAÇÃO...... caso a nota final esteja no intervalo [5, 7)

REPROVADO .......... caso a nota final esteja no intervalo [0, 5)

20. Faça um algoritmo que leia 2 valores numéricos e um símbolo. Caso o símbolo seja um dos relacionados abaixo efetue a operação correspondente com os valores. Atenção para a divisão por 0!

“+” operação de soma

“-” operação de subtração

“*” operação de multiplicação

“/” operação de divisão

21. Dados 3 valores A, B, C, verifique se podem ser valores de lados um triângulo e, se for, determine se o triângulo é equilátero, isósceles ou escaleno.

22. Sejam 3 números distintos A, B, C. Coloque-os em ordem crescente, utilizando seleção encadeada (ou aninhada).

23. Faça um programa que lê dois valores, o primeiro servindo de indicador de operação e o segundo correspondendo ao raio de uma circunferência. Caso o primeiro valor lido seja igual a 1, calcular e imprimir a área desta circunferência. Se o valor lido for 2, calcular e imprimir o perímetro da circunferência. E se o valor lido for diferente destes dois valores, imprimir uma mensagem dizendo que o indicador de operação foi mal fornecido.

24. Uma loja fornece 5% de desconto para funcionários e 10% de desconto para clientes especiais. Faça um programa que calcule o valor total a ser pago por uma pessoa. O programa deverá ler o valor total da compra efetuada e um código que identifique se o comprador é um cliente comum ou um dos dois tipos de clientes que recebem desconto.

25. Construa um programa que receba os nomes de 5 clientes de uma loja e o valor (em reais) que cada um destes clientes pagou por sua compra. O programa deverá informar:

a) o valor total pago pelos 5 clientes; b) o valor da compra média efetuada; c) nome dos clientes que efetuaram compras superiores a 20 reais; d) o número de clientes que efetuaram compras inferiores a 50 reais.


65

26. A partir do preço à vista de um determinado produto, calcular o preço total a pagar e o valor da prestação mensal, referentes ao pagamento parcelado. Se o pagamento for parcelado em três vezes deverá ser dado um acréscimo de 10% no total a ser pago. Se for parcelado em 5 vezes, o acréscimo é de 20%.

27. O departamento que controla o índice de poluição do meio ambiente fiscaliza 3 grupos de indústrias que são altamente poluidoras 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 sobe para 0.4, as do 1º e do 2º grupos são intimadas a suspenderem suas atividades; e se o índice sobe para 0.5, todos os três grupos devem ser notificados a paralisarem suas atividades. Escreva um programa que lê o índice de poluição medido e emite a notificação adequada aos diferentes grupos de empresas.

28. Faça um programa que lê 4 valores I, A, B e C onde I é um número inteiro e positivo e A, B, e C são quaisquer valores reais. O programa deve escrever os valores lidos e:

a) se I = 1, escrever os três valores A, B e C em ordem crescente; b) se I = 2, escrever os três valores A, B e C em ordem decrescente; c) se I = 3, escrever os três valores A, B, e C de forma que o maior valor fique entre os outros dois;

d) se I não for um dos três valores acima, dar uma mensagem indicando isto.

29. Fazer um programa para imprimir o conceito de um aluno, dada a sua nota. Supor notas inteiras somente. O critério para conceitos é o seguinte:

nota inferiores a 3 - conceito E nota de 3 a 5 - conceito D

notas 6 e 7 - conceito C notas 8 e 9 - conceito B nota 10 - conceito A

30. Elabore um algoritmo que verifique se um dado número inteiro positivo é PAR ou ÍMPAR.

31. Escreva um algoritmo que leia um número n (número de termos de uma progressão aritmética), a1 (o primeiro termo da progressão) e r (a razão da progressão) e escreva os n termos desta progressão, bem como a soma dos elementos.

32. Escreva um algoritmo que lê um valor n inteiro e positivo e que calcula a seguinte soma:

S := 1 + 1/2 + 1/3 + 1/4 + ... + 1/n

O algoritmo deve escrever cada termo gerado e o valor final de S.

33. Escreva um algoritmo que leia um número n que indica quantos valores devem ser lidos a seguir. Para cada número lido, mostre uma tabela contendo o valor lido e o fatorial deste valor.

34. Escreva um algoritmo que leia um valor N inteiro e positivo e que calcule e escreva o valor de EX.

EX = 1 + 1 / 1! + 1 / 2! + 1 / 3! + 1 / N!


66

35. Faça um algoritmo que mostre os conceitos finais dos alunos de uma classe de 75 alunos, considerando:

i. os dados de cada aluno (número de matrícula e nota numérica final) serão fornecidos pelo usuário

ii. a tabela de conceitos segue abaixo:

Nota Conceito

de 0,0 a 4,9 D

de 5,0 a 6,9 C

de 7,0 a 8,9 B

de 9,0 a 10,0 A

36. Foi feita uma estatística nas 20 principais cidades brasileiras para coletar dados sobre acidentes de trânsito. Foram obtidos os seguintes dados:

b. código da cidade

c. estado (RS, SC, PR, SP, RJ, ...)

d. número de veículos de passeio (em 2007)

e. número de acidentes de trânsito com vítimas (em 2007)

Deseja-se saber:

i. qual o maior e o menor índice de acidentes de trânsito e a que cidades pertencem

ii. qual a média de veículos nas cidades brasileiras

iii. qual a média de acidentes com vítimas entre as cidades do Rio Grande do Sul.

37. Faça um algoritmo que leia um indeterminado número de linhas contendo cada uma a idade de um indivíduo. A última linha, que não entrará nos cálculos, contém o valor da idade igual a zero. Calcule e escreva a média das idades deste grupo de indivíduos.

38. Imagine uma brincadeira entre dois colegas, na qual um pensa um número e o outro deve fazer chutes até acertar o número imaginado. Como dica, a cada tentativa é dito se o chute foi alto ou baixo. Elabore um algoritmo dentro desse contexto, que leia o número imaginado e os chutes, ao final mostre quantas tentativas foram necessárias para descobrir o número.

39. Construa um algoritmo que permita fazer um levantamento do estoque de vinhos de uma adega, tendo como dados de entrada tipos de vinho, sendo: „T‟para tinto, „B‟ para branco e „R‟ para rose. Especifique a porcentagem de cada tipo sobre o total geral de vinhos; a quantidade de vinhos é desconhecida, utilize como finalizador „F‟ de fim.

40. Uma certa firma fez uma pesquisa de mercado para saber se as pessoas gostaram ou não de um novo produto. Para isso, forneceu o sexo do entrevistado e sua resposta (sim ou não). Este programa deverá ser executado até que o sexo X seja informado pelo usuário, encerrando, assim sua execução. Calcule e escreva os itens que seguem:

o número de pessoas que responderam sim;


67

o número de pessoas que responderam não;

a porcentagem de pessoas do sexo feminino que responderam sim; a porcentagem de pessoas do sexo masculino que responderam não.

41. Leia dez elementos de um vetor.

42. Leia oito elementos de um vetor A. Construa um vetor B de mesma dimensão com os elementos do vetor A multiplicados por três. Apresente o vetor B.

43. Leia dois vetores A e B com quinze elementos cada. Construa um vetor C, sendo este a junção dos dois vetores. Desta forma, C deverá ter o dobro de elementos de A e B.

44. Leia vinte elementos de um vetor A e construa um vetor B de mesma dimensão com os mesmos elementos de A, sendo que estes deverão estar invertidos, ou seja, o primeiro elemento de A passa a ser o último de B. O segundo elemento de A passa a ser o penúltimo de B e assim por diante. Apresente os dois vetores.

45. Leia doze elementos de um vetor colocá-los em ordem decrescente e apresente os elementos ordenados.

46. Leia um vetor A com doze elementos. Após sua leitura, coloque os seus elementos em ordem crescente. Depois leia um vetor B também com doze elementos. Coloque os elementos de B em ordem crescente. Construa um vetor C, onde cada elemento de C é a soma do elemento correspondente de A com B. Apresente os valores de C.

47. Escreva uma matriz que leia uma matriz M(6,6) e calcule as somas das partes indicadas:

a. Acima da diagonal secundária.

b. Abaixo da diagonal principal.

c. A esquerda abaixo da diagonal principal e acima da diagonal secundária.

d. Acima das diagonais principal e secundária.

Escreva M e as somas calculadas.

48. Considerando uma matriz M(5,5), efetue as seguintes somas:

a. soma dos elementos da linha 3;

b. soma dos elementos da coluna 5;

c. soma dos elementos da diagonal principal (i=j);

d. soma dos elementos da diagonal secundária (i+j=n+1);

e. soma dos elementos da matriz toda.

Escreva as somas calculadas.

49. Escreva uma matriz M(5,3) e a escreva. Verifique, a seguir, quais elementos de M que estão repetidos e quantas vezes cada um deles é repetido com uma mensagem dizendo que aparece X vezes em M.


68

lógica de programação - portal de cursos...

Documents