diff --git a/docs/PadroesDeProjeto/Composite.md b/docs/PadroesDeProjeto/Composite.md
new file mode 100644
index 0000000..e53373c
--- /dev/null
+++ 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
+
+
+
+
+Figura 01 Fonte: Artur Rodrigues Sousa Alves e João Víctor Costa Andrade
+
+### 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 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
new file mode 100644
index 0000000..270816f
--- /dev/null
+++ 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/).
+
+
+
+
+Figura 01 Fonte: Artur Rodrigues Sousa Alves e João Víctor Costa Andrade
+
+### 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
new file mode 100644
index 0000000..dd9bfe0
--- /dev/null
+++ 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/).
+
+
+
+
+Figura 01 Fonte: Artur Rodrigues Sousa Alves e João Víctor Costa Andrade
+
+### 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 |