CENTRO FEDERAL DE EDUCAÇÃO

TECNOLÓGICA DE MINAS GERAIS

Graduação em Engenharia Civil

JOÃO PAULO ALVES MARINHO

ORIENTAÇÃO A OBJETOS EM JAVA

Segunda atividade individual

CURVELO
2022
 JOÃO PAULO ALVES MARINHO

ORIENTAÇÃO A OBJETOS EM JAVA

Segunda atividade individual

Trabalho elaborado para a disciplina de

Programação de Computadores II, ministrado
pela docente Karla de Souza no CEFET-MG
unidade de Curvelo

CURVELO
2022
 Sumário
1 INTRODUÇÃO .................................................................................................... 4
2 DESENVOLVIMENTO ....................................................................................... 5
2.1 ESTRUTURA ......................................................................................................... 5
2.1.1 Estoque (case 1:) ................................................................................................... 7
2.1.2 Caixa (case 2:) ....................................................................................................... 8
2.1.3 Lucro (case 3:) ....................................................................................................... 9
2.1.4 Saída (case 0:) ....................................................................................................... 9
2.2 PACOTE ............................................................................................................... 10
2.3 UML ...................................................................................................................... 10
3 CONCLUSÃO ...................................................................................................... 12
4 REFERÊNCIAS ................................................................................................... 12
1 INTRODUÇÃO

Foi construído um programa com a intenção de resolver o problema do

vendedor de uma loja. Esse vendendo não tinha nenhum software para fazer o cadastro
de seus produtos no estoque, por isso, muitas vezes se esquecia de repor. Além disso, o
vendendo também tinha dificuldades em fazer o controle diário de suas vendas,
relacionado a saída de produtos de sua loja. Levando tudo isso em consideração, ele
também gostaria de que seus dados estivessem seguros, onde os empregados não tivessem
a possibilidade de modificá-los facilmente, restringindo o acesso deles somente ao setor
onde trabalham, como caixa ou reposição de produtos nas prateleiras.

Pensando nessas dificuldades, foi desenvolvido um programa orientado a

objetos que fizesse o cadastro dos produtos em estoque, mostrasse os dados organizados
em forma de tabela, e que esses mesmos dados estivessem encapsulados. O cerne do
processamento desse programa, é fazer o cálculo diário de lucro, baseado nas informações
que vão ser inseridas pelo usuário, de forma controlada.

A motivação em desenvolver um programa com essa finalidade, é aplicar a

orientação a objetos de forma mais intuitiva, e também que seja fácil relacionar os objetos
da vida real.
2 DESENVOLVIMENTO

2.1 ESTRUTURA

Esse programa foi estruturado a partir da linguagem Java aplicado a

orientação a objetos, que segundo K19 (2015) “a linguagem de programação Java permite
que os conceitos de orientação a objetos sejam utilizados no desenvolvimento de uma
aplicação”.

Tem como objetivo o cadastramento de produtos em estoque de uma loja, e

para cada produto que o usuário der baixa, calcular o lucro e mostra uma mensagem
quando requisitado, do ganho até o momento. Temos duas classes para esse programa,
sendo que a primeira é a classe principal chamada “SistemaDeVendaV2”, e a segunda
“Produto”. O desenvolvimento foi feito na classe principal dentro do método principal
“main”, responsável pela chamada dos métodos e instanciação de objetos. Na classe
“Produto”, a função consiste em definir um tipo abstrato de dado (TAD) para um
determinado produto. Como mostrado na Figura 1, cada produto terá seu tipo, marca,
peso, quantidade, custo, e porcentagem de lucro sob cada produto, que corresponde aos
atributos do objeto que vão ser declarados como dados privados, ou seja, estará restrito
para ser acessado somente da classe Produto. Isso para cumprir com os quesitos de
encapsulamento de dados, com finalidade que através desses dados de entrada, seja obtido
seus valores de fome mais segura, mostrando uma tabela organizada com essas
informações de forma controlada. É importante ressaltar que foi usado um construtor com
seis argumentos, para inicializar as variáveis de atributo para cada vetor objeto criado.

Figura 1 – Atributos e construtor

Fonte: autoria própria

 Iniciando o método principal, por ordem de linha de comando, começa com
as declarações de variáveis, e logo em seguida, o método “cabecalho” é chamado como
uma interface de identificação do programa, mas também como um limpar tela, para
“afastar” o excesso de informações anteriores no Prompt de Comando. O cadastro dos
produtos é feito antes de entrar na estrutura de repetição “do-while”, depois de cadastrado
os produtos em estoque, ele se manterá fixo, com a quantidade de objetos (produtos)
determinados pelo usuário. “Esses objetos devem ser alocados na memória RAM do
computador. Felizmente, todo o processo de alocação do objeto na memória é gerenciado
pela máquina virtual. O gerenciamento da memória é um dos recursos mais importantes
oferecidos pela máquina virtual. ” (K19, 2015).

O construtor é chamado com novo parâmetro da classe Produto, para cada

repetição do “for” que indica a quantidade de objetos. Em seguida o “do-while” irá repetir
indefinidamente até que seja satisfeito, tendo um valor igual a zero, isso para que não seja
necessário entrar com os produtos em estoque todos os dias, o que significa que terá uma
condição “if” que vai demarcar o início de um novo dia, onde o usuário terá que colocar
uma nova data, e o lucro vai ser contado a partir da inicialização de venda nesse dia.

Para cada opção que não corresponder ao que foi mostrado no menu, irá exibir
uma mensagem de erro conforme a Figura 2, que esse valor atribuindo não corresponde
as opões, evitando assim que o programa tenha um comportamento inesperado.
Figura 2 – Menu e mensagem de erro

Fonte: autoria própria

 Existem quatro casos no “switch-case” para o programa, onde cada caso
poderá ser expresso através de uma das opões do menu, que é chamado como um método
dentro de “main”. O primeiro é para mostras os produtos em estoque, o segundo para
registrar a compra de um cliente, o terceiro para encerrar o dia (fechar a loja), dar o
resultado do lucro, e o quarto para sair do programa.

2.1.1 Estoque (case 1:)

Figura 3 – Estoque

Fonte: autoria própria

O primeiro “case” do “switch” é identificado com comentário “ESTOQUE”,
responsável por conter a saída dos produtos cadastrados pelo usuário, mostrando a
composição do seu estoque organizado em forma de tabela. Como visto na Figura 3, é
apresentado a última data com a sequência de atributos, e o “Código” que corresponde a
posição no vetor para cada produto por ordem de cadastro. Foi necessário o uso de um
“for”, que faz uma contagem passando por todos os atributos armazenados nos vetores
dos objetos criados, mostrando em forma de tabela uma sequência condizente para o
respectivo produto. Com isso foi necessário criar um método “get” para todos os atributos
na classe “Produto”, onde terá o valor do atributo retornado para dentro do método, com
a finalidade de mostras esses dados, pois eles não podem ser diretamente acessados.
 2.1.2 Caixa (case 2:)
Figura 4 – Caixa

Fonte: autoria própria

Figura 5 – Continuação da figura Caixa

Fonte: autoria própria

O segundo “case” do “switch” é identificado como “CAIXA”, responsável
por fazer a aquisição de compra do cliente, mostrando para ele quanto deve pagar, e
registra o somatório sobre a porcentagem lucro de cada produto. Na Figura 4 é
apresentado a última data com o pedido de quantidades de tipos de produto, necessário
para o funcionamento do “for”, que fará a repetição de acordo com essa quantidade, e
para cada repetição, a necessidade de entrada do código de identificação do produto
(número do cadastro), e quantidade desse mesmo produto que o cliente está levando. Com
essas informações já é possível, a traves do método “CalcVenda” (que é a capacidade de
que um produto/objeto pode ser vendido), de calcular a quantidade de lucro, e através de
uma manipulação de vetores referente aos métodos “get”, usando o código e quantidade
dele sendo vendido, mostrar o peço a ser pago pelo cliente mostrado na Figura 5. Foi
necessário o uso de um “set” para a ajustar a quantidade de produtos, onde terá que ser
subtraído do estoque para cada venda.

Nesse “for” ainda é possível a verificação de erros, como o uso de códigos

inexistentes, e o número de baixas de produtos que excedam a quantidade que tem no
estoque, isso para que o programa possa funcionar corretamente.

2.1.3 Lucro (case 3:)

Figura 6 – Lucro

Fonte: autoria própria

O terceiro “case” do “switch” é identificado como “LUCRO”, é o rendimento
total da loja no dia. Como mostrado na Figura 6 é apresentado a última data com o lucro
total que foi obtido em encima da porcentagem, respectivo ao preço de cada produto. O
usuário pode decidir por não fechar a loja ainda, podendo então ver o lucro até o momento,
sem necessariamente iniciar um novo dia, onde o lucro é zerado.

O ponto onde a loja estaria fechando, seria quando a data do dia e o lucro são
resetados caso o “if” receba “true”, que significa verdadeiro, mas nesse sentido, foi
adotado como sendo uma confirmação (sim), que também teve o mesmo raciocínio
aplicado para “false”, porem invertido. (Obs: o cálculo do lucro é feito no case2).
 2.1.4 Saída (case 0:)
Figura 7 – Requisição de saída do programa

Fonte: autoria própria

O “case” zero é o quarto dentro do “switch”, e ele é responsável por trazer
uma mensagem de confirmação de saída do programa, com advertência de que a saída
implica a exclusão de todos os dados do programa.

Conforme a Figura 7, caso o usuário mude de ideia, ele pode optar por
continuar usando o programa escrevendo “false”. Na condição “if” será feita uma
comparação, e se o oposto do que ele escolheu for verdadeiro, então o valor que iria
satisfazer o “do-while” será modificado, não o satisfazendo, repetindo então o programa.
Do contrário, mostra uma mensagem de despedida.

2.2 PACOTES
Outra questão muito importante a ser ressaltado, é o fato de ter sido utilizado
pacotes nesse programa.

À medida que os aplicativos tornam-se mais complexos, os pacotes

ajudam os programadores a gerenciar a complexidade dos componentes
de aplicativo. Os pacotes também facilitam a reutilização de software
permitindo que programas importam classes de outros pacotes, antes de
copiar as classes em cada programa que os utiliza (DEITEL, 2010,
p.264)

Na classe principal foi importado o pacote “vendinha”. Nele é utilizado um

asterisco no fim da declaração, que significa que está informando para o compilador de
que todas as classes que estão em “public” no pacote “vendinha”, e estão disponíveis para
serem usadas no programa. Também foi preciso definir que no arquivo "Produto.java" se
encontra em uma pasta, para que o compilador consiga localizá-lo para classe principal
“SistemaDeVendasV2”.

2.3 UML

“A UML é agora o esquema de representação gráfica mais amplamente

utilizado para modelar sistemas orientados a objetos. Ela de fato unificou os vários
esquemas de notação populares. ” (DEITEL, 2010)
“Em algumas empresas, o UML é amplamente utilizado. Às vezes, o
programador recebe o UML já pronto, completo, e só deve preencher a implementação,
devendo seguir à risca o UML. ” (CAELUM, 2022).

K19, (2015) expõe que podemos representar uma classe pelo meio de um
diagrama UML. Esse diagrama UML de uma classe é composta pelo nome da mesma, e
também pelos atributos e métodos que ela define. Todos os objetos que serão criados a
partir de uma classe, terão os atributos e métodos mostrados no diagrama UML. Os
valores dos atributos de uma quantidade determinada de objetos criados a partir da classe,
podem ser diferentes.

Na Figura 8 é mostrado o diagrama UML que foi utilizado para o

desenvolvimento deste programa.
 Figura 8 - Diagrama UML do programa

SistemaDeVendasV2
__________________________

__________________________ Produto
+ main(args[]: String): void ___________________________
+ cabecalho(): void
- tipo: String
- marca: String
- peso: float
- custo: float
- porcentagem: float
- quantidade: int
___________________________
+ Produto(tipo: String, marca: String,
peso: float, custo: float, porcentagem:
float, quantidade: int)
+ getTipo(): String
+ getMarca(): String
+ getPeso(): float
+ getCusto(): float
+ getPorcentagem(): float
+ getQuantidade(): int
+ setQuantidade(quantidade: int): void
+ calcVenda(quant: float): double

Fonte: autoria própria

3 CONCLUSÃO

Com o desenvolvimento dessa atividade pude compreender melhor como

relacionar os objetos da vida real aplicado em um programa, além de esclarecer os
objetivos e funções de uma classe, método, atributo e objeto. Cada um é responsável por
referenciar algo da vida real, seja ela abstrata ou concreta, e pude tratar esses dados de
forma segura e controlada. Fazer um programa orientado a objeto ajudou a compreender
melhor o problema para trabalhar na solução de forma mais precisa, e através de um
diagrama UML, pude ter visão “panorâmica” de como a base do programa teria que ser.
Nessa segunda versão do programa, foi difícil conseguir descobrir exatamente como seria
a sintaxe para acessar diretamente os atributos encapsulados em um vetor objeto, que tem
característica de ser implementado só depois que o usuário definir a quantidade de
objetos. Novas atualizações poderão ser feitas relacionado a reposição de estoque, para
que não seja necessário recomeçar o programa novamente a cada produto que acabar e
precisar ser reposto na loja.

4 REFERÊNCIAS

CAELUM. Java e Orientação a Objetos. [S. l.: s. n.], 2022. Disponível em:
https://www.alura.com.br/apostila-java-orientacao-objetos. Acesso em: 23 maio 2022.

DEITEL, Paul; DEITEL, Harvey. Java como programar. 8. ed. São Paulo: Pearson
Prentice Hall, 2010.

K19 (org.). Orientação a Objetos em Java. [S. l.: s. n.], 2015.

KB 0-X8POKET 8