CIBERSEGURANÇA

SHEILLIVAN LIMA DA SILVA

PROJETO INTEGRADO II:

Cibersegurança

Guajará-Mirim, Rondônia
2022
SHEILLIVAN LIMA DA SILVA

PROJETO INTEGRADO II
Cibersegurança

Projeto Integrado II de Cibersegurança é apresentado

como requisito parcial para a obtenção de média
bimestral nas disciplinas de Linguagem de
Programação, Sistemas Operacionais, Modelagem de
Dados, Lógica Computacional, Algoritmos e
Programação Estruturada, Arquitetura de Redes.

Orientador: Profª. Vanice Dalto

Guajará-Mirim, Rondônia
2022
 SUMÁRIO

1 INTRODUÇÃO...........................................................................................................3

2 POLIMORFISMO......................................................................................................4
2.1 Tipos de Polimorfismo.............................................................................................4
2.1.2 Exemplos de classe.............................................................................................5
2.1.3 Demonstração do uso do polimorfismo...............................................................6
2.1.4 Benefícios do polimorfismo..................................................................................6
2.2 Herança...................................................................................................................7
2.3 Threads..................................................................................................................8
2.3.1 Os Estados das Threads.....................................................................................8
2.3.1 Os benefícios da Programação Multithread........................................................9
2.3.2 Operações de threads.......................................................................................10
2.3.3.1 Criar (thread creation)....................................................................................11
2.3.3.2 Terminar (thread termination).........................................................................11
2.3.3.3 Thread Yield (Rendimento da thread)............................................................12
2.4 Modelo Entidade-Relacionamento.......................................................................12
2.4.1 Ferramentas CASE’s........................................................................................12
2.4.2 Modelo ER, ou simplesmente MER..................................................................13
2.4.3 Entidades..........................................................................................................14
2.4.4 Relacionamentos...............................................................................................15
2.4.5 Atributos............................................................................................................16
2.4.6 Diagrama Entidade Relacionamento.................................................................17
2.5 Programa na linguagem C...................................................................................20
2.6 Agricultura Familiar..............................................................................................20
2.6.1 Diagrama de Venn............................................................................................22
2.6 Projeto de Rede...................................................................................................23
2.6.1 Tipo de Cabeamento..........................................................................................23
2.6.1.1 Par Trançado...................................................................................................24
2.6.1.2 Coaxial.............................................................................................................24
2.6.1.2 Fibra Ótica.......................................................................................................24
2.6.2 Cabeamento escolhido para o Projeto...............................................................24
3 CONCLUSÃO..........................................................................................................26
REFERÊNCIAS...........................................................................................................27
 3

1 INTRODUÇÃO

O presente Projeto Integrado II visa avaliar os conhecimentos do

aluno acerca das matérias dadas ao longo do semestre. Para tal, algumas tarefas
foram propostas.
A primeira tarefa pede que seja dado os conceitos de herança e
polimorfismo e a segunda tarefa requer a definição de thread, os seus estados, os
benefícios da programação multithead e as suas operações.
Na quarta tarefa deve-se desenvolver um programa na linguagem C
que tenha peça o nome, endereço, telefone e que sejam exibidos na tela.
Na quinta tarefa fora dado um problema para ser resolvido pelo
aluno e que este seja resolvido por meio do raciocínio lógico.
Na sexta e última tarefa o aluno deve elaborar um projeto de rede
para uma escola que interligue duas unidades, sendo solicitado ao desenvolvedor
que exponha suas escolhas acerca do cabeamento, metragem e velocidade máxima
da opção escolhida para integrar o projeto.
 4

2 POLIMORFISMO

Na programação orientada a objetos, o polimorfismo permite que

recomendações de tipos de classes mais abstratas correspondem ao procedimento
das classes concretas que apontam. Deste modo, pode-se proceder com variados
tipos de formas homogêneas (através da interface do tipo mais abstrato). O termo
polimorfismo é oriundo do grego e significa "muitas formas" (poli = muitas, morphos
= formas).
O polimorfismo é caracterizado quando duas ou mais classes
distintas têm métodos de mesmo nome, de forma que uma função possa utilizar um
objeto de qualquer uma das classes polimórficas, sem necessidade de tratar de
forma diferenciada conforme a classe do objeto.
Uma das formas de implementar o polimorfismo é através de uma
classe abstrata, cujos métodos são declarados mas não são determinados, e
através de classes que herdam os métodos desta classe abstrata.

2.1 Tipos de Polimorfismo

Existem quatro tipos de polimorfismo que a linguagem pode ter,

porém deve-se atentar-se ao fato de que nem toda linguagem orientada a objeto tem
implementado todos os tipos de polimorfismo.

UNIVERSAL

Inclusão - um ponteiro para classe mãe pode apontar para uma instância de uma
classe filha (exemplo em Java: List lista = new LinkedList(); (tipo de
polimorfismo mais básico que existe).
Paramétrico - se restringe ao uso de templates (C++, por exemplo) e generics
(C#/Java).

AD-HOC

Sobrecarga - duas funções/métodos com o mesmo nome mas assinaturas

diferentes.
Coerção - conversão implícita de tipos sobre os parâmetros de uma função.
 5

2.1.2 Exemplos de classe

public abstract class OperacaoMatematica {
public abstract double calcular(double x, double y);
}

Esta é uma classe abstrata que representa qualquer operação

matemática. Podemos imaginar diversas operações que se encaixam na sua
interface, como soma, subtração, multiplicação ou divisão, entre outras. Note que,
mesmo que a natureza do cálculo mude, a semântica do método calcular não muda,
ou seja, ele sempre calculará o resultado da operação matemática que está sendo
trabalhada. Definamos então, duas subclasses, Soma e Subtracao, que extendem a
classe OperacaoMatematica:

public class Soma extends OperacaoMatematica {

public double calcular(double x, double y) {
return x + y;
}
}

public class Subtracao extends OperacaoMatematica {

public double calcular(double x, double y) {
return x - y;
}
}

2.1.3 Demonstração do uso do polimorfismo

public class Contas {

public static void mostrarCalculo(OperacaoMatematica operacao, double x, double
y) {
System.out.println("O resultado é: " + operacao.calcular(x, y));
}

public static void main(String args[]) {

// Primeiro calculamos uma soma
Contas.mostrarCalculo(new Soma(), 5, 5); // Imprime o resultado é: 10

// Depois uma subtração

Contas.mostrarCalculo(new Subtracao(), 5, 5); // Imprime o resultado é: 0
}
}
 6

Embora o método calcular tenha sido chamado duas vezes no

interior de mostrarCalculo, os tipos (isto é, as classes das instâncias) utilizados
como parâmetros eram diferentes. De fato, o comportamento de cada tipo era
exatamente oposto. É comum definir sobrecarga de métodos ou simplesmente
sobrecarga como uma forma de polimorfismo (chamado de polimorfismo ad-hoc).
Nesse caso, implementa-se métodos com um mesmo nome, mudando apenas a
lista de parâmetros que ele recebe. Digamos

public static void mostrarCalculo(Soma soma, double x, double y) {

System.out.println("O resultado é: " + soma.calcular(x, y));
}

public static void mostrarCalculo(Subtracao subtracao, double x, double y) {

System.out.println("O resultado é: " + subtracao.calcular(x, y));
}

Embora nesse caso o resultado possa ser o mesmo que aquele

obtido com o uso de herança, no polimorfismo ad-hoc não existem garantias que os
métodos sobrecarregados tenham o mesmo comportamento.

2.1.4 Benefícios do polimorfismo

Em linguagens de programação não-polimórficas, para implementar

o método mostrarCalculo, seria necessário recorrer a uma enumeração com o
tipo de operação e, dentro do método, testar o valor da enumeração, como no
exemplo abaixo:

public void mostrarCalculo(String operacao, double x, double y) {

System.out.print("O resultado é: ");

switch (operacao) {
case SOMA:
System.out.print(x + y);
break;
case SUBTRACAO:
System.out.print(x - y);
break;

// Outras operações...
default:
 7

throw new UnsupportedOperationException();

break;
}
}

Além do código ser maior e mais difícil de ler, essa implementação

tem outros problemas. Provavelmente esse não será o único método a utilizar
operações matemáticas e, portanto, pode-se esperar não um, mas vários switchs
como esse pelo código. Se uma nova operação for adicionada ao sistema, será
necessário que todos os switchs sejam encontrados e substituídos, por exemplo.
Com o polimorfismo, a modificação se limitaria tão-somente à criação de uma nova
classe.

2.2 Herança

O conceito de encapsular estrutura e comportamento em um tipo

não é exclusivo da orientação a objetos; particularmente, a programação por tipos
abstratos de dados segue esse mesmo conceito. O que torna a orientação a objetos
única é o conceito de herança.
Herança é um mecanismo que permite que características comuns a
diversas classes sejam fatoradas em uma classe base, ou superclasse. A partir de
uma classe base, outras classes podem ser especificadas. Cada classe derivada ou
subclasse apresenta as características (estrutura e métodos) da classe base e
acrescenta a elas o que for definido de particularidade para ela.
Sendo uma linguagem de programação orientada a objetos, Java
oferece mecanismos para definir classes derivadas a partir de classes existentes. É
fundamental que se tenha uma boa compreensão sobre como objetos de classes
derivadas são criados e manipulados, assim como das restrições de acesso que
podem se aplicar a membros de classes derivadas. Também importante para uma
completa compreensão da utilização desse mecanismo em Java é a compreensão
de como relacionam-se interfaces e herança.
Herança é usualmente utilizada em Java, mesmo que não
explicitamente. Quando uma classe é criada e não há nenhuma referência à sua
superclasse, implicitamente a classe criada é derivada diretamente da classe
Object. É por esse motivo que todos os objetos podem invocar os métodos da
 8

classe Object, tais como equals() e toString().

2.3 Threads

A forma pelo qual um processo ou tarefa de um programa de

computador é dividido em duas ou mais partes, as quais podem ser executadas
concorrentemente, denomina-se thread. Tal forma tem seu suporte fornecido pelo
sistema operacional no caso da linha de execução ao nível do núcleo, ou
implementada através de uma biblioteca de uma determinada linguagem de
programação. Uma thread permite, por exemplo, que o usuário de um programa
utilize uma funcionalidade do ambiente enquanto outras linhas de execução realizam
outros cálculos e operações.
Em computadores que possuem apenas uma única CPU, cada
thread é processada de forma aparentemente concomitante, pois a mudança entre
uma thread e outra é feita de forma tão rápida que para o utilizador, isso está
acontecendo concomitantemente. Em equipamentos multi-cores (com múltiplos
CPUs ), as threads são realizadas realmente de forma simultânea.
Os sistemas que suportam uma única thread (em real execução) são
chamados de monothread enquanto que os sistemas que suportam múltiplas
threads são chamados de multithread (multitarefa).

2.3.1 Os Estados das Threads

A execução de uma thread pode passar por quatro estados: novo,

executável, bloqueado e encerrado.
A thread está no estado de novo, quando é criada. Ou seja, quando
é alocada área de memória para ela através do operador new. Ao ser criada, a
thread passa a ser registrada dentro da JVM, para que a mesma posso ser
executada.
A thread está no estado de executável, quando for ativada. O
processo de ativação é originado pelo método start(). É importante frisar que uma
thread executável não está necessariamente sendo executada, pois quem determina
o tempo de sua execução é a JVM ou o S.O.
 9

A thread está no estado de bloqueado, quando for desativada. Para

desativar uma thread é necessário que ocorra uma das quatro operações a seguir:
1. Foi chamado o método sleep(long tempo) da thread;
2. Foi chamado o método suspend() da thread (método deprecado)
3. A thread chamou o método wait();
4. A thread chamou uma operação de I/O que bloqueia a CPU;
Para a thread sair do estado de bloqueado e voltar para o estado de
executável, uma das seguintes operações deve ocorrer, em oposição as ações
acima:
1. Retornar após o tempo especificado, caso a thread estiver adormecida;
2. Retornar através do método resume(), caso a thread tiver sido suspensa
(método deprecado);
3. Retornar com o método notify() (ou notifyAll()), caso a thread estiver em
espera;
4. Retornar após a conclusão da operação de I/O.
A thread está no estado de encerrado, quando encerrar a sua
execução. Isto pode acorrer pelo término do método run(), ou pela chamada
explícita do método stop().

2.3.2 Os benefícios da Programação Multithread

Os benefícios da programação multithread podem ser divididos em

quatro categorias principais: Capacidade de resposta, Compartilhamento de
recursos, Economia e Escalabilidade.
Capacidade de resposta - o multithreading em um aplicativo
interativo pode permitir que um programa continue em execução mesmo se uma
parte dele estiver bloqueada ou executando uma operação demorada, aumentando
assim a capacidade de resposta ao usuário.
Em um ambiente não multiencadeado, um servidor escuta a porta
para algum pedido e quando o pedido chega, ele processa o pedido e então retoma
a escuta de outro pedido. O tempo gasto no processamento da solicitação faz com
que outros usuários esperem desnecessariamente. Em vez disso, uma abordagem
melhor seria passar a solicitação para um thread de trabalho e continuar ouvindo a
porta.
 10

Por exemplo, um navegador da web multiencadeado permite a

interação do usuário em um encadeamento enquanto um vídeo está sendo
carregado em outro encadeamento. Portanto, em vez de esperar que toda a página
da web carregue, o usuário pode continuar visualizando alguma parte da página.
Compartilhamento de recursos - os processos podem compartilhar
recursos apenas por meio de técnicas como: Passagem de mensagens e Memoria
compartilhada.
Essas técnicas devem ser explicitamente organizadas pelo
programador. No entanto, os threads compartilham a memória e os recursos do
processo ao qual pertencem por padrão.
A vantagem de compartilhar código e dados é que permite que um
aplicativo tenha vários threads de atividade no mesmo espaço de endereço.
Economia - alocar memória e recursos para a criação de processos
é um trabalho caro em termos de tempo e espaço.
Visto que os encadeamentos compartilham memória com o processo
ao qual pertence, é mais econômico criar e alternar encadeamentos de contexto.
Geralmente, muito mais tempo é consumido na criação e gerenciamento de
processos do que em threads.
No Solaris, por exemplo, o processo de criação é 30 vezes mais
lento do que a criação de threads e a troca de contexto é 5 vezes mais lenta.
Escalabilidade - Os benefícios da multiprogramação aumentam
significativamente no caso de arquitetura de multiprocessador, onde os threads
podem ser executados paralelamente em vários processadores. Se houver apenas
um thread, não será possível dividir os processos em tarefas menores que diferentes
processadores podem executar.
O processo de thread único pode ser executado apenas em um
processador, independentemente de quantos processadores estão disponíveis.
Multi-threading em uma máquina de CPU múltipla aumenta o
paralelismo.

2.3.3 Operações de threads

Há quatro operações básicas na gestão de threads: criar, terminar,

thread join e thread yield.
 11

2.3.3.1 Criar (thread creation)

Basicamente uma thread pode criar outra(s), sendo que depois

essas mesmas threads são executas 'simultaneamente'. A thread criadora é a
thread-mãe e a thread criada é a thread-filho. Threads incluídas na função main
quando executadas podem criar threads-filho. No diagrama a seguir há a thread A
que executa inicialmente. Mais tarde é criada a thread B indicada no ponto amarelo.
Depois de criadas, a thread A e thread B executam simultaneamente. Em seguida a
thread A pode criar uma ou mais threads (por exemplo uma thread C). Depois de
criada a thread C, há três threads executando simultaneamente e todas disputam o
uso da CPU. Entretanto, a thread que pode ser executada a qualquer momento não
é de conhecimento da CPU.

2.3.3.2 Terminar (thread termination)

Para maioria dos casos, as threads não são criadas e executadas

eternamente. Depois de terminado o seu objectivo, a thread termina. No facto, a
thread que criou estas duas threads-filho termina também, porque sua tarefa
atribuída se completa. Na matrix de multiplicação (matrix multiplication), uma vez
que o valor de C[i,j] é computado, a thread correspondente termina. Em geral
quando a tarefa atribuída a thread completa, a thread pode ser terminada. Além
disso, se a thread-mãe terminar, todas as threads filho terminam também. Porque
isso é importante? Isso é importante porque as threads-filho compartilham recursos
com a thread-mãe, incluindo variáveis. Quando a thread-mãe termina, todas as
variáveis são perdidas e a thread-filho não poderá aceder aos recursos que a
thread-mãe possuía. Assim, se a thread-mãe terminar mais cedo que a thread-filho
haverá um problema! Uma thread pode terminar das seguintes maneiras:
 Retornando da sua rotina mais externa, a thread criadora.
 Quando termina a rotina em que foi começada.
 Chamando pthread_exit, fornecendo um estado de saída.
 Terminando através da função pthread_cancel

Imagine a seguinte situação: Você está estudando para uma prova.

 12

Então você pede o seu irmão mais novo para comprar uma pizza. Neste caso você é
a thread principal e seu irmão a thread-filho. Uma vez que você deu a ordem, você e
seu irmão começam a “executar uma tarefa” simultaneamente. Agora há dois casos
a se considerar: Primeiro: Seu irmão traz a pizza e termina enquanto você estuda.
Nesse caso você pode parar de estudar e comer a pizza. Segundo: Você acaba de
estudar mais cedo e dorme e depois a pizza chegará.
A junção de threads (thread join) é destinada para resolver este
problema. A thread pode executar o thread join e aguardar até a outra thread
terminar. No caso acima, você é a thread principal (thread main) e deve executar o
thread joinaguardando o seu irmão (thread-filho) terminar. Em geral o thread join é
utilizado para a thread-mãe se sincronizar com uma das threads-filho.

2.3.3.3 Thread Yield (Rendimento da thread)

Suponha que você executa um certo número de programas o tempo

todo no computador. Isso é possível devido a CPU escalonar pouco a pouco outros
ciclos da CPU, assim outros programas podem ser executados. Isso pode ser um
problema de política de planeamento do Sistema Operativo. Entretanto, quando
escrevemos programas com múltiplas threads, temos que fazer correctamente para
que algumas threads não ocupem a CPU eternamente, ou por um tempo muito
longo sem abandoná-lo. Senão terminar na situação acima quando uma ou duas
threads executam enquanto outras simplesmente esperam para retornar. Liberamos
espaço na memória graças a thread yield. Quando a thread executa o thread yield, a
execução da thread é suspensa e a CPU passa para uma outra thread em
execução. Essa thread aguardará até a CPU tornar-se disponível novamente.

2.4 Modelo Entidade-Relacionamento

2.4.1 Ferramentas CASE’s
Do inglês Computer-Aided Software Engineering, as chamadas
ferramentas CASE são aquelas baseadas em computadores (softwares) utilizadas
na Engenharia de Software para auxílio nas atividades desde análise de requisitos
até, modelagem de dados.
As ferramentas CASE permitem a criação de diagramas de forma
simples em um ambiente de fácil utilização e com recursos para incluir as principais
 13

regras de composição dos diagramas. Exemplos comuns desse tipo de ferramenta

são: Star UML, Astah e ERwin Data Modeler. Na Figura 6 vemos um exemplo de
diagrama sendo construído no Astah.

Figura 1: Diagrama no Astah Community

2.4.2 Modelo ER, ou simplesmente MER

O Modelo Entidade Relacionamento (também chamado Modelo ER,

ou simplesmente MER), como o nome sugere, é um modelo conceitual utilizado na
Engenharia de Software para descrever os objetos (entidades) envolvidos em um
domínio de negócios, com suas características (atributos) e como elas se relacionam
entre si (relacionamentos).
Em geral, este modelo representa de forma abstrata a estrutura que
possuirá o banco de dados da aplicação. Obviamente, o banco de dados poderá
conter várias outras entidades, tais como chaves e tabelas intermediárias, que
podem só fazer sentido no contexto de bases de dados relacionais.
Nem sempre cria-se modelos para um sistema completo, pois isso
 14

poderia resultar em um modelo muito extenso e difícil de interpretar. Dependendo da

magnitude do que estaremos desenvolvendo, podemos criar modelos apenas para
uma parte do sistema, um módulo, ou mesmo uma funcionalidade. Imagine, por
exemplo, um sistema ERP de grande porte que contemple vendas, finanças,
recursos humanos, etc. Várias entidades estão presentes em mais de uma parte do
sistema, mas não seria muito interessante, e provavelmente nem mesmo
necessário, criar um único modelo para todo o sistema, por isso pode-se dividir a
modelagem em várias partes menores.

2.4.2 Entidades

Os objetos ou partes envolvidas um domínio, também chamados de

entidades, podem ser classificados como físicos ou lógicos, de acordo sua
existência no mundo real. Entidades físicas: são aquelas realmente tangíveis,
existentes e visíveis no mundo real, como um cliente (uma pessoa, uma empresa)
ou um produto (um carro, um computador, uma roupa). Já as entidades lógicas são
aquelas que existem geralmente em decorrência da interação entre ou com
entidades físicas, que fazem sentido dentro de um certo domínio de negócios, mas
que no mundo externo/real não são objetos físicos (que ocupam lugar no espaço).
São exemplos disso uma venda ou uma classificação de um objeto (modelo,
espécie, função de um usuário do sistema).
As entidades são nomeadas com substantivos concretos ou
abstratos que representem de forma clara sua função dentro do domínio. Exemplos
práticos de entidades comuns em vários sistemas são Cliente, Produto, Venda,
Turma, Função, entre outros.
Pode-se classificar as entidades segundo o motivo de sua
existência:
 Entidades fortes: são aquelas cuja existência independe de outras
entidades, ou seja, por si só elas já possuem total sentido de existir. Em um
sistema de vendas, a entidade produto, por exemplo, independe de quaisquer
outras para existir.
 Entidades fracas: ao contrário das entidades fortes, as fracas são aquelas
que dependem de outras entidades para existirem, pois individualmente elas
não fazem sentido. Mantendo o mesmo exemplo, a entidade venda depende
 15

da entidade produto, pois uma venda sem itens não tem sentido.
 Entidades associativas: esse tipo de entidade surge quando há a
necessidade de associar uma entidade a um relacionamento existente. Na
modelagem Entidade-Relacionamento não é possível que um relacionamento
seja associado a uma entidade, então tornamos esse relacionamento uma
entidade associativa, que a partir daí poderá se relacionar com outras
entidades. Para melhor compreender esse conceito, tomemos como exemplo
uma aplicação de vendas em que existem as entidades Produto e Venda, que
se relacionam na forma muitos-para-muitos, uma vez que em uma venda
pode haver vários produtos e um produto pode ser vendido várias vezes (no
caso, unidades diferentes do mesmo produto). Em determinado momento, a
empresa passou a entregar brindes para os clientes que comprassem um
determinado produto. A entidade Brinde, então, está relacionada não apenas
com a Venda, nem com o Produto, mas sim com o item da venda, ou seja,
com o relacionamento entre as duas entidades citadas anteriormente. Como
não podemos associar a entidade Brinde com um relacionamento, criamos
então a entidade associativa "Item da Venda", que contém os atributos
identificadores das entidades Venda e Produto, além de informações como
quantidade e número de série, para casos específicos. A partir daí, podemos
relacionar o Brinde com o Item da Venda, indicando que aquele prêmio foi
dado ao cliente por comprar aquele produto especificamente.

2.4.2 Relacionamentos

Uma vez que as entidades são identificadas, deve-se então definir

como se dá o relacionamento entre elas. De acordo com a quantidade de objetos
envolvidos em cada lado do relacionamento, podemos classificá-los de três formas:
 Relacionamento 1..1 (um para um): cada uma das duas entidades
envolvidas referenciam obrigatoriamente apenas uma unidade da outra. Por
exemplo, em um banco de dados de currículos, cada usuário cadastrado
pode possuir apenas um currículo na base, ao mesmo tempo em que cada
currículo só pertence a um único usuário cadastrado.
 Relacionamento 1..n ou 1..* (um para muitos): uma das entidades
envolvidas pode referenciar várias unidades da outra, porém, do outro lado
 16

cada uma das várias unidades referenciadas só pode estar ligada uma
unidade da outra entidade. Por exemplo, em um sistema de plano de saúde,
um usuário pode ter vários dependentes, mas cada dependente só pode estar
ligado a um usuário principal. Note que temos apenas duas entidades
envolvidas: usuário e dependente. O que muda é a quantidade de
unidades/exemplares envolvidas de cada lado.
 Relacionamento n..n ou *..* (muitos para muitos): neste tipo de
relacionamento cada entidade, de ambos os lados, podem referenciar
múltiplas unidades da outra. Por exemplo, em um sistema de biblioteca, um
título pode ser escrito por vários autores, ao mesmo tempo em que um autor
pode escrever vários títulos. Assim, um objeto do tipo autor pode referenciar
múltiplos objetos do tipo título, e vice versa.
Os relacionamentos em geral são nomeados com verbos ou
expressões que representam a forma como as entidades interagem, ou a ação que
uma exerce sobre a outra. Essa nomenclatura pode variar de acordo com a direção
em que se lê o relacionamento. Por exemplo: um autor escreve vários livros,
enquanto um livro é escrito por vários autores.

2.4.2 Atributos

Atributos são as características que descrevem cada entidade dentro

do domínio. Por exemplo, um cliente possui nome, endereço e telefone. Durante a
análise de requisitos, são identificados os atributos relevantes de cada entidade
naquele contexto, de forma a manter o modelo o mais simples possível e
consequentemente armazenar apenas as informações que serão úteis futuramente.
Uma pessoa possui atributos pessoais como cor dos olhos, altura e peso, mas para
um sistema que funcionará em um supermercado, por exemplo, estas informações
dificilmente serão relevantes.
Os atributos podem ser classificados quanto à sua função da
seguinte forma:
 Descritivos: representam característica intrínsecas de uma entidade, tais
como nome ou cor.
 Nominativos: além de serem também descritivos, estes têm a função de
definir e identificar um objeto. Nome, código, número são exemplos de
 17

atributos nominativos.
 Referenciais: representam a ligação de uma entidade com outra em um
relacionamento. Por exemplo, uma venda possui o CPF do cliente, que a
relaciona com a entidade cliente.
Quanto à sua estrutura, podemos ainda classificá-los como:
 Simples: um único atributo define uma característica da entidade. Exemplos:
nome, peso.
 Compostos: para definir uma informação da entidade, são usados vários
atributos. Por exemplo, o endereço pode ser composto por rua, número,
bairro, etc.
Alguns atributos representam valores únicos que identificam a
entidade dentro do domínio e não podem se repetir. Em um cadastro de clientes, por
exemplo, esse atributo poderia ser o CPF. A estes chamamos de Chave Primária.
Já os atributos referenciais são chamados de Chave Estrangeira e
geralmente estão ligados à chave primária da outra entidade. Estes termos são
bastante comuns no contexto de bancos de dados. Mantendo o exemplo anterior, a
entidade cliente tem como chave primária seu CPF, assim, a venda possui também
um campo “CPF do cliente” que se relaciona com o campo CPF da entidade cliente.

2.4.2 Diagrama Entidade Relacionamento

Enquanto o MER é um modelo conceitual, o Diagrama Entidade

Relacionamento (Diagrama ER ou ainda DER) é a sua representação gráfica e
principal ferramenta. Em situações práticas, o diagrama é tido muitas vezes como
sinônimo de modelo, uma vez que sem uma forma de visualizar as informações, o
modelo pode ficar abstrato demais para auxiliar no desenvolvimento do sistema.
Dessa forma, quando se está modelando um domínio, o mais comum é já criar sua
representação gráfica, seguindo algumas regras.
O diagrama facilita ainda a comunicação entre os integrantes da
equipe, pois oferece uma linguagem comum utilizada tanto pelo analista,
responsável por levantar os requisitos, e os desenvolvedores, responsáveis por
implementar aquilo que foi modelado.
Em sua notação original, proposta por Peter Chen (idealizador do
modelo e do diagrama), as entidades deveriam ser representadas por retângulos,
 18

seus atributos por elipses e os relacionamentos por losangos, ligados às entidades

por linhas, contendo também sua cardinalidade (1..1, 1..n ou n..n). Porém, notações
mais modernas abandonaram o uso de elipses para atributos e passaram a utilizar o
formato mais utilizado na UML, em que os atributos já aparecem listados na própria
entidade. Essa forma torna o diagrama mais limpo e fácil de ser lido.

Figura 2: Diagrama Entidade Relacionamento de sistema de imobiliária

No domínio representado pelo diagrama acima temos as seguintes

entidades e relacionamentos:
 Proprietário contata Corretor (um proprietário pode contatar vários corretores
e um corretor pode ser contatado por vários proprietários).
 Corretor atende Inquilino (um corretor pode atender vários inquilinos e um
inquilino pode ser atendido por vários corretores).
 Inquilino aluga Imóvel (um inquilino aluga um imóvel e um imóvel pode ser
alugado por vários inquilinos).
 Proprietário possui Imóvel (um proprietário possui vários imóveis e um imóvel
pertence a apenas um proprietário).
Uma variante da Figura 2 pode ser vista na Figura 3, onde a
cardinalidade do relacionamento é exibida junto do losango.
 19

Figura 3: Diagrama de Entidade Relacionamento (variação)

Uma outra variação já mostra a cardinalidade de uma forma mais

completa, deixando claro as possibilidades de números de objetos envolvidos em
cada relacionamento. Nesse modelo, em cada lado do relacionamento os números
aparecem no formato (X,Y) ao invés de um único número como vemos nas figuras
anteriores. A Figura 4 ilustra um exemplo desse tipo.

Figura 4: Diagrama Entidade Relacionamento (variação 2)

Neste diagrama, lê-se os relacionamentos da seguinte forma:

 1 ou 1 grupo possui 0 ou muitos produtos. Como de um lado temos “1 ou 1”,
isso equivale a apenas “1”, pois não temos várias possibilidades. Já do lado
do produto, indicamos que um grupo pode possuir nenhum produto, mas
também pode possuir vários.
 0 ou várias vendas contém 1 ou muitos produtos. Ou seja, um produto pode
nunca ser vendido (0 vendas) como também pode ser vendido várias vezes (n
 20

vendas). Já uma venda deve conter 1 ou vários produtos, pois uma venda
não pode estar vazia (0 produtos).
Os atributos, como já foi dito, podem aparecer no diagrama na forma
de elipses ligadas às entidades. Essa foi a notação original proposta, mas como
podemos ver na Figura 5, ela deixa o diagrama com muitos itens e pode atrapalhar
um pouco a organização destes.

Figura 5: Atributos apresentados como elipses

Em uma notação mais atual, comumente utilizada na UML, os

atributos aparecem listados dentro do próprio retângulo da entidade, enquanto o
nome da entidade aparece no topo na forma de título. Na Figura 6 têm-se um
exemplo.

Figura 6: Diagrama com atributos nas entidades

2.5 Programa na linguagem C

Em Algoritmos e Programação Estruturada, 0000tem-se buscado a
facilidade de compreensão de programas através do número restrito de mecanismos
de controle da execução de programas. Para tal, desenvolve-se um programa na
 21

linguagem C, utilizando qualquer compilador, em que peça como entrada, nome,

endereço e telefone, por fim, exiba esses dados na tela.

Figura 7: Programa na Linguagem C

2.6 Agricultura Familiar

Nesse ano de eleições, os candidatos a presidente estão

apresentando seus programas de governo.
Um desses programas é sobre a agricultura familiar. É bem
interessante, vamos analisar a sua experiência.
Ele fez uma experiência com 13.500 agricultores e verificou-se que:
 22

 7.000 plantam arroz;

 4.100 plantam banana;
 3.100 plantam uva;
 2.100 plantam arroz e banana;
 1.400 plantam arroz e uva;
 plantam banana e uva;
 400 plantam arroz, banana e uva.
Tendo essas informações, usa-se a lógica para a obtenção da
resposta destas questões:
A) Quantos plantam pelo menos uma das três espécies?
B) Quantos não plantam nenhuma das três espécies?
C) Quantos plantam arroz ou banana, mas não plantam uvas?
D) Quantas plantam apenas uvas?

2.6.1 Diagrama de Venn

Essa questão pode ser resolvida por meio do diagrama de Venn,

que representa a intersecção entre os conjuntos.
Como 400 agricultores plantam arroz, banana e uva, esse número
ficará na intersecção dos três conjuntos.
A seguir, a quantidade que ficará nas intersecções de dois conjuntos
apenas:
 2.100 plantam arroz e banana. Logo, 2100 - 400 = 1700 plantam somente
arroz e banana.
 1.400 plantam arroz e uva. Logo, 1400 - 400 = 1000 plantam somente arroz e
uva.
 1.000 plantam banana e uva. Logo, 1000 - 400 = 600 plantam somente
banana e uva.
A seguir, a quantidade que ficará somente em cada um dos
conjuntos:
 7.000 plantam arroz. Logo, 7000 - (1700 + 400 + 1000) = 7000 - 3100 = 3900
plantam apenas arroz.
 4.100 plantam banana. Logo, 4100 - (1700 + 400 + 600) = 4100 - 2700 = 1400
plantam apenas banana.
 23

 3.100 plantam uva. Logo, 3100 - (1000 + 400 + 600) = 3100 - 2000 = 1100
plantam apenas uva.
O número de pessoas que plantam pelo menos uma das três é:

3900 + 1400 + 1100 = 6400

Como o total é de 13500 agricultores, temos:
3900 + 1400 + 1100 + 1700 + 1000 + 600 + 400 + x = 13500
10100 + x = 13500
x = 13500 - 10100
x = 3400

Então, 3400 não plantam nenhuma das três espécies. O número de

pessoas que plantam arroz ou banana, mas não plantam uvas, é: 10100 - 1100 =
9000.

2.7 Projeto de Rede

A rede de ensino Bom Aluno está inaugurando uma nova unidade na

capital Curitiba, próxima a unidade da matriz, a localização é de aproximadamente
700m uma da outra. Com o objetivo de interligar ambas as unidades, por meio de
cabeamento, sem perdas de sinal e perda de performance na comunicação de
ambas as redes, um projeto de rede está sendo elaborado para interligar ambas
unidades.
Neste projeto de rede especifica-se o tipo de cabeamento usado.
Ademais serão informados os dados, tais como: metragem máxima, velocidade
máxima e tecnologia de transmissão.

2.7.1 Tipo de Cabeamento

Atualmente a instalação de uma rede própria é fundamental

conforme uma empresa cresce e novas necessidades vão aparecendo. Mas apesar
do aumento de popularidade das redes wi-fi, o cabeamento de rede ainda é
amplamente usado no mercado. Assim, saber reconhecer os diferentes tipos de
cabeamento estruturado pode ajudar você a tomar a melhor decisão para sua
empresa.
Provavelmente tem-se visto algum dos cabos usados para a
 24

instalação de uma rede de computadores. Sem dúvida um dos mais conhecidos é o

“cabo Ethernet”, aquele geralmente azul que muitas vezes é conectado ao seu
roteador. Ou seja, mesmo que você não saiba os detalhes, você convive direta ou
indiretamente com estes cabos diariamente.

2.7.1.1 Par Trançado

Em primeiro lugar temos o cabo de par trançado (ou UTP) é um dos

tipos de cabeamento mais populares atualmente. Ele funciona com pares de fio
entrelaçados, desse modo cancelando ou diminuindo as interferências
eletromagnéticas que podem interferir nas transmissões. Além disso, suas principais
vantagens sobre os outros tipos incluem a sua alta taxa de transferência,
flexibilidade e resistência.

2.7.1.2 Coaxial

Em segundo lugar temos o cabo coaxial, feito a partir de um único fio

metálico condutor de dados. E apesar de ser menos flexível que o de par trançado
devido à estrutura metálica, ele é resistente e sofre poucas interferências também.
Entretanto sua instalação mais complexa o torna menos popular que suas
alternativas, sendo usado principalmente para sinais televisivos atualmente.

2.7.1.2 Fibra Ótica

Finalmente em terceiro lugar está o cabo de fibra ótica, feito com um

núcleo de fibra de vidro ou silício. Eles usam um feixe de luz com o propósito de
enviar e receber dados, que vai sendo refletido pela fibra. Desse modo, eles são
imunes às interferências eletromagnéticas e são até mesmo bastante flexíveis, nem
mesmo precisando estar em linha reta para funcionar. Mas eles são bem mais caros
que os outros fios, bem como mais difíceis e custosos de se instalar.

2.7.2 Cabeamento escolhido para o Projeto

Para interligar a matriz e a filial, o cabeamento escolhido foi a fibra

 25

ótica. A fibra ótica é um tipo de sinal de internet que podem alcançar grande
números quando o assunto é capacidade de distanciamento, mas com um sinal de
qualidade, e isso é possível observar a partir de diversos tipos de perspectivas.
Geralmente, um sinal de internet comum acaba não oferecendo um
grande alcance de seu sinal, logo sofrendo quedas e interferência e levando a uma
qualidade do sinal de internet muito baixa. Esse tipo de situação acaba não
acontecendo quando realizamos um tipo de conexão via fibra ótica, que pode acabar
apresentando cerca de 120 quilômetros de extensão, sem que seu sinal seja
devidamente afetado.
A maior parte dos cabos de fibra óptica utilizados atualmente tem
capacidades de transmissão entre 10 e 40 Gbits/s. No entanto, existem diversas
aplicações em que são necessárias maiores taxas de transferências, por isso,
algumas companhias de telecomunicação já desenvolveram cabos com mais de
7000 km de comprimento, capazes de transmitir até 15,5 Tbits/s (Terabits/s – 1015
bits/s). Estima-se que cabos de fibra óptica desse tipo sejam capazes de sustentar
até 3.000.000 de chamadas telefônicas simultâneas ou até 90.000 canais de
televisão. Por este motivo deu-se a escolha da fibra ótica, pois ela é a mais
adequada às necessidades do projeto.
 26

3 CONCLUSÃO

Tendo em vista o exposto, considera-se que os conceitos de

herança e polimorfismo foram satisfatoriamente expostos, assim como a definição
de thread. Bem como os benefícios da programação multithread e a operação de
thread.
A ferramenta case abordada neste projeto foi a Astah, sendo ela
usada para criação de um MER para um projeto de banco de dados relacional.
Outro item abordado no projeto fora o desenvolvimento de um
programa na linguagem C que pedia as entradas e as imprimiam na tela, podendo
ser este rodar em qualquer compilador.
Na lógica computacional, um problema fora dado para ser resolvido,
sendo este resolvido com o uso do diagrama de Venn.
Já a sexta tarefa disposta, trata-se um projeto de rede para uma
escola que tem a intenção de interligar a matriz e sua filial. Fora pedido que um tipo
de cabeamento mais adequado a ser utilizado neste projeto de rede. Pontos como a
metragem e velocidade máximas do cabeamento escolhido para o projeto.
 27

REFERÊNCIAS

CELES, W.; CERQUEIRA, R.; RANGEL, J. L. Introdução à estrutura de dados: com

técnicas de programação em C. 6. reimp. Rio de Janeiro: Elsevier, 2004.

DROZDEK, A. Estrutura de dados e algoritmos em C++. Trad. 4. ed. norte-

americana. São Paulo: Cengage Learning, 2016.

SILVA, O. Q. Estrutura de dados e algoritmos usando C: fundamentos e aplicações.

Rio de Janeiro: Ciência Moderna, 2007.

ABREU, M. P.; MACHADO, F. N. R. Projeto de banco de dados: uma visão prática.

16. ed. rev. e atual. São Paulo: Érica, 2009.

CORONEL, C.; ROB, P. Sistema de banco de dados: projeto, implementação e

administração. São Paulo: Cengage Learning, 2011.

DATE, C. J. Introdução a sistemas de bancos de dados. Rio de Janeiro, RJ:

Elsevier, 2003.

NAVATHE, S. B.; RAMEZ, E. Sistemas de banco de dados. 4. ed. São Paulo:

Addison Wesley, 2005.

ALVES, W. P. Banco de Dados. São Paulo: Saraiva, 2014.

TANENBAUM, A. S. Sistemas operacionais modernos. 2. ed. São Paulo: Pearson,

2003.

MACHADO, F. B.; MAIA, L. P. Arquitetura de sistemas operacionais. 4. ed. Rio de

Janeiro: LTC, 2007.