SISTEMA DE ENSINO PRESENCIAL CONECTADO ANÁLISE E DESENVOLVIMENTO DE SISTEMAS RICHARD MARTINS BUENO

PORTFÓLIO INDIVIDUAL

Poços de Caldas 2011

RICHARD MARTINS BUENO

PORTFÓLIO INDIVIDUAL

Trabalho apresentado a produção textual interdiciplicar indivual do 3º semestre do curso de analise e desenvolvimento de sistemas da Universidade Norte do Paraná - UNOPAR Prof. Márcio Chiavelli Profa. Merris Mozer Prof. Roberto Yukio Nishimura Profa. Simone Tanaka

Poços de Caldas 2011

....................................................SUMÁRIO 1 INTRODUÇÃO...................................................4 1 CONCLUSÃO.............................25 .........................................3 2 DESENVOLVIMENTO.........................................................................................................................................

Definição dos conceitos de alocação simplesmente encadeada. sendo cada parte relacionada a uma disciplina apresentada no módulo. exclusão e pesquisa. O trabalho foi dividido em 04 (quatro) partes para facilitar o entendimento. FILO. seus apontadores suas ordens para inclusão. explique como você representou o polimorfismo ? . 3 – Programação Orientada a Objetos Qual a vantagem de se utilizar Orientação a Objetos? Como e quando utiliza-se polimorfismo? 4 – Análise de Sistemas II Como pode-se representar polimorfismo no diagrama de classe. 2 – Banco de Dados II Definição dos conceitos das propriedades ACID de uma transação. exemplos do cotidiano e da informática sobre listas lineares. conforme abaixo: 1 – Algoritmos Pesquisa sobre listas lineares definindo os conceitos de FIFO. alocação duplamente encadeada.3 1 INTRODUÇÃO Este trabalho apresenta a produção textual interdisciplinar individual do 3º semestre do curso de análise e desenvolvimento de sistemas e tem como objetivo aplicar os conceitos das disciplinas apresentadas. representação grafica das duas alocações de encadeamento e resposta a qual delas tem maiores vantagens e o motivo.

DEL).4 2 DESENVOLVIMENTO 2.Letras de uma palavra . Não garante um tempo de resposta rápido. Não é eficiente em sistemas em tempo real.1 ALGORITMOS 2.Pessoas esperando ônibus . e DEQUEUE (retirar . Exemplos diarios de listas lineares: . que remove o elemento no início da fila.1 Listas Lineares Lista linear é a estrutura que permite representar um conjunto de dados afins. . Se processos maiores chegarem primeiro aumentarão o tempo médio de espera.1.1. • • Não é eficiente em sistemas de tempo compartilhado.Palavras de uma frase 2. Uma fila possui duas funções básicas: ENQUEUE (incluir . que adiciona um elemento ao final da fila.1. de forma a preservar a relação de ordem linear de seus elementos.1 Conceito de FIFO (First In First Out) O primeiro elemento que entrou é o primeiro a sair. Vantagens: • • O mais simples entre os processos de escalonamento Todos os processos tendem a serem atendidos Desvantagens: • • • Muito sensível a ordem de chegada. Estruturas lineares com esta disciplina de acesso são denominadas filas.INC).

e POP. Exemplos do cotidiado: -Pilhas de pratos.1. que remove o item no topo da pilha. Estruturas lineares com esta disciplina de acesso são denominadas pilhas. Exemplo de Fila: inicio Y F C INC “X” INC “T” DEL DEL INC “R” INC “J” DEL Resposta: C–X–T–R-J 2. que insere um dado no topo da pilha.5 Exemplo do cotidiado: fila de bancos. etc.2 Conceito de FILO (First in. Existem duas funções que se aplicam a todas as pilhas: PUSH. Last Out) O último elemento que entrou é o primeiro a sair. chamada topo. Exemplo: Considere a pilha abaixo: . É uma lista linear em que todas as inserções. as remoções e os acessos são feitos em uma única extremidade. pilhas de livros.1.

mesmo que a lista esteja vazia. Essa variável será utilizada sempre. Uma lista encadeada tem necessariamente uma variável ponteiro apontando para o seu primeiro elemento.6 13 19 14 10 Qual será seu o estado final. São chamadas de simplesmente encadeadas porque possuem somente o endereço do seu próximo (próximo elemento). Caso esta primeira variável não seja atualizada corretamente (no caso da inclusão de um elemento na primeira posição). e deverá apontar sempre para o início da lista (primeiro elemento). A grande diferença da lista para as outras estruturas de dados. é que as listas não possuem critério de inclusão e remoção de dados.1. após executar as seguintes instruções: Pop x Pop y Pop z Push y Push x Push z 14 13 19 10 Resposta 2. a lista poderá se perder na memória e não ser mais acessível. .3 Alocação Simplesmente Encadeada Cada nó da lista ponta para o próximo nó. A alocação simplesmente encadeada só pode ser percorrida em um único sentido.1. Um elemento da lista é composto de duas partes: a informação propriamente dita e uma conexão com o próximo elemento.

todas as listas devem possuir uma variável padrão. }tipoCelula. /* variavel auxiliar: ponteiro para uma estrutura tipoCelula Para reservar memória para nova célula. Uma vez que o primeiro elemento será uma célula. /* campo para os dados */ /* ponteiro para a proxima celula */ /* nome do novo tipo de estrutura */ Uma lista encadeada é toda alocada dinamicamente. portanto. a variável inicio possui valor NULL: Incluindo o primeiro elemento (primeira célula): TipoCelula aux. struct celula *proximaCelula. Sabemos que a memória alocada dinamicamente não possui um nome como acontece nas variáveis comuns. e cada célula é uma estrutura. que vai apontar para o seu inicio. então: inicio = NULL. Para uma lista vazia (sem células). /* ponteiro para uma estrutura tipoCelula */ Uma vez que a lista não possui elementos ainda.7 typedef struct celula { int dados. então a variável que apontará para o início da lista será um ponteiro de estrutura. A variável início mostrada na figura acima será então definida como: TipoCelula * inicio. utilizamos o comando . do tipo ponteiro.

podemos utilizar o ponteiro aux. Sendo assim: 1) aux->proximaCelula = NULL.8 malloc. // copia o endereco de aux em inicio Para inserir dados nesta primeira célula. aux->dados = 10. Temos então: E precisamos atualizar os ponteiros para que a lista receba seu primeiro elemento. /*atribui o valor 10 ao campo dados da célula pontada por aux Obs: Cada célula de uma lista também é chamada de nó ou nodo Exemplos: O programa a seguir cria uma lista com três nós. conforme exibida a abaixo inicio matricula proximo 1 1 2 3 . // atribui NULL ao campo proximacelula da célula apontada por aux 2) inicio = aux. aux = malloc (sizeof (tipoCelula)). que permanece apontando para a célula.

h> #include <stdlib. stuct no *proximo. /* NULL = Fim */ atual->proximo = novo. /* instancia o segundo nó */ novo->matricula = 2. atual=atual->proximo. *novo. *atual. /* aloca o nó na memória */ novo->matricula = 1.9 #include <stdio. /* NULL = Fim */ inicio = novo. } tipoNo. /* instancia o terceiro nó */ novo->matricula = 3. novo->Proximo = NULL. /* nó anterior aponta para o segundo lista */ atual = novo.h> main( ) { typedef struct no {int matricula. } getchar(). */ /* cria o primeiro registro (nodo 1) */ novo = malloc(sizeof (tipoNo)). /* atribui 1 para amatrícula */ novo->proximo = NULL. /* cria o segundo registro (nodo 2) */ novo = malloc(sizeof (tipoNo)). } . while (atual != NULL) { printf("\n matricula = %d ". /* NULL = Fim */ atual->proximo = novo. /* nó anterior aponta para o segundo lista */ atual = novo.atual->matricula). novo->Proximo = NULL. tipoNo *inicio. /* cria o terceiro registro (nó 3) */ novo = malloc(sizeof (tipoNo)). /* inicio aponta para o primeiro nó atual = novo. /* exibe os nós da lista */ atual = inicio.

h" #include <stdlib.i++) { novo = malloc(sizeof(tipoNo)). *novo. struct no *proximo. 2.1 O programa abaixo cria uma lista dinâmica (FILA) com 5 nós. while (atual != NULL) { printf("\n matricula = %d ". clrscr(). /* exibe a lista */ atual = inicio. respectivamente. atual = novo. #include "stdio. int i.i<6.atual->matricula). tipoNo *inicio. e 5. }tipoNo. 3. contendo as matrículas: 1. novo->matricula = i. *atual. else atual->proximo = novo. novo->proximo=NULL. inicio = atual = NULL. } getch(). } Inicio matricula prox } 1 1 2 3 4 5 .h> main() { typedef struct no {int matricula. atual=atual->proximo. if (inicio == NULL) inicio = novo. 4. for (i=1.

/* inclui segundo registro na pilha */ novo = malloc(sizeof(tipoNo)). topo #include <stdio. }tipoNo. /* inclui terceiro registro na pilha */ novo = malloc(sizeof(tipoNo)). topo = novo. struct no *proximo. atual=atual->proximo. novo->proximo = topo. /* inclui primeiro registro na pilha */ novo = malloc(sizeof(tipoNo)). novo->proximo = NULL.h> main() { typedef struct no {int matricula. contendo as matrículas: 1. tipoNo clrscr().atual->matricula). novo->matricula = 3. /* exibe os registros da pilha */ atual = topo. } getch(). novo->matricula = 1. *topo. topo = novo. } Será exibido: matricula = 3 matricula = 2 matricula = 1 .1 O programa abaixo cria uma lista dinâmica (tipo Pilha) com 3 nós. *novo. 2. novo->proximo = topo. topo = novo. e 3. novo->matricula = 2. matriculaa prox 3 2 1 *atual. while (atual != NULL) { printf("\n matricula = %d ".

} getch(). topo = novo.h" main() { typedef struct no {int matricula.i<6. com as matrículas. } Será exibido: matricula matricula matricula matricula matricula = = = = = 5 4 3 2 1 *topo. topo matricula proximo 1 5 4 3 2 1 . }tipoNo. clrscr().atual->matricula). tipoNo int i. if (topo == NULL) novo->proximo = NULL. 2. for (i=1.4 e 5. atual=atual->proximo. novo->matricula = i. *atual. } /* exibe os registros da pilha */ atual = topo. while (atual != NULL) { printf("\n matricula = %d ". 1. topo = atual = NULL. *novo. #include "stdio. else novo->proximo = topo. struct no *proximo.3.1 O programa abaixo cria uma lista encadeada do tipo Pilha.i++) { novo = malloc(sizeof(tipoNo)).

aux receberá o endereço contido no campo proximo. no caso das pilhas). Observe o trecho de programa a seguir que exibirá todos os nós da lista. aux = aux->proximo.1 Percorrendo a lista Para percorrer uma lista (fila ou pilha) temos que utilizar uma variável auxiliar (ponteiro auxiliar). receberá o endereço da próxima célula (próximo nó). Enquanto aux for diferente de NULL. Inicialmente. Depois. } Inicio matricula proximo 1 1 2 3 4 5 . while (aux != NULL) { printf("\n matricula = %d ". aux deverá apontar para o início da fila (ou para o topo. } getchar(). aux = inicio. repete-se o processo acima.aux->matricula). ou seja.

atribuir ao campo ponteiro da última célula o endereço da nova célula TipoNo *aux.1 Incluindo um nó no final da lista (Fila) O último nó da lista não apontava para nenhum outro.alocar memória para o novo nó (malloc) . percorrer a lista até a última célula (aux apontará para o último nó) . este deverá apontar para o novo nó. novo = malloc(sizeof(tipoNo)) novo->valor = 55.atribuir dados aos campos de dados . *novo.atribuir NULL ao campo ponteiro da nova célula incluída . a lista ficará assim: Início 55 Valor 10 valor Proximo 27 valor Proximo Proximo . novo->proximo = NULL. aux->proximo = novo. agora. Início 1 0 valor 27 Próximo valor Proxi mo . while(aux->proximo != NULL) aux = aux->proximo.se a lista não é vazia. if (inicio != NULL) { aux = inicio. } Desta forma. *inicio.

/* aux aponta para o início da fila */ /* inicio aponta para o segundo nó */ /* libera da memória do primeiro nó */ A lista ficará da seguinte forma: inicio Dado prox 1 7 3 . aux = inicio. free(aux). ou inicio = inicio- tipoNo *aux. inicio = aux->prox. *inicio.1 Excluindo o primeiro nó da lista Início 2 Dado Prox 7 Dado Prox 3 Dado Prox apontar aux para o inicio da fila (aux = inicio) início recebe o endereço do segundo nó (inicio = aux-prox >prox) retirar o primeiro nó da memória ( free(aux) ).

/* libera área do nó 2 */ . /* nó 1 aponta para o nó 3 */ free(apaga). aux = inicio.percorrer a lista até o nó anterior ao de valor 7 (primeiro nó) .liberar a memória do nó de valor 7 ( free(aux) ) A lista ficará da seguinte forma: Início 2 Dado Prox 7 Dado Prox 3 Dado Prox tipoNo aux.atribuir o endereço do nó de valor 7 a um ponteiro auxiliar (para poder liberar a memória) .alterar o endereço apontado pelo nó 1. while(aux->prox->valor != 7) aux = aux->prox. apaga = aux->prox.1 Excluindo um nó qualquer da lista Observe a lista: Início 2 Dado Prox 7 Dado Prox 3 Dado Prox Desejamos fazer a exclusão do nó com valor 7 (segundo nó) . . apaga. /* apaga recebe o endereço do nó 2 */ aux->prox = apaga->prox. para que ela aponte para onde o nó de valor 7 aponta atualmente (nó 3).

/* ponteiro da celula anterior */ /* campo de dado */ /* campo de dado */ /* ponteiro da proxima célula */ tipoCelula *cabeca.4 Alocação Duplamente Encadeada A alocação duplamente encadeada é aquela em que cada nó possui não só o endereço do nó anterior mas também o endereço do próximo nó.1 2. Observe o gráfico e a declaração abaixo: typedef struct celula { struct celula int char struct no } tipoCelula. *proxima. .1. *cauda. pode ser percorrida em ambos os sentidos.1. nome[15]. *anterior. indice.

Consistência.1 2. 2.3 Isolamento A propriedade de isolamento garante que a transação não será interferida por nenhuma outra transação concorrente.1 ACID Acrônimo de Atomicidade. O resultado de uma transação executada concorrentemente a outra deve ser o mesmo que o de sua execução de forma isolada.1. . é necessário que. A transação será executada totalmente ou não será executada. Isolamento e Durabilidade. da conta origem seja retirado um valor X e na conta destino seja somado o mesmo valor X.1.2. Operações exteriores a uma dada transação jamais verão esta transação em estados intermediários. 2. Exemplo: Em uma transferencia de valores entre contas bancárias.2 Consistência A propriedade de consistência garante que o banco de dados passará de uma forma consistente para outra forma consistente.1. Transação X altera o nome do mesmo cliente.2.1 Atomicidade A propriedade de atomicidade garante que as transações sejam atômicas (indivisíveis). Ex: Duas transações executadas juntas.2.2. Transação Y altera o nome do cliente. As duas operações devem ser completadas sem que qualquer erro aconteça.2 BANCO DE DADOS 2. caso contrário todas as alterações feitas nessa operação de transferência devem ser desfeitas. 2.

. update ou delete enquanto a transação estiver em andamento todos os dados da tabela serão alocados para aquela transação. Esta escolha é feita pelo banco de dados e ele executa primeiro uma transação depois a outra.2.4 Durabilidade A propriedade de durabilidade garante que o que foi salvo.1 Ao fazer insert. Duas transações só podem ser simultâneas se elas não alterarem os mesmos dados. portanto a transação X só poderá ser executada após a conclusão da transação Y.1. não será mais perdido. 2.

pois para nós se torna bem mais fácil a compreensão. . oculta e protege as informações dos objetos. Pode-se citar também como benefícios da OO: .O encapsulamento não permite que seja feito o acesso direto ao estado interno de um objeto. pois temos objetos que se comportam de formas semelhantes além de permitir redução no tempo de desenvolvimento.3 PROGRAMAÇÃO ORIENTADA A OBJETOS 2.Escalabilidade. .A Reutilização de código é considerada uma grande vantagem oferecida pela OO.2 2.Facilita o reaproveitamento de código.1 Qual a vantagem de se utilizar Orientação a Objetos? Agrupar os conceitos do mundo real e representá-los através de objetos é um dos maiores benefícios oferecidos pela OO. projeto até a implementação. O acesso aos mesmos deve ser feito através das mensagens que o objeto pode receber. . precisa apenas da documentação dos objetos para que possa utilizá-los. . Para aumentar a escalabilidade a aplicação é construída utilizando-se a composição de objetos e a troca de mensagens entre estes objetos. isto é.Herança – torna o programa menor e facilita a manutenção. que é a capacidade de uma aplicação adaptar-se facilmente às exigências de novos requisitos do sistema sem aumentar muito a sua complexidade e sem comprometer o desempenho.Utilização da mesma notação.3. O programador não necessita conhecer o código. da análise. . Utiliza-se as classes para implementar novas funcionalidades podendo-se herdar o comportamento (que está codificado) de outras classes anteriormente implementadas. . durante todo o ciclo de vida do software.

A desvantagem é que estes objetos serão tratados em grupos e não de forma individual.InsereUsuário else if Pessoa = Funcionário then Funcionário.InsereProfessor. Ex. precisaríamos de três método diferentes.InsereProfessor else if Pessoa = usuário then Usuário. Funcionário. Usuário e Funcionário são instâncias de objetos das respectivas subclases Professor. {método} Professor. If Pessoa then {método} If Pessoa = Professor then Pessoa. 2. Utilizando-se o polimorfismo.2 Como e quando utiliza-se polimorfismo? A aplicação do polimorfismo torna o código mais legível. A vantagem é podermos utilizar um agrupamento de objetos e fornecermos uma solução para um problema. Professor.2 .InsereUsuario. um para Professor e um método para Funcionário. Isto significa que objetos diferentes podem responder a uma mesma mensagem de forma diferente. {chamada do método} Usuário.InsereFuncionário Professor. pode ser uma vantagem e também uma desvantagem. mais enxuto e facilita manutenção dos sistemas pois permite que se utilize métodos com o mesmo nome para objetos diferentes. para usuário.: Ao tentarmos inserir uma nova pessoa. pode atuar de modo diferente em classes diferentes.Insere. Usuário e Funcionário.{chamada do método} . que foi implementada através da codificação um método.InsereFuncionario.Insere. que possibilita agrupar em classes os objetos com comportamento semelhante e estas classes podem ser agrupadas em hierarquias de herança . teremos três classes e apenas um método Insere: Pessoa.A apropriação.3. A mesma operação.

Este conceito não exige que se conheça a implementação do método insere para cada objeto. Algumas linguagens OO implementam o polimorfismo com ligação (binding) dinâmica ou com ligação estática. se você deseja somar dois números inteiros. 2) Redefinição de operadores: utilizada quando necessita-se de operações que normalmente não são disponíveis na linguagem de programação. soma de matrizes. chamado polimorfismo paramétrico ou sobrecarga de operadores. Funcionário. Tipos Clássicos de Polimorfismo: 1) De operadores (distinção pelo tipo do elemento): já vem implementado em todas as linguagens. esta facilidade torna a execução do sistema mais lenta. onde podemos ter métodos com o mesmo nome. mas que diferem apenas pelo número de parâmetros que utilizam. Existe outro tipo de polimorfismo. O exemplo mostra que a operação Insere pode atuar de forma diferente em objetos diferentes.Insere. mas diminui o número de linhas de forma significativa quando temos muitos objetos com comportamentos ligeiramente diferentes. implementados na mesma classe. A ligação dinâmica é feita em tempo de execução e poderá ser alterada durante a execução do programa. A ligação estática é feita em tempo de compilação ou interligação (linking) não podendo mais ser alterada no decorrer da execução do programa. A utilização do polimorfismo não facilita a reutilização de código. .2 Usuário. Por exemplo. entretanto.Insere. O tipo de polimorfismo acima é um exemplo de métodos com implementação diferente com o mesmo nome em classes diferentes. 3) Dois métodos iguais na mesma classe: distinguem-se pelo número e/ou tipo de parámetros ou objetos referenciados. Por exemplo.

veja o exemplo abaixo: Neste exemplo temo suma superclasse “Mamífero e as subclases “Cachorro”. Podemos dizer que Cachorro é um Mamifero. Isto é Herança. Homem é um Mamífero. Podemos portanto re-definir na subclasse um atributo que já estaba presentes na superclasse. Macaco é um Mamífero. que “herdam” de “Mamífero”. isto é porque o Homem tem pelos diferentes dos outros mamíferos.1 Como pode-se representar polimorfismo no diagrama de classe. Além disso. explique como você representou o polimorfismo? Para exemplificar um diagrama de classe representando um polimorfismo.4. cada classe que herda de Mamífero poderá ter seus próprios atributos que se somarão aos da superclasse. Dando uma razão lógica para nosso exemplo. “Macaco”. Note que a classe Homem contém uma definição dos atributo Pelos. “Homem”.4 ANÁLISE DE SISTEMAS 2. As características definidas na classe Mamífero estarão presentes nas chasses que herdam dela.2 2. Todos os Mamíferos terão Mamas e Pelos. dando a ele características diferentes. Isto é Polimorfismo: o mesmo método ou atributo pode ter funcionamento diferente em .

pode-se ter uma hierarquia de classes relacionadas por herança / generalização. promovendo a sua reutilização. evitandose redundância.2 clases diferentes. mesmo que uma hede da outra. . Veja outro exemplo abaixo. Em cada classe da hierarquia colocam-se as propriedades que são comuns a todas as suas subclasses. Em geral.

2 1 CONCLUSÃO O trabalho realizado buscou apresentar a matéria solicitada pelas quatro matérias do 3 semestre do curso de Análises de Sistema. .

Sign up to vote on this title
UsefulNot useful