Merge pull request #31 from UnBArqDsw2024-1/Artur-JoãoCosta/Entrega03

Artur joão costa/entrega03
UnBArqDsw2024-1 · Jul 25, 2024 · 49fd7d6 · 49fd7d6
2 parents 4ede0d4 + dc56d2b
commit 49fd7d6
Show file tree

Hide file tree

Showing 3 changed files with 330 additions and 0 deletions.
diff --git a/docs/PadroesDeProjeto/Composite.md b/docs/PadroesDeProjeto/Composite.md
@@ -0,0 +1,127 @@
+# Composite - GoF Comportamental
+
+## 1. Introdução
+O padrão de projeto Composite é um padrão estrutural que permite a composição de objetos em estruturas de árvore para representar hierarquias parte-todo. Ele trata objetos individuais e composições de objetos de maneira uniforme, simplificando o design de sistemas que precisam manipular uma coleção de objetos de forma hierárquica. O Composite é especialmente útil em situações onde você quer que o cliente interaja com objetos simples e compostos de maneira idêntica.
+
+
+## 2. Objetivo
+O principal objetivo do padrão Composite é permitir que os clientes tratem objetos individuais e composições de objetos de maneira uniforme. Isso é alcançado ao definir uma interface comum para todos os objetos na composição. O padrão facilita a adição de novos tipos de componentes, já que o cliente não precisa se preocupar se está manipulando um objeto simples ou uma composição complexa. Esse padrão promove um design mais flexível e escalável, reduzindo a complexidade do código e melhorando a manutenibilidade do sistema.
+
+
+## 3. Implementação
+
+
+
+### 3.1. Diagrama UML
+
+
+<![image](https://github.com/user-attachments/assets/93ed98a1-1753-42fc-83e4-7316096b5740)>
+
+<h6 align = "center">Figura 01 Fonte: Artur Rodrigues Sousa Alves e João Víctor Costa Andrade</h6>
+
+### 3.2. Código
+```java
+import java.util.ArrayList;
+import java.util.List;
+
+// Interface Componente
+abstract class HoraTrabalhada {
+    protected String nome;
+
+    public HoraTrabalhada(String nome) {
+        this.nome = nome;
+    }
+
+    public String getNome() {
+        return nome;
+    }
+
+    public abstract int getHoraTrabalhada();
+
+    public void add(HoraTrabalhada horaTrabalhada) {
+        throw new UnsupportedOperationException();
+    }
+
+    public void remove(HoraTrabalhada horaTrabalhada) {
+        throw new UnsupportedOperationException();
+    }
+}
+
+// Folha: Funcionario
+class Funcionario extends HoraTrabalhada {
+    private int horas;
+
+    public Funcionario(String nome, int horas) {
+        super(nome);
+        this.horas = horas;
+    }
+
+    @Override
+    public int getHoraTrabalhada() {
+        return horas;
+    }
+}
+
+// Composto: Organizacao
+class Organizacao extends HoraTrabalhada {
+    private List<HoraTrabalhada> departamentos = new ArrayList<>();
+
+    public Organizacao(String nome) {
+        super(nome);
+    }
+
+    @Override
+    public void add(HoraTrabalhada horaTrabalhada) {
+        departamentos.add(horaTrabalhada);
+    }
+
+    @Override
+    public void remove(HoraTrabalhada horaTrabalhada) {
+        departamentos.remove(horaTrabalhada);
+    }
+
+    @Override
+    public int getHoraTrabalhada() {
+        int totalHoras = 0;
+        for (HoraTrabalhada horaTrabalhada : departamentos) {
+            totalHoras += horaTrabalhada.getHoraTrabalhada();
+        }
+        return totalHoras;
+    }
+}
+
+// Cliente
+public class Program {
+    public static void main(String[] args) {
+        Funcionario func1 = new Funcionario("Funcionario 1", 40);
+        Funcionario func2 = new Funcionario("Funcionario 2", 35);
+        Funcionario func3 = new Funcionario("Funcionario 3", 30);
+
+        Organizacao departamento1 = new Organizacao("Departamento 1");
+        departamento1.add(func1);
+        departamento1.add(func2);
+
+        Organizacao departamento2 = new Organizacao("Departamento 2");
+        departamento2.add(func3);
+
+        Organizacao empresa = new Organizacao("Empresa");
+        empresa.add(departamento1);
+        empresa.add(departamento2);
+
+        System.out.println("Horas trabalhadas no " + departamento1.getNome() + ": " + departamento1.getHoraTrabalhada());
+        System.out.println("Horas trabalhadas no " + departamento2.getNome() + ": " + departamento2.getHoraTrabalhada());
+        System.out.println("Horas trabalhadas na " + empresa.getNome() + ": " + empresa.getHoraTrabalhada());
+    }
+}
+```
+
+## Referências
+
+> **Arquitetura e Desenho de Software - Aula GoFs Comportamentais**. Material de apoio em slides. Milene Serrano.
+## Versionamento
+
+| Versão | Alteração |  Responsável  | Revisor | Data de realização | Data de revisão |
+| :------: | :---: | :-----: | :----: | :----: | :-----: |
+| 1.0 | Criação do documento | [João Costa](https://github.com/jvcostta) | [Artur Rodrigues](https://github.com/ArturRSA19)| 22/07/2024 | 22/07/2024 |
+| 1.2 | Adicionando codigo | [João Costa](https://github.com/jvcostta) | [Artur Rodrigues](https://github.com/ArturRSA19)| 22/07/2024 | 22/07/2024 |
+| 1.3 | Adicionando imagem e finalizando documento | [João Costa](https://github.com/jvcostta) | [Artur Rodrigues](https://github.com/ArturRSA19)| 22/07/2024 | 22/07/2024 |
diff --git a/docs/PadroesDeProjeto/Prototype.md b/docs/PadroesDeProjeto/Prototype.md
@@ -0,0 +1,95 @@
+# Prototype - GoF Criacional
+
+## 1. Introdução
+
+O Prototype é um padrão de projeto criacional que permite copiar objetos existentes sem fazer seu código ficar dependente de suas classes.
+
+## 2. Objetivo
+
+O padrão Prototype delega o processo de clonagem para o próprio objeto que está sendo clonado. O padrão declara um interface comum para todos os objetos que suportam clonagem. Essa interface permite que você clone um objeto sem acoplar seu código à classe daquele objeto. Geralmente, tal interface contém apenas um único método clonar.
+
+## 3. Implementação
+
+
+
+### 3.1. Diagrama UML
+Modelagem utilizando a ferramenta online [Lucidchart](https://www.lucidchart.com/pages/).
+
+![image](https://github.com/user-attachments/assets/953c1118-bf4e-48f6-9160-52f05701f21b)
+
+
+<h6 align = "center">Figura 01 Fonte: Artur Rodrigues Sousa Alves e João Víctor Costa Andrade</h6>
+
+### 3.2. Código
+
+```java
+public interface Prototype {
+    String getColor();
+    Prototype clone();
+}
+
+public class Button implements Prototype {
+    private int x;
+    private int y;
+    private String color;
+
+    public Button(int x, int y, String color) {
+        this.x = x;
+        this.y = y;
+        this.color = color;
+    }
+
+    public Button(Button prototype) {
+        if (prototype != null) {
+            this.x = prototype.x;
+            this.y = prototype.y;
+            this.color = prototype.color;
+        }
+    }
+
+    @Override
+    public String getColor() {
+        return this.color;
+    }
+
+    @Override
+    public Prototype clone() {
+        return new Button(this);
+    }
+
+    @Override
+    public String toString() {
+        return "Button [x=" + x + ", y=" + y + ", color=" + color + "]";
+    }
+}
+
+public class Client {
+    public static void main(String[] args) {
+        PrototypeRegistry registry = new PrototypeRegistry();
+
+        // Adicionando protótipo ao registro
+        Button landingButton = new Button(10, 40, "red");
+        registry.addItem("LandingButton", landingButton);
+
+        // Clonando protótipo pelo ID
+        Button buttonById = (Button) registry.getById("LandingButton");
+        System.out.println(buttonById);
+
+        // Clonando protótipo pela cor
+        Button buttonByColor = (Button) registry.getByColor("red");
+        System.out.println(buttonByColor);
+    }
+}
+```
+
+
+## Referências
+
+> **Arquitetura e Desenho de Software - Aula GoFs Comportamentais**. Material de apoio em slides. Milene Serrano.
+## Versionamento
+
+| Versão | Alteração |  Responsável  | Revisor | Data de realização | Data de revisão |
+| :------: | :---: | :-----: | :----: | :----: | :-----: |
+| 1.0 | Criação do documento | [Artur Rodrigues](https://github.com/ArturRSA19)| [João Costa](https://github.com/jvcostta) | 22/07/2024 | 22/07/2024 |
+| 1.1 | Adicionando código | [Artur Rodrigues](https://github.com/ArturRSA19)| [João Costa](https://github.com/jvcostta) | 22/07/2024 | 22/07/2024 |
+| 1.2 | Finalizando documento| [Artur Rodrigues](https://github.com/ArturRSA19)| [João Costa](https://github.com/jvcostta) | 22/07/2024 | 22/07/2024 |
diff --git a/docs/PadroesDeProjeto/Strategy.md b/docs/PadroesDeProjeto/Strategy.md
@@ -0,0 +1,108 @@
+# Strategy - GoF Comportamental
+
+## 1. Introdução
+
+O padrão de projeto Strategy é um dos 23 padrões de design documentados pelos "Gang of Four" (GoF) no livro "Design Patterns: Elements of Reusable Object-Oriented Software". Este padrão é categorizado como um padrão comportamental, que lida com a responsabilidade e a comunicação entre objetos.
+
+O padrão Strategy permite definir uma família de algoritmos, encapsular cada um deles em uma classe separada e torná-los intercambiáveis. O Strategy permite que o algoritmo varie independentemente dos clientes que o utilizam. Isso facilita a manutenção e a extensão do código, pois novas estratégias podem ser introduzidas sem modificar as existentes.
+
+## 2. Objetivo
+
+O principal objetivo do padrão Strategy é permitir que diferentes algoritmos sejam selecionados e aplicados em tempo de execução sem que o cliente precise conhecer os detalhes de implementação dos algoritmos. Ele visa resolver problemas relacionados à variação do comportamento de uma aplicação, onde um algoritmo específico precisa ser escolhido dentre vários disponíveis.
+
+Os principais benefícios do padrão Strategy incluem:
+
+Encapsulamento de Algoritmos: Cada algoritmo é encapsulado em sua própria classe, promovendo a separação de responsabilidades e facilitando a manutenção e a compreensão do código.
+
+Intercambiabilidade: Algoritmos podem ser alterados ou substituídos sem modificar o código do cliente que os utiliza. Isso proporciona grande flexibilidade e extensibilidade ao sistema.
+
+Isolamento de Código Complexo: Complexidade do algoritmo fica isolada em classes específicas, reduzindo a complexidade do código do cliente.
+
+## 3. Implementação
+
+
+
+### 3.1. Diagrama UML
+Modelagem utilizando a ferramenta online [Lucidchart](https://www.lucidchart.com/pages/).
+
+![image](https://github.com/user-attachments/assets/0acdd8d7-5962-4e8e-badb-8d1c38e0b535)
+
+
+<h6 align = "center">Figura 01 Fonte: Artur Rodrigues Sousa Alves e João Víctor Costa Andrade</h6>
+
+### 3.2. Código
+
+```java
+// Interface da Estratégia
+interface EstrategiaPagamento {
+    void processarPagamento(double valor);
+}
+
+// Estratégia Concreta: Pagamento com Cartão de Crédito
+class PagamentoCartaoCredito implements EstrategiaPagamento {
+    @Override
+    public void processarPagamento(double valor) {
+        System.out.println("Processando pagamento de R$" + valor + " via Cartão de Crédito.");
+    }
+}
+
+// Estratégia Concreta: Pagamento com PayPal
+class PagamentoPayPal implements EstrategiaPagamento {
+    @Override
+    public void processarPagamento(double valor) {
+        System.out.println("Processando pagamento de R$" + valor + " via PayPal.");
+    }
+}
+
+// Estratégia Concreta: Pagamento com Transferência Bancária
+class PagamentoTransferenciaBancaria implements EstrategiaPagamento {
+    @Override
+    public void processarPagamento(double valor) {
+        System.out.println("Processando pagamento de R$" + valor + " via Transferência Bancária.");
+    }
+}
+
+// Contexto
+class Pagamento {
+    private EstrategiaPagamento estrategia;
+
+    public void setEstrategia(EstrategiaPagamento estrategia) {
+        this.estrategia = estrategia;
+    }
+
+    public void processarPagamento(double valor) {
+        this.estrategia.processarPagamento(valor);
+    }
+}
+
+// Cliente
+public class Main {
+    public static void main(String[] args) {
+        Pagamento pagamento = new Pagamento();
+
+        // Pagamento via Cartão de Crédito
+        pagamento.setEstrategia(new PagamentoCartaoCredito());
+        pagamento.processarPagamento(100.0);
+
+        // Pagamento via PayPal
+        pagamento.setEstrategia(new PagamentoPayPal());
+        pagamento.processarPagamento(200.0);
+
+        // Pagamento via Transferência Bancária
+        pagamento.setEstrategia(new PagamentoTransferenciaBancaria());
+        pagamento.processarPagamento(300.0);
+    }
+}
+```
+
+
+## Referências
+
+> **Arquitetura e Desenho de Software - Aula GoFs Comportamentais**. Material de apoio em slides. Milene Serrano.
+## Versionamento
+
+| Versão | Alteração |  Responsável  | Revisor | Data de realização | Data de revisão |
+| :------: | :---: | :-----: | :----: | :----: | :-----: |
+| 1.0 | Criação do documento | [Artur Rodrigues](https://github.com/ArturRSA19)| [João Costa](https://github.com/jvcostta) | 22/07/2024 | 22/07/2024 |
+| 1.1 | Adicionando código | [Artur Rodrigues](https://github.com/ArturRSA19)| [João Costa](https://github.com/jvcostta) | 22/07/2024 | 22/07/2024 |
+| 1.2 | Finalizando documento | [Artur Rodrigues](https://github.com/ArturRSA19)| [João Costa](https://github.com/jvcostta) | 22/07/2024 | 22/07/2024 |