Faça um diagrama de caso de uso e de classes para cada um dos casos abaixo:
Uma loja de automóveis vende carros nacionais, importados, novos e usados. Os carros podem ser vendidos à vista, à prazo ou pela troca pelo carro antigo do cliente, nesse último caso, desejamos cadastrar o carro antigo ao carro vendido. Os carros usados são na verdade carros que foram deixados como troca. Uma venda pode ser feita por um único vendedor ou por um grupo de vendedores.
Uma loja de automóveis vende carros nacionais, importados, novos e usados. Os carros podem ser vendidos à vista, à prazo ou pela troca pelo carro antigo do cliente, nesse último caso, desejamos cadastrar o carro antigo ao carro vendido. Os carros usados são na verdade carros que foram deixados como troca. Uma venda pode ser feita por um único vendedor ou por um grupo de vendedores.
Passo 1
O que o enunciado pede:
- Fazer um diagrama de caso de uso e um diagrama de classes para o sistema descrito.
Informações dadas pelo enunciado (tudo que posso usar):
- A loja vende carros de dois atributos importantes: origem (nacional ou importado) e estado (novo ou usado).
- Os carros usados são, na prática, carros deixados como troca pelos clientes.
- Existem três formas de pagamento/venda: à vista, à prazo e por troca (quando o cliente entrega o carro antigo).
- No caso de troca, é necessário cadastrar o carro antigo vinculado ao carro vendido.
- Uma venda pode ser realizada por um único vendedor ou por um grupo de vendedores.
- Deseja-se modelar os elementos para suportar esses casos (caso de uso + classes).
O que devo entregar:
- Um diagrama de caso de uso (atores + casos de uso + relacionamentos).
- Um diagrama de classes (classes principais, atributos, operações importantes e relacionamentos com multiplicidades).
- Explicações passo a passo para entender e poder reproduzir/interpretar os diagramas na prova.
Passo 2
Primeiro, entenda os elementos que vamos usar (mini-aula rápida, calma que é simples).
- Ator: é quem interage com o sistema (pessoa ou outro sistema). Ex.: Cliente, Vendedor.
- Caso de uso: uma funcionalidade visível do sistema para um ator (ex.: Registrar Venda, Registrar Carro).
- Associação: ligação entre ator e caso de uso (quem usa o quê).
- Inclusão (<<include>>): um caso de uso sempre chama outro (fatia reutilizável).
- Extensão (<<extend>>): um caso de uso opcional/condicional estende outro.
- Classe: entidade do modelo de domínio com atributos (dados) e operações (métodos).
- Herança: especialização entre classes (subclasse herda atributos e operações).
- Associação entre classes com multiplicidade: quantos de um lado se ligam ao outro (ex.: 1…*).
Esses conceitos são suficientes para construir o que precisamos. Vou agora identificar atores e casos de uso do enunciado.
Passo 3
Identificação dos atores e dos casos de uso (peguei tudo do enunciado):
Atores principais:
- Cliente — pessoa que compra e/ou traz carro para troca.
- Vendedor — pessoa que realiza vendas (pode ser um único vendedor ou uma equipe; modelaremos a possibilidade de mais de um vendedor numa venda).
- Sistema (o sistema em si fica dentro da fronteira do diagrama de caso de uso).
Casos de uso importantes (descrição curta de cada um):
- Buscar/Consultar Carros — cliente ou vendedor olha o catálogo/estoque.
- Registrar Carro no Estoque — cadastrar carro novo ou usado (estoque recebe carros).
- Registrar Venda — registrar uma operação de venda (subtipos: à vista, a prazo, por troca).
- Registrar Troca (carro antigo) — cadastrar o carro que o cliente entrega como parte da troca.
- Registrar Cliente — cadastrar dados do cliente (quando necessário).
- Registrar Vendedor(s) na Venda — associar um ou mais vendedores à venda (pode ser parte do processo de Registrar Venda).
- Gerar Documento/Contrato de Venda — emitir comprovante/contrato.
- Gerenciar Estoque — operações administrativas: adicionar/remover marcar carro como vendido.
- Calcular Condições de Pagamento — para venda a prazo (parcelas, juros).
Relações úteis de modelagem:
- Registrar Venda <<include>> Calcular Condições de Pagamento (quando for a prazo).
- Registrar Venda <<include>> Gerar Documento/Contrato.
- Registrar Venda <<extend>> Registrar Troca (extensão quando a modalidade é troca).
- Registrar Troca <<include>> Registrar Carro no Estoque (porque o carro trocado se torna carro usado em estoque).
- Vendedor e Cliente associados a Registrar Venda e Buscar/Consultar Carros.
Passo 4
Construção do diagrama de caso de uso — como montá-lo passo a passo (o objetivo aqui é que você saiba desenhar/explicar na prova):
- Desenhe a fronteira do sistema (um retângulo com “Sistema Loja de Automóveis”).
- Do lado de fora coloque os atores: Cliente e Vendedor.
- No interior, coloque os casos de uso (ovais) com os nomes listados no passo 3.
- Ligue Cliente a: Buscar/Consultar Carros, Registrar Venda (caso o cliente inicie o processo), Registrar Cliente (quando necessário).
- Ligue Vendedor a: Buscar/Consultar Carros, Registrar Venda, Gerenciar Estoque.
- Faça associações adicionais:
- Registrar Venda <<include>> Calcular Condições de Pagamento.
- Registrar Venda <<include>> Gerar Documento/Contrato.
- Registrar Venda <<extend>> Registrar Troca (condicional: somente se modalidade = troca).
- Registrar Troca <<include>> Registrar Carro no Estoque (o carro antigo é cadastrado como usado).
- Se desejar explicitar “venda por equipe”, não precisa criar um ator especial — represente multiplicidade/nota textual: “Venda pode ter 1…* Vendedor associado”. Mas se preferir, pode adicionar um ator “Equipe de Vendas” que generaliza “Vendedor” — ambos são aceitáveis; eu vou representar a multiplicidade no diagrama de classes (mais claro para a prova).
Dica: ao desenhar, use setas com estereótipos <<include>> e <<extend>> bem posicionados; isso mostra entendimento e ganha pontos.
Passo 5
Agora a modelagem de classes — identificando as classes candidatas e justificando (passo a passo didático):
-
Pense em substantivos do enunciado: Carro, Venda, Cliente, Vendedor, Estoque, Troca (ou CarroAntigo), Pagamento/Parcelamento. Cada substantivo vira candidato a classe.
-
Agrupe responsabilidades:
- Carro: guarda dados do veículo (marca, modelo, ano, origem, estado, preço, id).
- Venda: representa a transação; deve referenciar o carro vendido, o(s) vendedor(es), o cliente, a forma de pagamento, data e valor.
- Cliente: dados do comprador.
- Vendedor: dados do vendedor (nome, id, porcentagem de comissão).
- Estoque (Inventory): mantém coleção de Carro (adicionar, remover, buscar).
- Troca (TradeIn) ou usar atributo em Venda para referenciar o carro antigo.
- Pagamento: classe opcional para modelar parcelamento (nº parcelas, valor parcela, juros).
-
Decisão de design importante (explico e justifico):
- Origem (nacional/importado) e estado (novo/usado) são atributos do Carro, não subclasses. Por quê? Porque um carro pode ser simultaneamente nacional e usado — isso é um atributo combinável; criar subclasses para todas as combinações (Nacional/Importado × Novo/Usado) complica e raramente acrescenta benefício. Então: use enums.
- Carros usados são carros deixados em troca: modelaremos que, em uma Venda do tipo troca, o carro antigo é cadastrado e passa a integrar o Estoque com atributo estado = USADO. Podemos ter uma classe TradeIn (ou simplesmente um link Venda.carroTrocado para um objeto Carro) — prefiro a segunda opção simples: Venda terá um atributo opcional carroTrocado: Carro (0…1) e, após a finalização, esse carro será adicionado ao Estoque (estado = USADO).
- Venda pode ter 1…* Vendedor — modelamos associação com multiplicidade.
Passo 6
Definição detalhada das classes (atributos e operações principais). Isso é o conteúdo que deverá constar no diagrama de classes textual/visual. Vou listar cada classe com atributos e métodos sugeridos; depois explico relações e multiplicidades.
Classe: Carro
- Atributos:
- id: String
- marca: String
- modelo: String
- ano: Integer
- origem: OrigemEnum {NACIONAL, IMPORTADO}
- estado: EstadoEnum {NOVO, USADO}
- precoTabela: Decimal
- precoVenda: Decimal
- observacoes: String
- Operações:
- atualizarPreco(novoPreco: Decimal): void
- marcarComoVendido(): void
Classe: Cliente
- Atributos:
- id: String
- nome: String
- cpfCnpj: String
- telefone: String
- endereco: String
- Operações:
- atualizarContato(…): void
Classe: Vendedor
- Atributos:
- id: String
- nome: String
- matricula: String
- comissaoPercentual: Decimal
- Operações:
- calcularComissao(valorVenda: Decimal): Decimal
Classe: Venda
- Atributos:
- id: String
- data: Date
- tipo: TipoVendaEnum {AVISTA, A_PRAZO, TROCA}
- valorBruto: Decimal
- valorLiquido: Decimal
- parcelas: Integer (opcional; usado em A_PRAZO)
- Operações:
- calcularValorTotal(): Decimal
- adicionarVendedor(v: Vendedor): void
- finalizar(): void
- Associações (descritas abaixo):
- carroVendido: Carro (1) — o carro que está sendo vendido
- carroTrocado: Carro (0…1) — presente somente se tipo = TROCA
- cliente: Cliente (1)
- vendedores: Vendedor (1…*)
Classe: Estoque
- Atributos:
- id: String
- listaCarros: List<Carro>
- Operações:
- adicionarCarro(c: Carro): void
- removerCarro(c: Carro): void
- buscarPorFiltro(…): List<Carro>
Classe: Pagamento (opcional, para a prazo)
- Atributos:
- id: String
- forma: String
- numParcelas: Integer
- jurosPercentual: Decimal
- Operações:
- calcularParcela(valor: Decimal): Decimal
Enumerations:
- OrigemEnum {NACIONAL, IMPORTADO}
- EstadoEnum {NOVO, USADO}
- TipoVendaEnum {AVISTA, A_PRAZO, TROCA}
Passo 7
Relações, multiplicidades e regras de negócio (explicação detalhada para a prova):
- Venda — Carro:
- Associação: Venda 1 — 1 Carro (carroVendido)
- Significa: cada venda tem exatamente um carro vendido; um carro no estoque poderá ser vendido em uma ou zero vendas (após vendido, status muda).
- Venda — Carro (troca):
- Associação: Venda 1 — 0…1 Carro (carroTrocado)
- Significa: se a venda for por troca, existe um carroTrocado associado; se não, esse campo fica nulo.
- Regra: quando carroTrocado estiver presente e a venda for finalizada, o sistema deverá adicionar esse Carro ao Estoque com estado = USADO.
- Venda — Vendedor:
- Associação: Venda 1 — 1…* Vendedor
- Significa: cada venda é registrada com pelo menos um vendedor; pode haver vários (equipe).
- Venda — Cliente:
- Associação: Venda 1 — 1 Cliente
- Significa: cada venda tem um cliente associado.
- Estoque — Carro:
- Associação: Estoque 1 — * Carro
- Significa: o estoque contém vários carros.
- Observações sobre integridade:
- Um Carro marcado como vendido não deve permanecer disponível no Estoque.
- O carroTrocado, uma vez cadastrado em Venda (troca), deve ser copiado/transferido para o Estoque ao finalizar a venda, e vinculado como Carro com estado USADO.
Passo 8
Alternativas de modelagem (o que o examinador pode aceitar e o que é preferível — mini-debate didático):
Alternativa A (que eu recomendei):
- Carro com atributos origem e estado (enum). Venda tem campo carroTrocado opcional. Vendedor multiplicidade 1…*.
- Vantagem: simples, direta, cobre todos os requisitos dados.
Alternativa B (mais orientada a herança):
- Ter subclasses CarroNovo e CarroUsado (CarroUsado com atributos adicionais, ex.: quilometragem, histórico).
- Vantagem: se o domínio exige atributos muito distintos para usados (ex.: laudos, número de proprietários), essa modelagem é útil.
- Desvantagem: complica se origem (nacional/importado) também precisa ser subclassificada.
Alternativa C (usar entidade TradeIn separada):
- Criar classe TradeIn com dados do carro antigo e link para Venda; depois criar um Carro a partir do TradeIn ao integrá-lo ao Estoque.
- Vantagem: melhor auditoria/histórico; se o negócio exige registrar avaliação da troca, notas, fotos, é uma boa escolha.
Na prova: explique por que escolheu a alternativa A (atributos + link opcional) — é geralmente suficiente e mais simples de desenhar em pouco tempo.
Passo 9
Como desenhar o diagrama de classes na prova (passo a passo rápido, prático):
- No topo/esquerda coloque Carro com seus atributos e operações curtas.
- Abaixo/à direita coloque Venda, com atributos tipo, data, valor, métodos calcular/ finalizar.
- A partir de Venda desenhe associação para Carro (label carroVendido, 1), para Cliente (1) e para Vendedor (1…*).
- Desenhe associação opcional de Venda para Carro com o nome carroTrocado (0…1).
- Desenhe Estoque com listaCarros e associe a Carro (1…*).
- Acrescente notas (estereótipos) explicando: quando tipo = TROCA então carroTrocado é obrigatório e, após finalizar, carroTrocado -> adiciona no Estoque como USADO.
- Coloque enums em um canto (OrigemEnum, EstadoEnum, TipoVendaEnum).
Passo 10
Boas práticas e observações finais para a prova (motivação e ansiedade controlada):
- Não gaste tempo demais com detalhes de métodos, foque em atributos essenciais e nas multiplicidades/associações, porque são pontos-chave.
- No diagrama de caso de uso, nomeie claramente os estereótipos <<include>> / <<extend>> e indique que “Registro de Troca” é extensão de “Registrar Venda”.
- Se ficar sem tempo, entregue um diagrama de classes coerente com as relações (Venda–Carro–Vendedor–Cliente–Estoque) e uma legenda explicando a troca vs. usado — isso normalmente é suficiente.
- Você consegue fazer isso em ~15–25 minutos em prova se seguir os passos acima. Respira, vai dar certo!
Resposta
Diagrama de Caso de Uso (descrição textual / pronta para desenhar)
- Atores:
- Cliente
- Vendedor
- Casos de uso principais:
- Buscar/Consultar Carros
- Registrar Cliente
- Registrar Carro no Estoque
- Registrar Venda
- <<include>> Calcular Condições de Pagamento
- <<include>> Gerar Documento/Contrato
- <<extend>> Registrar Troca (condicional quando tipo = TROCA)
- Registrar Troca
- Gerenciar Estoque
- Associações:
- Cliente — Buscar/Consultar Carros
- Cliente — Registrar Venda
- Cliente — Registrar Cliente
- Vendedor — Buscar/Consultar Carros
- Vendedor — Registrar Venda
- Vendedor — Gerenciar Estoque
- Registrar Venda <<include>> Calcular Condições de Pagamento
- Registrar Venda <<include>> Gerar Documento/Contrato
- Registrar Venda <<extend>> Registrar Troca
- Registrar Troca <<include>> Registrar Carro no Estoque
- Observação: indicar em nota que “Venda pode ter 1…* Vendedors (venda individual ou em grupo)”.
Diagrama de Classes (texto pronto para desenhar ou transcrever em UML)
-
Classes e atributos/operacoes principais:Classe: Carro
- id: String
- marca: String
- modelo: String
- ano: Integer
- origem: OrigemEnum {NACIONAL, IMPORTADO}
- estado: EstadoEnum {NOVO, USADO}
- precoTabela: Decimal
- precoVenda: Decimal
- observacoes: String
- atualizarPreco(novoPreco: Decimal): void
- marcarComoVendido(): void
Classe: Cliente- id: String
- nome: String
- cpfCnpj: String
- telefone: String
- endereco: String
- atualizarContato(…): void
Classe: Vendedor- id: String
- nome: String
- matricula: String
- comissaoPercentual: Decimal
- calcularComissao(valorVenda: Decimal): Decimal
Classe: Venda- id: String
- data: Date
- tipo: TipoVendaEnum {AVISTA, A_PRAZO, TROCA}
- valorBruto: Decimal
- valorLiquido: Decimal
- parcelas: Integer (opcional)
- calcularValorTotal(): Decimal
- adicionarVendedor(v: Vendedor): void
- finalizar(): void
- Associação: carroVendido: Carro (1)
- Associação: carroTrocado: Carro (0…1) // presente se tipo = TROCA
- Associação: cliente: Cliente (1)
- Associação: vendedores: Vendedor (1…*)
Classe: Estoque- id: String
- listaCarros: List<Carro>
- adicionarCarro(c: Carro): void
- removerCarro(c: Carro): void
- buscarPorFiltro(…): List<Carro>
Classe (opcional): Pagamento- id: String
- forma: String
- numParcelas: Integer
- jurosPercentual: Decimal
- calcularParcela(valor: Decimal): Decimal
Enums:- OrigemEnum {NACIONAL, IMPORTADO}
- EstadoEnum {NOVO, USADO}
- TipoVendaEnum {AVISTA, A_PRAZO, TROCA}
-
Relacionamentos (resumo com multiplicidades):
- Venda 1 — 1 Carro (carroVendido)
- Venda 1 — 0…1 Carro (carroTrocado) // somente para TROCA
- Venda 1 — 1 Cliente
- Venda 1 — 1…* Vendedor
- Estoque 1 — * Carro
-
Regras de negócio documentadas (para colocar como notas no diagrama):
- Quando Venda.tipo = TROCA e Venda.carroTrocado preenchido, ao finalizar a venda o sistema deve adicionar Venda.carroTrocado no Estoque com Estado = USADO.
- Um Carro marcado como vendido deve ser removido do Estoque/disponibilidade.
- Vendas podem envolver um único vendedor ou vários; por isso Venda.vendedores multiplicidade 1…*.
(Pronto para desenhar: usar o diagrama de caso de uso com os atores e relações acima; usar o diagrama de classes com classes, atributos, métodos e associações e multiplicidades indicadas.)