├── .gitignore ├── Algoritmos ├── Bubble Sort Algorithm │ ├── Bubble Sort │ │ ├── .gitignore │ │ └── src │ │ │ └── com │ │ │ └── bubblesort │ │ │ └── java │ │ │ ├── BubbleSort.java │ │ │ └── SortingAlgorithms.java │ ├── BubbleSort.gif │ ├── README.md │ └── img.png ├── Counting Sort Algorithm │ ├── .gitignore │ ├── README.md │ ├── counting-sort │ │ └── src │ │ │ ├── CountingSort.java │ │ │ └── SortingAlgorithms.java │ ├── img.png │ ├── img_1.png │ ├── img_3.png │ ├── img_4.png │ ├── img_5.png │ ├── img_7.png │ └── img_8.png ├── LIFO-Last in First out.md ├── LIFO │ ├── README.md │ └── src │ │ ├── Ball.java │ │ └── Lifo.java ├── Quicksort │ └── src │ │ ├── Main.java │ │ └── README.md ├── README.md └── Recursion │ └── src │ └── Recursion.java ├── CONTRIBUTING.md ├── Design Patterns ├── Abstract Factory Pattern │ ├── README.md │ └── com │ │ └── abstractfactory │ │ └── java │ │ ├── factory │ │ ├── BrazilianRulesAbstractFactory.java │ │ ├── CountryRulesAbstractFactory.java │ │ └── USRulesAbstractFactory.java │ │ ├── model │ │ ├── certificate │ │ │ ├── BrazilianCertificate.java │ │ │ ├── Certificate.java │ │ │ └── USCertificate.java │ │ └── packing │ │ │ ├── BrazilianPacking.java │ │ │ ├── Packing.java │ │ │ └── USPacking.java │ │ └── test │ │ └── AbstractFactoryTest.java ├── Adapter │ ├── README.md │ ├── com.adapter.java │ │ ├── JackConnector.java │ │ ├── JackToUsbAdapter.java │ │ ├── Main.java │ │ ├── Usb.java │ │ └── UsbConnector.java │ └── images │ │ ├── adapter.png │ │ ├── class-adapter.png │ │ ├── jack-to-usbc.png │ │ └── obj-adaptor.png ├── Builder │ ├── README.md │ └── com.builder.java │ │ ├── Dought.java │ │ ├── Pizza.java │ │ ├── Sauce.java │ │ ├── Size.java │ │ └── Topping.java ├── Chain of Responsability Pattern │ └── com │ │ └── chainresponsability │ │ └── java │ │ ├── README.md │ │ ├── enumeration │ │ ├── DiscountType.java │ │ └── PaymentType.java │ │ ├── model │ │ ├── Order.java │ │ └── OrderItem.java │ │ ├── service │ │ └── discount │ │ │ ├── Discount.java │ │ │ ├── DiscountPackage.java │ │ │ ├── DiscountPixPayment.java │ │ │ └── DiscountPremiumCustomer.java │ │ └── test │ │ └── ChainResponsabilityTest.java ├── Composite Pattern │ └── com.composite.principal │ │ ├── Content.java │ │ ├── Lesson.java │ │ ├── Main.java │ │ ├── Module.java │ │ └── README.md ├── Facade Pattern │ ├── README.md │ └── com │ │ └── facade │ │ └── java │ │ ├── enumeration │ │ └── TransportType.java │ │ ├── model │ │ ├── DeliveryByBicycle.java │ │ ├── DeliveryByCar.java │ │ ├── DeliveryByTruck.java │ │ ├── DeliveryTransport.java │ │ └── PackageInfo.java │ │ ├── service │ │ ├── CalcService.java │ │ └── ManageDelivery.java │ │ └── test │ │ └── FacadeTest.java ├── FactoryMethod │ ├── README.md │ └── com │ │ └── factorymethod │ │ └── java │ │ ├── Animal.java │ │ ├── AnimalFactory.java │ │ ├── MainAnimalFactory.java │ │ └── RandomAnimalFactory.java ├── Observer Pattern │ ├── README.md │ └── com │ │ └── observer │ │ └── java │ │ ├── model │ │ └── Product.java │ │ ├── observer │ │ ├── ClientProductObserver.java │ │ └── Observer.java │ │ ├── service │ │ └── ProductStockService.java │ │ ├── subject │ │ ├── ProductOutOfStockSubject.java │ │ └── Subject.java │ │ └── test │ │ └── ObserverTest.java ├── Proxy Pattern │ ├── README.md │ └── com.proxy.principle │ │ ├── DownloadPlatform.java │ │ ├── ProxyVideo.java │ │ ├── RealVideo.java │ │ └── Video.java ├── README.md ├── Singleton │ ├── README.md │ └── com.singleton.java │ │ └── MySingleton.java └── Strategy Pattern │ ├── README.md │ └── com.strategy.java │ ├── Addition.java │ ├── Context.java │ ├── Division.java │ ├── Multiplication.java │ ├── Strategy.java │ └── Subtraction.java ├── Exception Handling ├── Acessando Indice │ ├── README.md │ └── com.accessing.index │ │ └── java │ │ └── Main.java ├── Custom Exception │ └── com.custom.java │ │ ├── README.md │ │ ├── domain │ │ └── Pessoa.java │ │ ├── exceptions │ │ └── IdadeInvalidaException.java │ │ └── impl │ │ └── Main.java ├── Encadeamento de Excecoes │ └── com.encadeamento.excecoes.java │ │ ├── Main.java │ │ ├── README.md │ │ └── exception │ │ └── AcessoNegadoException.java ├── File Not Found │ ├── Arquivos │ │ └── arquivo.txt │ ├── Main.java │ └── README.md ├── Leitura e Processamento de arquivo │ ├── Color.txt │ ├── README.md │ └── src │ │ └── Main.java ├── Multiple Exceptions │ ├── .gitignore │ ├── README.md │ └── src │ │ └── MultipleExceptionsExample.java ├── Null Pointer Exception │ ├── README.md │ └── com.npe │ │ └── java │ │ ├── Produto.java │ │ └── ServicoProduto.java └── README.md ├── Java Basic Sintax └── README.md ├── POO ├── Abstracao │ ├── README.md │ ├── circulo.java │ ├── formaGeometrica.java │ ├── quadrado.java │ └── triangulo.java ├── Polimorfismo │ ├── README.md │ └── exemplos │ │ ├── PolimorfismoSobrecarga.java │ │ └── PolimorfismoSobrescrita.Java └── README.md ├── README.md ├── Testes └── README.md └── java-trainning.iml /.gitignore: -------------------------------------------------------------------------------- 1 | .DS_Store 2 | -------------------------------------------------------------------------------- /Algoritmos/Bubble Sort Algorithm/Bubble Sort/.gitignore: -------------------------------------------------------------------------------- 1 | src/out/* 2 | src/.idea/* 3 | src/*.iml 4 | -------------------------------------------------------------------------------- /Algoritmos/Bubble Sort Algorithm/Bubble Sort/src/com/bubblesort/java/BubbleSort.java: -------------------------------------------------------------------------------- 1 | package com.bubblesort.java; 2 | 3 | public class BubbleSort { 4 | public int[] sortList(int[] list) { 5 | boolean isSorted = verifySorting(list); 6 | while (!isSorted){ 7 | for (int i=0; i list[i + 1]) { 27 | isSorted = false; 28 | break; 29 | } 30 | } 31 | return isSorted; 32 | } 33 | 34 | private void printList(int[] list){ 35 | for (int num : list) { 36 | System.out.print(num + " "); 37 | } 38 | System.out.println(); 39 | } 40 | 41 | } 42 | 43 | -------------------------------------------------------------------------------- /Algoritmos/Bubble Sort Algorithm/Bubble Sort/src/com/bubblesort/java/SortingAlgorithms.java: -------------------------------------------------------------------------------- 1 | package com.bubblesort.java; 2 | 3 | import com.bubblesort.java.BubbleSort; 4 | 5 | public class SortingAlgorithms { 6 | public static void main(String[] args) { 7 | 8 | BubbleSort bubbleSort = new BubbleSort(); 9 | int[] list = {3, 5, 1, 2, 4}; 10 | int[] sortedList = bubbleSort.sortList(list); 11 | 12 | for (int num : sortedList) { 13 | System.out.print(num + " "); 14 | } 15 | System.out.println(); 16 | 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /Algoritmos/Bubble Sort Algorithm/BubbleSort.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/devs-javagirl/java-trainning/913aa1d4402d4c1ec18a06eba387019992d244d6/Algoritmos/Bubble Sort Algorithm/BubbleSort.gif -------------------------------------------------------------------------------- /Algoritmos/Bubble Sort Algorithm/README.md: -------------------------------------------------------------------------------- 1 | # Algoritmo de Ordenação: Bubble Sort 2 | 3 | Algoritmo é uma descrição, passo a passo, para a realização de uma determinada tarefa. 4 |
5 |
6 | Um dos problemas que podem ser resolvidos por meio de um algoritmo é a ordenação de elementos, como números ou palavras. 7 |
8 |
9 | Essa tarefa pode ser realizada de diferentes formas, ou seja, existem diversos algoritmos diferentes que produzirão o mesmo resultado. 10 |
11 |
12 | No entanto, em muitas situações, o processo importa tanto quanto o resultado, e um determinado algoritmo pode ser mais adequado que outro, ainda que seus produtos sejam idênticos. 13 |
14 |
15 | Quando se trata da ordenação de elementos, um dos algoritmos existentes é o Bubble Sort, ou "Classificação por Bolha". 16 | 17 | 18 | # Bubble Sort 19 | 20 | O Bubble Sort é um algoritmo simples, mas pouco eficiente. 21 |
Com ele, cada elemento de uma lista é comparado com o elemento seguinte, e caso o segundo seja menor do que o primeiro, eles trocam de lugar. 22 |
A lista precisa ser percorrida quantas vezes seja necessário, até que todos os elementos estejam ordenados. 23 | 24 | Vamos exemplificar com a seguinte lista numérica, onde os valores entre [ ] representam a posição de cada elemento: 25 | 26 | ![img.png](img.png) 27 | 28 | 29 | * **Primeira passagem:** 30 | - O elemento na posição [0] é comparado ao elemento na posição [1], e caso o elemento [1] seja menor, eles trocam de lugar: 31 |
5 < 3: Falso - Os elementos são mantidos em suas posições.
32 | - O elemento na posição [1] é comparado ao elemento na posição [2], e caso o elemento [2] seja menor, eles trocam de lugar: 33 |
1 < 5: Verdadeiro - Os elementos trocam de lugar.
34 | - O elemento na posição [2] é comparado ao elemento na posição [3], e caso o elemento [3] seja menor, eles trocam de lugar: 35 |
2 < 5: Verdadeiro - Os elementos trocam de lugar.
36 | - O elemento na posição [3] é comparado ao elemento na posição [4], e caso o elemento [4] seja menor, eles trocam de lugar: 37 |
4 < 5: Verdadeiro - Os elementos trocam de lugar. 38 | 39 | ![BubbleSort.gif](BubbleSort.gif) 40 | 41 | O processo se repete até que todos os elementos estejam ordenados. 42 | -------------------------------------------------------------------------------- /Algoritmos/Bubble Sort Algorithm/img.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/devs-javagirl/java-trainning/913aa1d4402d4c1ec18a06eba387019992d244d6/Algoritmos/Bubble Sort Algorithm/img.png -------------------------------------------------------------------------------- /Algoritmos/Counting Sort Algorithm/.gitignore: -------------------------------------------------------------------------------- 1 | src/out/* 2 | src/.idea/* 3 | src/*.iml 4 | 5 | 6 | ### IntelliJ IDEA ### 7 | out/ 8 | !**/src/main/**/out/ 9 | !**/src/test/**/out/ 10 | 11 | ### Eclipse ### 12 | .apt_generated 13 | .classpath 14 | .factorypath 15 | .project 16 | .settings 17 | .springBeans 18 | .sts4-cache 19 | bin/ 20 | !**/src/main/**/bin/ 21 | !**/src/test/**/bin/ 22 | 23 | ### NetBeans ### 24 | /nbproject/private/ 25 | /nbbuild/ 26 | /dist/ 27 | /nbdist/ 28 | /.nb-gradle/ 29 | 30 | ### VS Code ### 31 | .vscode/ 32 | 33 | ### Mac OS ### 34 | .DS_Store 35 | -------------------------------------------------------------------------------- /Algoritmos/Counting Sort Algorithm/README.md: -------------------------------------------------------------------------------- 1 | # Algoritmo de Ordenação: Counting Sort 2 | 3 | Algoritmo é uma descrição, passo a passo, para a realização de uma determinada tarefa. 4 |
5 |
6 | Um dos problemas que podem ser resolvidos por meio de um algoritmo é a ordenação de elementos, como números ou palavras. 7 |
8 |
9 | Essa tarefa pode ser realizada de diferentes formas, ou seja, existem diversos algoritmos diferentes que produzirão o mesmo resultado. 10 |
11 |
12 | No entanto, em muitas situações, o processo importa tanto quanto o resultado, e um determinado algoritmo pode ser mais adequado que outro, ainda que seus produtos sejam idênticos. 13 |
14 |
15 | Quando se trata da ordenação de elementos, um dos algoritmos existentes é o Counting Sort, ou "Ordenação por Contagem". 16 | 17 | # Counting Sort 18 | 19 | Counting Sort é um algoritmo de ordenação adequado, em especial, para coleções de numeros inteiros positivos, nos casos em que o intervalo de valores que os seus elementos podem assumir já seja conhecido. 20 | 21 | Este algoritmo utiliza a frequência de cada valor para realizar a ordenação de forma linear, e é consideravelmente mais eficinente para um intervalo pequeno de valores. 22 | 23 | Para demonstrar o funcionamento do Counting Sort, vamos considerar a seguinte coleção de valores inteiros positivos: 24 | 25 | ![img.png](img.png) 26 | 27 | 28 | ## Passos do Counting Sort 29 | 30 | 1. **Contagem das Frequências:** 31 | - Primeiramente, criamos um vetor de contagem, com tamanho igual ao intervalo dos valores na lista. Como 0 (zero) também é um valor válido, o tamanho da lista será igual ao maior valor existente adicionado de um. 32 | - _Tamanho do vetor de contagem: 9 + 1 = 10_ 33 |
34 | Sua Imagem 35 |
36 | 37 | - Percorremos a lista, contando quantas vezes cada valor aparece e atualizando o vetor de contagem com essas frequências. 38 | - No vetor acima temos as sequintes frequências: 39 | - O elemento "1" aparece 1 vez; 40 | - O elemento "2" aparece 2 vezes; 41 | - O elemento "3" aparece 1 vez; 42 | - O elemento "4" aparece 1 vez; 43 | - O elemento "5" aparece 1 vez; 44 | - O elemento "6" aparece 1 vez; 45 | - O elemento "9" aparece 2 vezes; 46 |
47 |
48 | Sua Imagem 49 |
50 | 51 | 52 | 2. **Acumulação das Frequências:** 53 | - Em seguida, acumulamos as frequências no vetor de contagem, de modo que cada elemento guarde a quantidade de elementos menores ou iguais a ele. 54 | - _Não existe nenhum elementos menores ou iguais a "0";_ 55 | - _Existe 1 elemento menor ou igual a "1";_ 56 | - _Existem 3 elementos menores ou iguais a "2";_ 57 | - _Existem 4 elementos menores ou iguais a "3";_ 58 | - _Existem 5 elementos menores ou iguais a "4";_ 59 | - _Existem 6 elementos menores ou iguais a "5";_ 60 | - _Existem 7 elementos menores ou iguais a "6";_ 61 | - _Existem 7 elementos menores ou iguais a "7";_ 62 | - _Existem 7 elementos menores ou iguais a "8";_ 63 | - _Existem 9 elementos menores ou iguais a "9";_ 64 |
65 |
66 | Sua Imagem 67 |
68 | 69 | 70 | 71 | 3. **Construção da Lista Ordenada:** 72 | - Agora, percorremos a lista original novamente e, com base no vetor de contagem, colocamos cada elemento na posição correta na lista ordenada. A posição será igual ao valor da frequencia acumulada -1. 73 | - À medida que fazemos isso, decrementamos a frequência correspondente no vetor de contagem. 74 | 75 |
Abaixo demostramos como ocorre o posicionamento do primeiro elemento no vetor auxiliar: 76 | 77 |
78 |
79 | Sua Imagem 80 |

81 |
82 | Sua Imagem 83 |

84 |
85 | Sua Imagem 86 |
87 | 88 | 89 |
90 | 91 | 92 | 4. **Lista Ordenada:** 93 | - Após completar o passo anterior para todos os elementos, obtemos a lista ordenada no vetor auxiliar. 94 | - Em seguida, basta copiar o vetor auxiliar para o vetor original e obter os elementos organizados. 95 | -------------------------------------------------------------------------------- /Algoritmos/Counting Sort Algorithm/counting-sort/src/CountingSort.java: -------------------------------------------------------------------------------- 1 | import java.util.Arrays; 2 | 3 | public class CountingSort { 4 | public void sortList(int[] list) { 5 | // Nada a fazer se o array estiver vazio ou já estiver ordenado. 6 | if (list == null || list.length <= 1) { 7 | System.out.println("Vetor inválido"); 8 | return; 9 | } else if (this.verifySorting(list)) { 10 | System.out.println("O vetor já está ordenado"); 11 | 12 | } else { 13 | // Encontrar o valor máximo no array. 14 | int maxValue = Arrays.stream(list).max().getAsInt(); 15 | 16 | // Criar um vetor de contagem com base no valor máximo 17 | // Lembre-se que o 0 também é um valor válido. 18 | int[] count = new int[maxValue + 1]; 19 | 20 | // Contar a frequência de cada valor no array original 21 | // e armazenar na posição correspondente ao valor. 22 | for (int value : list) { 23 | count[value]++; 24 | } 25 | 26 | // Acumular as frequências. 27 | for (int i = 1; i < count.length; i++) { 28 | count[i] += count[i - 1]; 29 | } 30 | 31 | // Criar vetor auxiliar para armazenar valores ordenados. 32 | int[] aux = new int[list.length]; 33 | // Construir a lista ordenada. 34 | for (int i = list.length - 1; i >= 0; i--) { 35 | aux[count[list[i]] - 1] = list[i]; 36 | count[list[i]]--; 37 | 38 | } 39 | 40 | // Copiar os elementos ordenados de volta para o array original. 41 | System.arraycopy(aux, 0, list, 0, list.length); 42 | } 43 | } 44 | 45 | private boolean verifySorting ( int[] list){ 46 | boolean isSorted = true; 47 | for (int i = 0; i < list.length - 1; i++) { 48 | if (list[i] > list[i + 1]) { 49 | isSorted = false; 50 | break; 51 | } 52 | } 53 | return isSorted; 54 | } 55 | 56 | public void printList(int[] list){ 57 | System.out.print("[ "); 58 | for (int num : list) { 59 | System.out.print(num + " "); 60 | } 61 | System.out.println(" ]"); 62 | } 63 | 64 | 65 | 66 | 67 | } 68 | 69 | 70 | -------------------------------------------------------------------------------- /Algoritmos/Counting Sort Algorithm/counting-sort/src/SortingAlgorithms.java: -------------------------------------------------------------------------------- 1 | import java.util.Arrays; 2 | 3 | public class SortingAlgorithms { 4 | public static void main(String[] args) { 5 | 6 | CountingSort countingSort = new CountingSort(); 7 | int[] list = {4, 2, 9, 1, 6, 3, 9, 5, 2}; 8 | System.out.print("Lista de entrada:\t "); 9 | countingSort.printList(list); 10 | 11 | // ordenando lista com algoritmo Counting Sort 12 | countingSort.sortList(list); 13 | 14 | System.out.print("Lista de saída:\t\t "); 15 | countingSort.printList(list); 16 | 17 | 18 | } 19 | } -------------------------------------------------------------------------------- /Algoritmos/Counting Sort Algorithm/img.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/devs-javagirl/java-trainning/913aa1d4402d4c1ec18a06eba387019992d244d6/Algoritmos/Counting Sort Algorithm/img.png -------------------------------------------------------------------------------- /Algoritmos/Counting Sort Algorithm/img_1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/devs-javagirl/java-trainning/913aa1d4402d4c1ec18a06eba387019992d244d6/Algoritmos/Counting Sort Algorithm/img_1.png -------------------------------------------------------------------------------- /Algoritmos/Counting Sort Algorithm/img_3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/devs-javagirl/java-trainning/913aa1d4402d4c1ec18a06eba387019992d244d6/Algoritmos/Counting Sort Algorithm/img_3.png -------------------------------------------------------------------------------- /Algoritmos/Counting Sort Algorithm/img_4.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/devs-javagirl/java-trainning/913aa1d4402d4c1ec18a06eba387019992d244d6/Algoritmos/Counting Sort Algorithm/img_4.png -------------------------------------------------------------------------------- /Algoritmos/Counting Sort Algorithm/img_5.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/devs-javagirl/java-trainning/913aa1d4402d4c1ec18a06eba387019992d244d6/Algoritmos/Counting Sort Algorithm/img_5.png -------------------------------------------------------------------------------- /Algoritmos/Counting Sort Algorithm/img_7.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/devs-javagirl/java-trainning/913aa1d4402d4c1ec18a06eba387019992d244d6/Algoritmos/Counting Sort Algorithm/img_7.png -------------------------------------------------------------------------------- /Algoritmos/Counting Sort Algorithm/img_8.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/devs-javagirl/java-trainning/913aa1d4402d4c1ec18a06eba387019992d244d6/Algoritmos/Counting Sort Algorithm/img_8.png -------------------------------------------------------------------------------- /Algoritmos/LIFO-Last in First out.md: -------------------------------------------------------------------------------- 1 | # LIFO - Last In, First Out 2 | 3 | ## Conceito 4 | 5 | O LIFO é uma política de processamento aplicada em estrutura de dados, que basicamente consiste na seguinte regra: o último a entrar é o primeiro a sair! Ou seja, quem chegou por último é o primeiro a ser processado/atendido. 6 | 7 | A estrutura de dados que aplica esta política é a Pilha (*Stack*). 8 | 9 | As operações comuns em pilhas são: 10 | 11 | * **Empilhar - *push***: inseri item na pilha. O item é inserido após o último item da pilha, logo o item adicionado passa a ser o último; 12 | * **Desempilhar - *pop***: remove item da pilha. O item removido é o último adicionado; 13 | * **Vazia - *empty***: verifica se a pilha está vazia. 14 | 15 | ## Código em Java 16 | 17 | Em Java, a classe *Stack* implementa a política LIFO. Ela pertence ao pacote *java.util*. 18 | 19 | Segue abaixo um exemplo de código de uso da classe Stack e alguns dos métodos disponíveis nela: 20 | 21 | 22 | public void Lifo{ 23 | 24 | // Instancia a classe Stack 25 | Stack tube = new Stack<>(); 26 | 27 | // Verifica se a pilha está vazia 28 | tube.empty(); 29 | 30 | // Empilha item na pilha 31 | tube.push("Vermelha"); 32 | tube.push("Amarela"); 33 | tube.push("Azul"); 34 | tube.push("Verde"); 35 | 36 | // Conta o número de itens na pilha 37 | tube.size(); 38 | 39 | // Desempilha item na pilha 40 | System.out.println(tube.pop()); // Retorna: Verde 41 | 42 | // Informa quem está no topo da pilha 43 | System.out.println(tube.peek()); // Retorna: Azul 44 | 45 | // Informa a posição que o item está na pilha 46 | System.out.println(tube.search("Azul")); // Retorna: 1 47 | } 48 | 49 | ## Aplicações 50 | 51 | Transportando para o mundo real, a LIFO pode ser empregado na seguinte situação: 52 | 53 | 1. Imagine que você tenha um copo em formato de tubo e algumas bolinhas do tamanho do copo. 54 | 55 | 2. Então você vai inserindo uma bolinha por vez dentro do copo, ou seja, empilhando as bolinhas. 56 | 57 | 3. Para esvaziar o copo, o que faremos? Acredito que a única maneira seja você primeiro remover a última bolinha e assim sucessivamente. É isso, você acabou que aplicar a LIFO! 58 | 59 |
60 | stack 62 |
63 | 64 | (Fonte: Java Stack - CodeGym) 65 | 66 |
67 |
68 | 69 | ## Links de conteúdos auxiliares 70 | 71 | * [Documentação](https://docs.oracle.com/javase/8/docs/api/java/util/Stack.html) 72 | * [Java Stack](https://www.baeldung.com/java-stack) -------------------------------------------------------------------------------- /Algoritmos/LIFO/README.md: -------------------------------------------------------------------------------- 1 | # LIFO - Last In, First Out 2 | 3 | ## Conceito 4 | 5 | O LIFO é uma política de processamento aplicada em estrutura de dados, que basicamente consiste na seguinte regra: o último a entrar é o primeiro a sair! Ou seja, quem chegou por último é o primeiro a ser processado/atendido. 6 | 7 | A estrutura de dados que aplica esta política é a Pilha (*Stack*). 8 | 9 | As operações comuns em pilhas são: 10 | 11 | * **Empilhar - *push***: inseri item na pilha. O item é inserido após o último item da pilha, logo o item adicionado passa a ser o último; 12 | * **Desempilhar - *pop***: remove item da pilha. O item removido é o último adicionado; 13 | * **Vazia - *empty***: verifica se a pilha está vazia. 14 | 15 | ## Código em Java 16 | 17 | Em Java, a classe *Stack* implementa a política LIFO. Ela pertence ao pacote *java.util*. 18 | 19 | Segue abaixo um exemplo de código de uso da classe Stack e alguns dos métodos disponíveis nela: 20 | 21 | 22 | public void Lifo{ 23 | 24 | // Instancia a classe Stack 25 | Stack tube = new Stack<>(); 26 | 27 | // Verifica se a pilha está vazia 28 | tube.empty(); 29 | 30 | // Empilha item na pilha 31 | tube.push("Vermelha"); 32 | tube.push("Amarela"); 33 | tube.push("Azul"); 34 | tube.push("Verde"); 35 | 36 | // Conta o número de itens na pilha 37 | tube.size(); 38 | 39 | // Desempilha item na pilha 40 | System.out.println(tube.pop()); // Retorna: Verde 41 | 42 | // Informa quem está no topo da pilha 43 | System.out.println(tube.peek()); // Retorna: Azul 44 | 45 | // Informa a posição que o item está na pilha 46 | System.out.println(tube.search("Azul")); // Retorna: 1 47 | } 48 | 49 | ## Aplicações 50 | 51 | Transportando para o mundo real, a LIFO pode ser empregado na seguinte situação: 52 | 53 | 1. Imagine que você tenha um copo em formato de tubo e algumas bolinhas do tamanho do copo. 54 | 55 | 2. Então você vai inserindo uma bolinha por vez dentro do copo, ou seja, empilhando as bolinhas. 56 | 57 | 3. Para esvaziar o copo, o que faremos? Acredito que a única maneira seja você primeiro remover a última bolinha e assim sucessivamente. É isso, você acabou que aplicar a LIFO! 58 | 59 |
60 | stack 62 |
63 | 64 | (Fonte: Java Stack - CodeGym) 65 | 66 |
67 |
68 | 69 | ## Links de conteúdos auxiliares 70 | 71 | * [Documentação](https://docs.oracle.com/javase/8/docs/api/java/util/Stack.html) 72 | * [Java Stack](https://www.baeldung.com/java-stack) -------------------------------------------------------------------------------- /Algoritmos/LIFO/src/Ball.java: -------------------------------------------------------------------------------- 1 | package Algoritmos.LIFO.com.lifo.java; 2 | 3 | public class Ball { 4 | 5 | private String collor; 6 | 7 | public Ball(String collor) { 8 | this.collor = collor; 9 | } 10 | 11 | @Override 12 | public String toString() { 13 | return "Ball " + collor ; 14 | } 15 | 16 | 17 | } 18 | -------------------------------------------------------------------------------- /Algoritmos/LIFO/src/Lifo.java: -------------------------------------------------------------------------------- 1 | package Algoritmos.LIFO.com.lifo.java; 2 | 3 | import java.util.Stack; 4 | 5 | public class Lifo { 6 | 7 | public static void main(String[] args) { 8 | // Instancia a classe Stack 9 | Stack tube = new Stack<>(); 10 | 11 | // Verifica se a pilha está vazia 12 | tube.empty(); 13 | 14 | // Empilha item na pilha 15 | tube.push(new Ball("Vermelha")); 16 | tube.push(new Ball("Amarela")); 17 | Ball blueBall = new Ball("Azul"); 18 | tube.push(blueBall); 19 | tube.push(new Ball("Verde")); 20 | 21 | // Conta o número de itens na pilha 22 | tube.size(); 23 | 24 | // Desempilha item na pilha 25 | System.out.println(tube.pop()); // Retorna: Verde 26 | 27 | // Informa quem está no topo da pilha 28 | System.out.println(tube.peek()); // Retorna: Azul 29 | 30 | // Informa a posição que o item está na pilha 31 | System.out.println(tube.search(blueBall)); // Retorna: 1 32 | } 33 | 34 | } 35 | -------------------------------------------------------------------------------- /Algoritmos/Quicksort/src/Main.java: -------------------------------------------------------------------------------- 1 | import java.sql.Array; 2 | 3 | public class Main { 4 | 5 | public static int particionaLomuto(Integer[] array, int inicio, int fim){ 6 | /*escolhe o pivot, estamos escolhendo o primeiro elemento, mas poderia ser aleatório 7 | o sucesso do quicksort está em escolher um bom pivot, e para isso existem algumas estratégias*/ 8 | int pivot = array[inicio]; 9 | 10 | int posicaoMenor = inicio + 1; 11 | 12 | /*particiona o array deixando o pivot no "meio" 13 | percorre o array até encontrar um elemento menor ou igual ao pivot*/ 14 | for(int i = inicio + 1; i <= fim; i++){ 15 | 16 | if(array[i] <= pivot){ 17 | /*coloca o elemento na frente do pivot e o elemento que estava ali vai para a posição do elemento que foi encontrado*/ 18 | troca(array, i, posicaoMenor); 19 | posicaoMenor +=1; 20 | } 21 | } 22 | /*coloca o pivot na posição logo após seus elementos menores*/ 23 | troca(array, inicio, posicaoMenor - 1); 24 | 25 | /*retorna posição atual do pivot*/ 26 | return posicaoMenor - 1; 27 | } 28 | 29 | public static void troca(Integer[] array, int i, int j){ 30 | int aux = array[i]; 31 | array[i] = array[j]; 32 | array[j] = aux; 33 | } 34 | 35 | public static void quickSort(Integer[] array, int inicio, int fim){ 36 | /*condição de parada da função recursiva*/ 37 | if(inicio < fim){ 38 | 39 | /*chamada da função de particionamento baseada no método Lomuto*/ 40 | int pivot = particionaLomuto(array, inicio, fim); 41 | 42 | /*a chamada dupla recursiva à função quicksort, na primeira chamada mandamos o lado "direto" do pivot 43 | *na segunda chamada mandamos o lado "esquerdo" do pivot 44 | * *não precisamos enviar o pivot pois ele já está na posição correta*/ 45 | quickSort(array, inicio, pivot-1); 46 | quickSort(array, pivot+1, fim); 47 | } 48 | } 49 | 50 | public static void main(String args[]){ 51 | 52 | Integer array[] = {4, -4, 6, 10, 0, -1, 2, 8, 50, 0, 32, 1, -1, 4}; 53 | quickSort(array, 0, array.length-1); 54 | 55 | for(int i =0; i< array.length; i++){ 56 | System.out.print(" " + array[i]); 57 | } 58 | 59 | } 60 | 61 | } 62 | -------------------------------------------------------------------------------- /Algoritmos/Quicksort/src/README.md: -------------------------------------------------------------------------------- 1 | # Quicksort 2 | O quicksort é um algoritmo de ordenação utilizado em uma ampla variedade de situações, é um algoritmo rápido e eficiente, onde em seu pior caso pode ter uma complexidade de **O(n²)** porém no melhor caso pode chegar a **O(n log n)**. 3 | O algoritimo consistem em estratégia de particionamento a partir de um elemento qualquer do vetor, **o pivot**, e de forma recursiva ordena essas partes menores até que todo o vetor esteja ordenado. 4 | 5 | Após escolhido o pivot o particionamento deve ser aplicado, deixando a esquerda do elemento escolhido os elementos menores iguaia a ele e à direita os elementos maiores. 6 | Não significa que os elementos estão ordenados, apenas que um partiiconamento foi feito e que agora precismaos ordenar cada uma das partes separadamente reaplicando o processo recursivamente. 7 | 8 | existem métodos para realizar o particionamento, o mais comumente utilizado como introdução e para entendimento do algorítimo, é o **Lomuto** mas temos outros como o **Hoare** e **Dual-Pivot**. 9 | 10 | O Lomuto é considerado mais simples, consiste em identificar os elementos menores ou iguais ao pivot colocá-los à frente dele e ao final posicionar o pivot a frente deles, deixando o pivot "no meio" do vetor. 11 | 12 | Por exemplo: 13 | v=[9, 6, 8, 7, **3**, 0, 2, -1] 14 | Se consideramos o numero 3 como pivot, após o particionamento utilizando esse método teríamos um vetor semelhante a esse, não fizemos todas iterações é apenas para exemplo. 15 | v=[0,2,-1,**3**, 9,6,8,7] -------------------------------------------------------------------------------- /Algoritmos/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/devs-javagirl/java-trainning/913aa1d4402d4c1ec18a06eba387019992d244d6/Algoritmos/README.md -------------------------------------------------------------------------------- /Algoritmos/Recursion/src/Recursion.java: -------------------------------------------------------------------------------- 1 | package Algorithms; 2 | 3 | public class Recursion { 4 | 5 | private static int factorialCalc(int n){ 6 | if (n <= 1) 7 | return 1; 8 | else 9 | return n * factorialCalc(n-1); 10 | 11 | 12 | } 13 | 14 | private static int regressiveSum(int number) { 15 | if (number <= 1) 16 | return 1; 17 | else 18 | return number + regressiveSum(number -1); 19 | 20 | } 21 | 22 | private static String stringReverse(String word, int position) { 23 | if (position < 0) 24 | return ""; 25 | else 26 | return word.charAt(position) + stringReverse(word,position-1); 27 | 28 | } 29 | 30 | private static int counting(int number) { 31 | System.out.printf("%d ", number); 32 | 33 | if (number <= 1) 34 | return 1; 35 | else 36 | return counting(number - 1); 37 | 38 | } 39 | 40 | public static void main(String[] args) { 41 | int factorial = 3; 42 | System.out.printf("Fatorial de %d -> %d%n", factorial, factorialCalc(factorial)); 43 | 44 | int regressiveNumber = 3; 45 | System.out.printf("Soma regressiva de %d -> %d%n", regressiveNumber,regressiveSum(regressiveNumber)); 46 | 47 | String word = "maratona"; 48 | System.out.printf("String %s, reverse -> %s%n", word, stringReverse(word,word.length()-1)); 49 | 50 | int countingNumber = 5; 51 | System.out.printf("Counting %d -> %d%n", countingNumber, counting(countingNumber)); 52 | 53 | 54 | 55 | 56 | } 57 | } 58 | -------------------------------------------------------------------------------- /CONTRIBUTING.md: -------------------------------------------------------------------------------- 1 | Como contribuir com esse repositório? 2 | 3 | Consulte as issues abertas , responda a issue dizendo que gostaria de contribuir e iremos atribuir ela a você, não desenvolva o conteúdo antes de se associar a issue, pois assim garantimos que duas pessoas não estão na mesma issue 4 | 5 | Com quais assuntos posso contribuir? 6 | 7 | Principais tópicos: 8 | - Conceitos de OO, 9 | - Sintaxe básica da linguagem 10 | - Principais APIs e bibliotecas do Java 11 | - Exercicios 12 | - e muito mais.. 13 | 14 | Como envio um conteúdo para esse guia? 15 | 16 | Após ter desenvolvido o conteúdo que resolva a issue basta envia a pull request sinalizando qual issue ela resolve e comentar na issue qual pull request você enviou, iremos analisar ela e uma vez estando tudo certo ela será mergeada e contabilizada para a hacktobefest. -------------------------------------------------------------------------------- /Design Patterns/Abstract Factory Pattern/README.md: -------------------------------------------------------------------------------- 1 | ABSTRACT FACTORY 2 | 3 | Definição: 4 | Prover uma interface para criar famílias de objetos relacionados ou dependentes sem especificar suas classes concretas. 5 | Responsável por criar um conjunto de objetos dentro do mesmo contexto. 6 | 7 | Projeto: 8 | O exemplo refere-se a um certificado (Certificate) e empacotamento (Packing), que serão aplicados em um aparelho celular. 9 | Este celular pode ser produzido no Brazil ou Estados Unidos, devendo seguir as regras do respectivo país (CountryRulesAbstractFactory). 10 | Para testar o pattern, foi desenvolvida a classe AbstractFactoryTest. 11 | 12 | Informações adicionais: 13 | Este exemplo faz parte do curso Padrões de Projeto em JAVA na Prática - Udemy - Cod3r 14 | Fonte adicional para estudo de patterns: 15 | https://refactoring.guru/design-patterns/abstract-factory -------------------------------------------------------------------------------- /Design Patterns/Abstract Factory Pattern/com/abstractfactory/java/factory/BrazilianRulesAbstractFactory.java: -------------------------------------------------------------------------------- 1 | package com.abstractfactory.java.factory; 2 | 3 | 4 | import com.abstractfactory.java.model.certificate.BrazilianCertificate; 5 | import com.abstractfactory.java.model.certificate.Certificate; 6 | import com.abstractfactory.java.model.packing.BrazilianPacking; 7 | import com.abstractfactory.java.model.packing.Packing; 8 | 9 | public class BrazilianRulesAbstractFactory implements CountryRulesAbstractFactory { 10 | 11 | public Certificate getCertificates() { 12 | return new BrazilianCertificate(); 13 | } 14 | 15 | public Packing getPacking() { 16 | return new BrazilianPacking(); 17 | } 18 | 19 | } 20 | -------------------------------------------------------------------------------- /Design Patterns/Abstract Factory Pattern/com/abstractfactory/java/factory/CountryRulesAbstractFactory.java: -------------------------------------------------------------------------------- 1 | package com.abstractfactory.java.factory; 2 | 3 | 4 | import com.abstractfactory.java.model.certificate.Certificate; 5 | import com.abstractfactory.java.model.packing.Packing; 6 | 7 | public interface CountryRulesAbstractFactory { 8 | Certificate getCertificates(); 9 | 10 | Packing getPacking(); 11 | } 12 | -------------------------------------------------------------------------------- /Design Patterns/Abstract Factory Pattern/com/abstractfactory/java/factory/USRulesAbstractFactory.java: -------------------------------------------------------------------------------- 1 | package com.abstractfactory.java.factory; 2 | 3 | import com.abstractfactory.java.model.certificate.Certificate; 4 | import com.abstractfactory.java.model.certificate.USCertificate; 5 | import com.abstractfactory.java.model.packing.Packing; 6 | import com.abstractfactory.java.model.packing.USPacking; 7 | 8 | public class USRulesAbstractFactory implements CountryRulesAbstractFactory { 9 | 10 | public Certificate getCertificates() { 11 | return new USCertificate(); 12 | } 13 | 14 | public Packing getPacking() { 15 | return new USPacking(); 16 | } 17 | 18 | } 19 | -------------------------------------------------------------------------------- /Design Patterns/Abstract Factory Pattern/com/abstractfactory/java/model/certificate/BrazilianCertificate.java: -------------------------------------------------------------------------------- 1 | package com.abstractfactory.java.model.certificate; 2 | 3 | public class BrazilianCertificate implements Certificate { 4 | @Override 5 | public String applyCertification() { 6 | return "\t- Calibrating Brazil rules\n\t- Applying Anatel's Stamp"; 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /Design Patterns/Abstract Factory Pattern/com/abstractfactory/java/model/certificate/Certificate.java: -------------------------------------------------------------------------------- 1 | package com.abstractfactory.java.model.certificate; 2 | 3 | public interface Certificate { 4 | String applyCertification(); 5 | } 6 | -------------------------------------------------------------------------------- /Design Patterns/Abstract Factory Pattern/com/abstractfactory/java/model/certificate/USCertificate.java: -------------------------------------------------------------------------------- 1 | package com.abstractfactory.java.model.certificate; 2 | 3 | public class USCertificate implements Certificate { 4 | 5 | public String applyCertification() { 6 | return "\t- Calibrating US rules"; 7 | } 8 | 9 | } 10 | -------------------------------------------------------------------------------- /Design Patterns/Abstract Factory Pattern/com/abstractfactory/java/model/packing/BrazilianPacking.java: -------------------------------------------------------------------------------- 1 | package com.abstractfactory.java.model.packing; 2 | 3 | public class BrazilianPacking implements Packing { 4 | 5 | @Override 6 | public String pack() { 7 | 8 | return "\t- Packing in Brazil"; 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /Design Patterns/Abstract Factory Pattern/com/abstractfactory/java/model/packing/Packing.java: -------------------------------------------------------------------------------- 1 | package com.abstractfactory.java.model.packing; 2 | 3 | public interface Packing { 4 | String pack(); 5 | } 6 | -------------------------------------------------------------------------------- /Design Patterns/Abstract Factory Pattern/com/abstractfactory/java/model/packing/USPacking.java: -------------------------------------------------------------------------------- 1 | package com.abstractfactory.java.model.packing; 2 | 3 | public class USPacking implements Packing { 4 | 5 | public String pack() { 6 | return "\t- Packing in US"; 7 | } 8 | 9 | } 10 | -------------------------------------------------------------------------------- /Design Patterns/Abstract Factory Pattern/com/abstractfactory/java/test/AbstractFactoryTest.java: -------------------------------------------------------------------------------- 1 | package com.abstractfactory.java.test; 2 | 3 | import static org.junit.jupiter.api.Assertions.assertTrue; 4 | 5 | import com.abstractfactory.java.factory.BrazilianRulesAbstractFactory; 6 | import com.abstractfactory.java.factory.CountryRulesAbstractFactory; 7 | import com.abstractfactory.java.factory.USRulesAbstractFactory; 8 | import org.junit.jupiter.api.Test; 9 | 10 | public class AbstractFactoryTest { 11 | 12 | @Test 13 | void whenInstantiateBrazilRulesReturnCertificateAndPackInBrazil(){ 14 | String match = "Brazil"; 15 | CountryRulesAbstractFactory rules = new BrazilianRulesAbstractFactory(); 16 | assertTrue(rules.getCertificates().applyCertification().contains(match)); 17 | assertTrue(rules.getPacking().pack().contains(match)); 18 | 19 | } 20 | 21 | @Test 22 | void whenInstantiateUSRulesReturnCertificateAndPackInUS(){ 23 | String match = "US"; 24 | CountryRulesAbstractFactory rules = new USRulesAbstractFactory(); 25 | assertTrue(rules.getCertificates().applyCertification().contains(match)); 26 | assertTrue(rules.getPacking().pack().contains(match)); 27 | 28 | } 29 | 30 | } 31 | -------------------------------------------------------------------------------- /Design Patterns/Adapter/README.md: -------------------------------------------------------------------------------- 1 | # Adapter Pattern 2 | O padrão **Adapter** é um padrão de projeto estrutural, 3 | que tem como objetivo a capacidade de permitir que classes 4 | trabalhem juntas quando não poderiam por conta de 5 | incompatibilidade de interfaces. 6 | 7 | ## Motivação 8 | Às vezes, uma classe projetada para reutilização não 9 | é reutilizável apenas porque a interface não corresponde 10 | à interface específica do domínio que um aplicativo exige. 11 | 12 | Este é um dos padrões mais importantes para gerenciar 13 | a complexidade da base de código e trabalhar com sistemas 14 | legados. Além disso, permite reutilizar bibliotecas de 15 | terceiros sem fazer alterações na aplicação e sempre 16 | podendo alterar as implementações com facilidade. 17 | 18 | Esse padrão possui duas abordagens: adaptador de classe e 19 | adaptador de objeto. 20 | 21 | ### Adaptador de Classe 22 | Essa implementação utiliza herança: o adaptador herda 23 | interfaces de ambos os objetos ao mesmo tempo. Observe que 24 | essa abordagem só pode ser implementada em linguagens de 25 | programação que suportam herança múltipla, tais como C++. 26 | 27 | Aqui, em vez de ter um objeto adaptado dentro do adaptador 28 | (composição) para fazer uso de sua funcionalidade, o 29 | adaptador herda o adaptado. 30 | 31 | ![class-adapter.png](images/class-adapter.png) 32 | 33 | ### Adaptador de Objeto 34 | Essa implementação usa o princípio de composição do objeto: 35 | o adaptador implementa a interface de um objeto e encobre 36 | o outro. O adaptador contém uma instância do adaptado. 37 | 38 | ![obj-adaptor.png](images/obj-adaptor.png) 39 | 40 | Algumas vantagens e desvantagens dessa abordagem são: 41 | 42 | | Vantagens | Desvantagens | 43 | |-----------------------------------------------------------------------------|----------------------------------| 44 | | Dados de lógica separados de dados de negócio | Aumenta a complexidade do código | 45 | | Facilidade de introdução de novos tipos de adaptadores sem quebrar o código | | | | 46 | 47 | ## Exemplo 48 | 49 | ![jack-to-usbc.png](images/jack-to-usbc.png) 50 | 51 | Eu, como boa amante de música, estou sempre com um fone de ouvido pluggado por aí. 52 | 53 | Suponha que você está voltando pra casa, em São Paulo, de metrô pela estação Sé, às 18:30 de uma terça-feira apenas 54 | com um fone de ouvido com um conector padrão Jack 3.5mm e um celular com entrada USB. Então, qual é o problema? 55 | De uns anos pra cá, foi crescente [a mudança dos conectores do padrão Jack para o USB tipo C](https://www.theverge.com/2016/8/17/12519936/intel-usb-type-c-headphone-jack-replacement-idf-2016). 56 | Dessa forma, dispositivos mais antigos não sabem interagir diretamente com os novos dispositivos. 57 | **Eles não compartilham uma interface comum.** 58 | 59 | O celular possui uma porta USB, mas não podemos inserir o conector do fone nela, pois possuem [formas e especificações](https://www.usb.org/sites/default/files/USB%20Type-C%20Spec%20R2.0%20-%20August%202019.pdf) 60 | diferentes, impedindo a reprodução do áudio. 61 | Um adaptador de interfaces resolve esse problema. Afinal, ele possui um cabo USB! Ao contrário do conector Jack, 62 | o adaptador pode ser conectado ao computador. 63 | **Eles compartilham uma interface comum com o computador: USB.** 64 | 65 | ![adapter.png](images/adapter.png) 66 | 67 | Na prática: 68 | 69 | #### USB 70 | Esta é a nossa interface USB com apenas um método de conexão via USB. 71 | 72 | #### JackConnector 73 | Esta é a nossa classe que representa o conector padrão Jack. Infelizmente, não 74 | implementa a interface USB. O conector não pode ser inserido na porta USB. 75 | 76 | #### UsbConnector 77 | Esta é a nossa classe que representa o conector padrão Usb. Esse conector, desde que seja compativel com 78 | o tipo da porta de entrada, pode ser inserido na porta USB. 79 | 80 | #### JackToUsbAdapter 81 | Esse é o nosso cabo adaptador. A classe que está sendo adaptada (JackConnector) passa a ser um dos campos do adaptador. 82 | Quando pluggamos um conector do padrão Jack em cabo desse tipo na vida real, ele também passa a fazer parte dele 83 | (um cabo só). Ao contrário do plug do padrão descontinuado, o adaptador compartilha uma interface com o celular. 84 | Possui cabo USB, ou seja, pode ser conectado a outros dispositivos via USB. É por isso que nossa classe 85 | JackToUsbAdapter implementa a interface USB. 86 | 87 | Na verdade, o adaptador não faz nada sozinho. Um cabo adaptador não possui nenhuma funcionalidade independente. 88 | Sua função é apenas conectar o celular e o fone de ouvido para permitir que o conector (e o fone de ouvido) 89 | faça seu trabalho – reproduzir a Crazy in Love no volume em 90%! 90 | 91 | A estrutura do projeto é a seguinte: 92 | ``` 93 | . 94 | ├── ... 95 | ├── com.adapter.java # Pacote destinado ao exemplo 96 | │ ├── JackConnector 97 | │ ├── JackToUsbAdapter 98 | │ ├── Main # Programa cliente para simular o exemplo 99 | │ ├── Usb 100 | │ └── UsbConnector 101 | ├── images # pasta para armazenamento das imagens 102 | ├── README.md # Documentação do exemplo 103 | └── ... 104 | 105 | ``` 106 | 107 | Uma forma de utilizar o padrão é como no exemplo abaixo: 108 | 109 | ``` java 110 | JackConnector jackConnector = new JackConnector(); 111 | Usb jackConnectorAdapter = new JackToUsbAdapter(jackConnector); 112 | jackConnectorAdapter.connectWithUsbCable(); 113 | ``` 114 | 115 | ## Casos de Uso 116 | 117 | Antigos tipos de coleções (Vector, Stack, Hashtable e 118 | alguns outros) no Java implementam um método elements(), 119 | que retorna uma [Enumeration](https://docs.oracle.com/javase/8/docs/api/java/util/Enumeration.html), interface que permite 120 | percorrer os elementos de uma coleção sem saber as 121 | especificidades de como são gerenciadas. 122 | 123 | Quando a Sun lançou sua classe mais recente, 124 | a [Collections](https://docs.oracle.com/javase/8/docs/technotes/guides/collections/overview.html), eles começaram a usar uma Interface do 125 | Iterator que, como Enumeration, permite que você itere 126 | através de um conjunto de itens em uma coleção, mas 127 | também adiciona a capacidade de remover itens. 128 | 129 | Assim, um Adapter para converter código legado em algo 130 | mais moderno, pode ser útil. 131 | 132 | ## Fonte 133 | - [Head First Design Patterns](https://www.amazon.com.br/Cabe%C3%A7a-Padr%C3%B5es-Projetos-Eric-Freeman/dp/8576081741) 134 | - [Design Patterns: Elements of Reusable Object-Oriented Software](https://www.amazon.com/Design-Patterns-Object-Oriented-Addison-Wesley-Professional-ebook/dp/B000SEIBB8) 135 | - [Refactoring Guru](https://refactoring.guru/design-patterns/adapter) 136 | - [Baeldung](https://www.baeldung.com/java-adapter-pattern) 137 | - [Java Documentation](https://docs.oracle.com/en/java/) -------------------------------------------------------------------------------- /Design Patterns/Adapter/com.adapter.java/JackConnector.java: -------------------------------------------------------------------------------- 1 | public class JackConnector { 2 | 3 | public void insert() { 4 | System.out.println("Jack 3.5mm has successfully plugged!"); 5 | } 6 | 7 | public void transferSound() { 8 | System.out.println(""" 9 | *Playing music with jack connector* 10 | 01:13 ━━⬤───────── 04:05 11 | """); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /Design Patterns/Adapter/com.adapter.java/JackToUsbAdapter.java: -------------------------------------------------------------------------------- 1 | public class JackToUsbAdapter implements Usb { 2 | 3 | private JackConnector jackConnector; 4 | 5 | public JackToUsbAdapter(JackConnector jackConnector) { 6 | this.jackConnector = jackConnector; 7 | } 8 | 9 | @Override 10 | public void connectWithUsbCable() { 11 | jackConnector.insert(); 12 | jackConnector.transferSound(); 13 | } 14 | 15 | } 16 | -------------------------------------------------------------------------------- /Design Patterns/Adapter/com.adapter.java/Main.java: -------------------------------------------------------------------------------- 1 | public class Main { 2 | public static void main(String[] args) { 3 | UsbConnector usbConnector = new UsbConnector(); 4 | JackConnector jackConnector = new JackConnector(); 5 | 6 | usbConnector.connectWithUsbCable(); 7 | 8 | //jackConnector.connectWithUsbCable(); won't compile 9 | System.out.println(""" 10 | Wrong type connector. 11 | Jack connectors are round and have a different type of plug. Use some adapter to usb ports. 12 | 13 | *Pause music* 14 | 01:12 ━━⬤───────── 04:05 15 | """); 16 | 17 | Usb jackConnectorAdapter = new JackToUsbAdapter(jackConnector); 18 | jackConnectorAdapter.connectWithUsbCable(); 19 | } 20 | } -------------------------------------------------------------------------------- /Design Patterns/Adapter/com.adapter.java/Usb.java: -------------------------------------------------------------------------------- 1 | public interface Usb { 2 | void connectWithUsbCable(); 3 | } 4 | -------------------------------------------------------------------------------- /Design Patterns/Adapter/com.adapter.java/UsbConnector.java: -------------------------------------------------------------------------------- 1 | public class UsbConnector implements Usb { 2 | 3 | public void insert() { 4 | System.out.println("Usb connector has successfully plugged!"); 5 | } 6 | 7 | public void transferSound() { 8 | System.out.println(""" 9 | *Playing music with usb connector* 10 | 00:01 ⬤─────────── 04:05 11 | """); 12 | } 13 | 14 | public void connectWithUsbCable() { 15 | this.insert(); 16 | this.transferSound(); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /Design Patterns/Adapter/images/adapter.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/devs-javagirl/java-trainning/913aa1d4402d4c1ec18a06eba387019992d244d6/Design Patterns/Adapter/images/adapter.png -------------------------------------------------------------------------------- /Design Patterns/Adapter/images/class-adapter.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/devs-javagirl/java-trainning/913aa1d4402d4c1ec18a06eba387019992d244d6/Design Patterns/Adapter/images/class-adapter.png -------------------------------------------------------------------------------- /Design Patterns/Adapter/images/jack-to-usbc.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/devs-javagirl/java-trainning/913aa1d4402d4c1ec18a06eba387019992d244d6/Design Patterns/Adapter/images/jack-to-usbc.png -------------------------------------------------------------------------------- /Design Patterns/Adapter/images/obj-adaptor.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/devs-javagirl/java-trainning/913aa1d4402d4c1ec18a06eba387019992d244d6/Design Patterns/Adapter/images/obj-adaptor.png -------------------------------------------------------------------------------- /Design Patterns/Builder/README.md: -------------------------------------------------------------------------------- 1 | # Builder Pattern 2 | O padrão **Builder**, que é um dos _23 padrões de design do 3 | Gang of Four (GoF)_, é um padrão de criação 4 | que permite construir objetos complexos passo a passo. 5 | Além de encapsular a construção, é capaz de produzir diferentes 6 | tipos e representações de um item utilizando o mesmo código. 7 | 8 | ## Motivação 9 | O padrão Builder foi introduzido para resolver alguns 10 | dos problemas de outros padrões de design semelhantes, como 11 | o **Factory** e **Abstract Factory**. 12 | 13 | Imagine uma classe que possua muitos atributos, sendo eles, 14 | variados entre opcionais e obrigatórios. No momento de criação 15 | de uma instância, os valores para os atributos obrigatórios sempre 16 | precisarão existir. Entretanto, a variação desses objetos com os campos 17 | opcionais pode ser enorme. 18 | 19 | Para solucionar e adequar os construtores aos casos conforme 20 | a necessidade, tradicionalmente, é usado o conceito de 21 | **construtor telescópico**: onde o primeiro construtor 22 | ocupa apenas os campos obrigatórios, para cada campo opcional, 23 | existe um construtor adicional que utiliza os campos obrigatórios 24 | **mais** os campos opcionais. 25 | 26 | ``` java 27 | class Pizza { 28 | public Pizza (Size size, Dough dought) { ... } 29 | public Pizza (Size size, Dough dought, Sauce sauce) { ... } 30 | public Pizza (Size size, Dough dought, Sauce sauce, List toppings) { ... } 31 | // ... 32 | } 33 | ``` 34 | 35 | O maior problema dessa solução, se dá pela manutenção desse 36 | código e leitura a longo prazo, pois os construtores tendem 37 | a aumentar conforme aumenta o número de atributos da classe. 38 | 39 | Outra possibilidade, é a utilização do **padrão JavaBeans**, ou 40 | seja, a criação de um construtor sem parâmetros e setters 41 | para inicialização dos valores necessários. 42 | 43 | ```java 44 | ... 45 | Pizza pizza = new Pizza(); 46 | pizza.setSize(SMALL); 47 | pizza.setSauce(RED); 48 | ... 49 | ``` 50 | 51 | Uma desvantagem relacionada é que o padrão JavaBeans 52 | exclui a possibilidade de tornar uma classe imutável e 53 | requer esforço adicional por parte do programador para 54 | garantir a segurança da thread. Se eu esqueço um dos parâmetros 55 | obrigatórios, como o tamanho, por exemplo, posso ter problemas 56 | futuros na utilização desse objeto. 57 | 58 | Com o objetivo de resolver esses problemas, surgiu o padrão 59 | Builder. 60 | 61 | Algumas vantagens e desvantagens dessa abordagem são: 62 | 63 | 64 | | Vantagens | Desvantagens | 65 | |------------------------------------------------------------|-----------------------------------------------------------------------| 66 | | Encapsulamento bem definido | Sempre é necessário criar um builder para a instanciação de um objeto | 67 | | Flexibilidade e possibilidade de customização de um objeto | Mais verboso que os demais métodos | 68 | | Imutabilidade | | 69 | | Segurança e integridade dos dados | | 70 | | Reusabilidade de código | | 71 | | Maior controle no processo de construção de um objeto | | 72 | 73 | ## Exemplo 74 | 75 | No nosso caso de uso, temos a construção de uma `Pizza`. Temos 76 | algumas possíveis variações aqui: Com ou sem azeitonas, 77 | tipos diferentes de tamanho, tipos de massa, possibilidades 78 | de molhos, quantidades e tipos de toppings 79 | (ou sem, se você tiver gostos peculiares). 80 | 81 | A estrutura do projeto é a seguinte: 82 | ``` 83 | . 84 | ├── ... 85 | ├── com.builder.java # Pacote destinado ao exemplo 86 | │ ├── Dought # Enum de tipos de Massa 87 | │ ├── Pizza # Classe da construção da Pizza 88 | │ ├── Sauce # Enum de tipos de Molho 89 | │ ├── Size # Enum de tipos de Tamanho 90 | │ └── Topping # Enum de tipos de Toppings 91 | ├── README.md # Documentação do exemplo 92 | └── ... 93 | 94 | ``` 95 | 96 | 97 | Uma forma de utilizar o padrão para a construção 98 | dessas Pizzas é como no exemplo abaixo: 99 | 100 | ``` java 101 | Pizza sausagePizza = new PizzaBuilder(Size.SMALL, Dought.WHITE_WHOLE_WHEAT) 102 | .withSauce(Sauce.RED) 103 | .withTopping(Topping.CHEESE, Topping.SAUSAGE, Topping.ONION) 104 | .withOlive() 105 | .build(); 106 | 107 | Pizza cheesePizza = new PizzaBuilder(Size.LARGE, Dought.WHITE_WHOLE_WHEAT) 108 | .withSauce(Sauce.WHITE) 109 | .withTopping(Topping.CHEESE) 110 | .build(); 111 | ``` 112 | 113 | ## Casos de Uso 114 | - [java.lang.StringBuilder](https://docs.oracle.com/javase/8/docs/api/java/lang/StringBuilder.html) 115 | - [java.lang.StringBuffer](https://docs.oracle.com/javase/8/docs/api/java/lang/StringBuffer.html#append-boolean-) 116 | 117 | ## Para saber mais 118 | Os exemplos mostrados aqui, foram inspirados na versão do 119 | padrão Builder de Joshua Bloch, autor do livro Effective Java. 120 | Essa versão alternativa, é uma variação da versão original 121 | apresentado pelo Gang of Four, que contém outros 122 | elementos, entre eles, um Director, responsável 123 | por notificar o construtor sempre que uma parte do produto 124 | deve ser construída. 125 | 126 | Caso tenha curiosidade, o livro **Design Patterns: Elements of Reusable Object-Oriented Software**, 127 | o site do Refactor Guru e livro Head First Design Patterns, 128 | todos presentes na seção **Fonte**, abordam o padrão 129 | em sua forma original. 130 | 131 | 132 | ## Fonte 133 | - [Design Patterns: Elements of Reusable Object-Oriented Software](https://www.amazon.com/Design-Patterns-Object-Oriented-Addison-Wesley-Professional-ebook/dp/B000SEIBB8) 134 | - [Refactoring Guru](https://refactoring.guru/design-patterns/builder) 135 | - [Head First Design Patterns](https://www.amazon.com.br/Cabe%C3%A7a-Padr%C3%B5es-Projetos-Eric-Freeman/dp/8576081741) 136 | - [Effective Java](https://www.amazon.com.br/Effective-Java-English-Joshua-Bloch-ebook/dp/B078H61SCH/ref=sr_1_1?__mk_pt_BR=%C3%85M%C3%85%C5%BD%C3%95%C3%91&crid=2VO8TOTTXMH5Y&keywords=effective+java&qid=1696547006&s=books&sprefix=effective+java%2Cstripbooks%2C148&sr=1-1) 137 | - [DigitalOcean](https://www.digitalocean.com/community/tutorials/builder-design-pattern-in-java) 138 | - [JournalDev: Builder Design Pattern](https://www.youtube.com/watch?v=D5NK5qMM14g&ab_channel=JournalDevITServices) 139 | - [Exploring Joshua Bloch’s Builder design pattern in Java](https://blogs.oracle.com/javamagazine/post/exploring-joshua-blochs-builder-design-pattern-in-java) 140 | 141 | -------------------------------------------------------------------------------- /Design Patterns/Builder/com.builder.java/Dought.java: -------------------------------------------------------------------------------- 1 | enum Dought { 2 | WHOLE_WHEAT, WHITE_WHOLE_WHEAT; 3 | } 4 | -------------------------------------------------------------------------------- /Design Patterns/Builder/com.builder.java/Pizza.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | 3 | import static java.util.Arrays.stream; 4 | 5 | public class Pizza { 6 | 7 | private final Size size; 8 | private final Dought dought; 9 | private final Sauce sauce; 10 | private final Set toppings; 11 | private boolean olive; 12 | 13 | public static class PizzaBuilder { 14 | private final Size size; 15 | private final Dought dought; 16 | private Sauce sauce; 17 | private EnumSet toppings = EnumSet.noneOf(Topping.class); 18 | private boolean olive; 19 | 20 | public PizzaBuilder(Size size, Dought dought) { 21 | this.size = size; 22 | this.dought = dought; 23 | } 24 | 25 | public PizzaBuilder withTopping(Topping... topping) { 26 | toppings.addAll(stream(topping).toList()); 27 | return this; 28 | } 29 | 30 | public PizzaBuilder withSauce(Sauce sauce) { 31 | this.sauce = sauce; 32 | return this; 33 | } 34 | 35 | public PizzaBuilder withOlive() { 36 | this.olive = true; 37 | return this; 38 | } 39 | 40 | public Pizza build() { 41 | return new Pizza(this); 42 | } 43 | 44 | 45 | } 46 | private Pizza(PizzaBuilder builder) { 47 | this.size = builder.size; 48 | this.dought = builder.dought; 49 | this.sauce = builder.sauce; 50 | this.toppings = builder.toppings; 51 | this.olive = builder.olive; 52 | } 53 | } -------------------------------------------------------------------------------- /Design Patterns/Builder/com.builder.java/Sauce.java: -------------------------------------------------------------------------------- 1 | enum Sauce { 2 | WHITE, RED; 3 | } 4 | -------------------------------------------------------------------------------- /Design Patterns/Builder/com.builder.java/Size.java: -------------------------------------------------------------------------------- 1 | public enum Size { 2 | SMALL, MEDIUM, LARGE; 3 | } 4 | -------------------------------------------------------------------------------- /Design Patterns/Builder/com.builder.java/Topping.java: -------------------------------------------------------------------------------- 1 | enum Topping { 2 | HAM, MUSHROOM, CORN, ONION, SAUSAGE, CHEESE; 3 | } 4 | -------------------------------------------------------------------------------- /Design Patterns/Chain of Responsability Pattern/com/chainresponsability/java/README.md: -------------------------------------------------------------------------------- 1 |

CHAIN OF RESPONSABILITY

2 | 3 |

OBJETIVO

4 | Evita acoplar o remetente de uma requisição ao seu destinatário ao dar a mais de um objeto a chance de servir a requisição.

5 | Compõe os objetos em cascata e passa a requisição da corrente até que um objeto a sirva.

6 | 7 | PROBLEMA

8 | Imagine que você está trabalhando em um sistema de encomendas online. Você quer restringir o acesso ao sistema para que apenas usuários autenticados possam criar pedidos. E também somente usuários que tem permissões administrativas devem ter acesso total a todos os pedidos.

9 | Também é um requisito do sistema que a senha seja criptografada, portanto você precisa implementar o código para descriptografar a senha antes de validá-la.

10 | Essas checagens devem ser feitas sequencialmente e, caso a aplicação não consiga autenticar o usuário, não há necessidade de continuar o processo.

11 | Caso sejam necessárias mais validações, o código se torna inchado e complexo, podendo afetar as regras já existentes.

12 | 13 | SOLUÇÃO

14 | Como muitos outros padrões de projeto comportamental, o Chain of Responsibility se baseia em transformar certos comportamentos em objetos solitários chamados handlers. Cada checagem devem ser extraída para sua própria classe com um único método que faz a checagem. O pedido, junto com seus dados, é passado para esse método como um argumento.

15 | O padrão sugere que você ligue esses handlers em uma corrente. Cada handler ligado tem um campo para armazenar uma referência ao próximo handler da corrente. Além de processar o pedido, handlers o passam adiante na corrente. O pedido viaja através da corrente até que todos os handlers tiveram uma chance de processá-lo.

16 | E aqui está a melhor parte: um handler pode decidir não passar o pedido adiante na corrente e efetivamente parar qualquer futuro processamento.

17 | 18 | BENEFÍCIOS

19 | Você pode controlar a ordem de tratamento dos pedidos.

20 | Princípio de responsabilidade única. Você pode desacoplar classes que invocam operações de classes que realizam operações.

21 | Princípio aberto/fechado. Você pode introduzir novos handlers na aplicação sem quebrar o código cliente existente.

22 | 23 | DESVANTAGENS

24 | Alguns pedidos podem acabar sem tratamento. 25 | É importante avaliar a ordem em que a corrente de handlers é criada, para que nenhum deixe deles deixe de ser processado. 26 | 27 | EXEMPLO IMPLEMENTADO

28 | No exemplo foi implementado uma livraria que concede descontos em seus pedidos.

29 | Caso o cliente compre 3 ou mais livros, recebe um desconto de 5%.

30 | Caso o pedido com desconto seja maior ou igual a R$ 100, recebe um desconto de 5%.

31 | Caso o pedido seja pago em PIX, também recebe um desconto de 5%.

32 | É importante notar que a ordem em que é criada a corrente de desconto, faz diferença neste processo. Caso a segunda validação anteceda a primeira, dependendo do valor do pedido, o cliente poderia obter mais descontos. 33 | 34 | REFERÊNCIAS

35 | https://diogomoreira.gitbook.io/padroes-de-projeto/padroes-gof-comportamentais/padrao-chain-of-responsibility 36 | Curso na Udemy: Padrões de Projeto em JAVA na Prática - Cod3r 37 | -------------------------------------------------------------------------------- /Design Patterns/Chain of Responsability Pattern/com/chainresponsability/java/enumeration/DiscountType.java: -------------------------------------------------------------------------------- 1 | package com.chainresponsability.java.enumeration; 2 | 3 | public enum DiscountType { 4 | PACKAGE_THREE_BOOKS("5% de desconto na compra de 3 livros", 5.0, 3.0), 5 | PIX_PAYMENT("Desconto de 5% para pagamentos com PIX", 5.0, 0.0), 6 | PREMIUM_CUSTOMER("Desconto de 5% para compras acima de 100 reais", 5.0, 100.0); 7 | 8 | private final String discountRule; 9 | private final double discountPercentage; 10 | private final double amount; 11 | 12 | DiscountType(String discountRule, double discountPercentage, double amount){ 13 | this.discountRule = discountRule; 14 | this.discountPercentage = discountPercentage; 15 | this.amount = amount; 16 | } 17 | 18 | public String getDiscountRule() { 19 | return discountRule; 20 | } 21 | 22 | public double getDiscountPercentage() { 23 | return discountPercentage; 24 | } 25 | 26 | public double getAmount() { 27 | return amount; 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /Design Patterns/Chain of Responsability Pattern/com/chainresponsability/java/enumeration/PaymentType.java: -------------------------------------------------------------------------------- 1 | package com.chainresponsability.java.enumeration; 2 | 3 | public enum PaymentType { 4 | PIX, 5 | MONEY, 6 | CREDIT_CARD 7 | } 8 | -------------------------------------------------------------------------------- /Design Patterns/Chain of Responsability Pattern/com/chainresponsability/java/model/Order.java: -------------------------------------------------------------------------------- 1 | package com.chainresponsability.java.model; 2 | 3 | import com.chainresponsability.java.enumeration.DiscountType; 4 | import com.chainresponsability.java.enumeration.PaymentType; 5 | import java.util.ArrayList; 6 | import java.util.Calendar; 7 | import java.util.List; 8 | 9 | public class Order { 10 | private Calendar date; 11 | private double total; 12 | private double totalWithDiscount; 13 | private PaymentType paymentType; 14 | private List orderItems = new ArrayList<>(); 15 | private List discounts = new ArrayList<>(); 16 | 17 | public Calendar getDate() { 18 | return date; 19 | } 20 | 21 | public void setDate(Calendar date) { 22 | this.date = date; 23 | } 24 | 25 | public double getTotal() { 26 | return orderItems.stream() 27 | .map(item -> item.getPrice()) 28 | .reduce(0.0, Double::sum); 29 | } 30 | 31 | public void setTotal(double total) { 32 | this.total = total; 33 | } 34 | 35 | public double getTotalWithDiscount() { 36 | double total = getTotal(); 37 | 38 | double totalDiscount = discounts.stream() 39 | .map(item -> (item.getDiscountPercentage()/100) * total) 40 | .reduce(0.0, Double::sum); 41 | 42 | return total - totalDiscount; 43 | } 44 | 45 | public void setTotalWithDiscount(double totalWithDiscount) { 46 | this.totalWithDiscount = totalWithDiscount; 47 | } 48 | 49 | public PaymentType getPaymentType() { 50 | return paymentType; 51 | } 52 | 53 | public void setPaymentType(PaymentType paymentType) { 54 | this.paymentType = paymentType; 55 | } 56 | 57 | public List getOrderItens() { 58 | return orderItems; 59 | } 60 | 61 | public void setOrderItens(List orderItens) { 62 | this.orderItems = orderItens; 63 | } 64 | 65 | public List getDiscounts() { 66 | return discounts; 67 | } 68 | 69 | public void setDiscounts(List discounts) { 70 | this.discounts = discounts; 71 | } 72 | } 73 | -------------------------------------------------------------------------------- /Design Patterns/Chain of Responsability Pattern/com/chainresponsability/java/model/OrderItem.java: -------------------------------------------------------------------------------- 1 | package com.chainresponsability.java.model; 2 | 3 | public class OrderItem { 4 | private String description; 5 | private double price; 6 | 7 | public OrderItem(String description, double price) { 8 | this.description = description; 9 | this.price = price; 10 | } 11 | 12 | public String getDescription() { 13 | return description; 14 | } 15 | 16 | public void setDescription(String description) { 17 | this.description = description; 18 | } 19 | 20 | public double getPrice() { 21 | return price; 22 | } 23 | 24 | public void setPrice(double price) { 25 | this.price = price; 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /Design Patterns/Chain of Responsability Pattern/com/chainresponsability/java/service/discount/Discount.java: -------------------------------------------------------------------------------- 1 | package com.chainresponsability.java.service.discount; 2 | 3 | import com.chainresponsability.java.model.Order; 4 | 5 | public interface Discount { 6 | 7 | void applyDiscount(Order order); 8 | void setNext(Discount discount); 9 | } 10 | -------------------------------------------------------------------------------- /Design Patterns/Chain of Responsability Pattern/com/chainresponsability/java/service/discount/DiscountPackage.java: -------------------------------------------------------------------------------- 1 | package com.chainresponsability.java.service.discount; 2 | 3 | import static com.chainresponsability.java.enumeration.DiscountType.PACKAGE_THREE_BOOKS; 4 | 5 | import com.chainresponsability.java.model.Order; 6 | 7 | public class DiscountPackage implements Discount{ 8 | private Discount nextDiscount; 9 | 10 | @Override 11 | public void applyDiscount(Order order) { 12 | if (order.getOrderItens().size() >= PACKAGE_THREE_BOOKS.getAmount()) 13 | order.getDiscounts().add(PACKAGE_THREE_BOOKS); 14 | 15 | if (nextDiscount != null) 16 | nextDiscount.applyDiscount(order); 17 | } 18 | 19 | @Override 20 | public void setNext(Discount discount) { 21 | nextDiscount = discount; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /Design Patterns/Chain of Responsability Pattern/com/chainresponsability/java/service/discount/DiscountPixPayment.java: -------------------------------------------------------------------------------- 1 | package com.chainresponsability.java.service.discount; 2 | 3 | import com.chainresponsability.java.enumeration.DiscountType; 4 | import com.chainresponsability.java.enumeration.PaymentType; 5 | import com.chainresponsability.java.model.Order; 6 | 7 | public class DiscountPixPayment implements Discount { 8 | Discount nextDiscount; 9 | 10 | @Override 11 | public void applyDiscount(Order order) { 12 | if (order.getPaymentType() == PaymentType.PIX) 13 | order.getDiscounts().add(DiscountType.PIX_PAYMENT); 14 | 15 | if (nextDiscount != null) 16 | nextDiscount.applyDiscount(order); 17 | 18 | } 19 | 20 | @Override 21 | public void setNext(Discount discount) { 22 | nextDiscount = discount; 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /Design Patterns/Chain of Responsability Pattern/com/chainresponsability/java/service/discount/DiscountPremiumCustomer.java: -------------------------------------------------------------------------------- 1 | package com.chainresponsability.java.service.discount; 2 | 3 | import com.chainresponsability.java.enumeration.DiscountType; 4 | import com.chainresponsability.java.model.Order; 5 | 6 | public class DiscountPremiumCustomer implements Discount { 7 | private Discount nextDiscount; 8 | 9 | @Override 10 | public void applyDiscount(Order order) { 11 | if (order.getTotalWithDiscount() >= DiscountType.PREMIUM_CUSTOMER.getAmount()) 12 | order.getDiscounts().add(DiscountType.PREMIUM_CUSTOMER); 13 | 14 | if (nextDiscount != null) 15 | nextDiscount.applyDiscount(order); 16 | } 17 | 18 | @Override 19 | public void setNext(Discount discount) { 20 | nextDiscount = discount; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /Design Patterns/Chain of Responsability Pattern/com/chainresponsability/java/test/ChainResponsabilityTest.java: -------------------------------------------------------------------------------- 1 | package com.chainresponsability.java.test; 2 | 3 | import static org.junit.jupiter.api.Assertions.assertEquals; 4 | 5 | import com.chainresponsability.java.enumeration.DiscountType; 6 | import com.chainresponsability.java.enumeration.PaymentType; 7 | import com.chainresponsability.java.model.Order; 8 | import com.chainresponsability.java.model.OrderItem; 9 | import com.chainresponsability.java.service.discount.Discount; 10 | import com.chainresponsability.java.service.discount.DiscountPackage; 11 | import com.chainresponsability.java.service.discount.DiscountPixPayment; 12 | import com.chainresponsability.java.service.discount.DiscountPremiumCustomer; 13 | import java.util.ArrayList; 14 | import java.util.Calendar; 15 | import java.util.List; 16 | import org.junit.jupiter.api.Test; 17 | 18 | public class ChainResponsabilityTest { 19 | 20 | @Test 21 | void whenOrderWithAllDiscountsThenCalculateTotalPriceWithAllDiscounts(){ 22 | 23 | Order order = getOrderWithThreeBooks(50, 50, 50); 24 | order.setPaymentType(PaymentType.PIX); 25 | setDiscountChain(order); 26 | 27 | printDiscounts(order); 28 | 29 | assertEquals(order.getTotalWithDiscount(), 127.5); 30 | assertEquals(order.getDiscounts().size(), 3); 31 | 32 | } 33 | 34 | @Test 35 | void whenOrderWithTwoBooksWithMoreThan100ThenGivePremiumCustomerDiscount(){ 36 | Order order = getOrderWithTwoBooks(50, 50); 37 | order.setPaymentType(PaymentType.CREDIT_CARD); 38 | setDiscountChain(order); 39 | 40 | printDiscounts(order); 41 | 42 | assertEquals(order.getTotalWithDiscount(), 95); 43 | assertEquals(order.getDiscounts().size(), 1); 44 | 45 | } 46 | 47 | @Test 48 | void whenOrderWithThreeBooksUnder100TotalThenGivePackageDiscount(){ 49 | Order order = getOrderWithThreeBooks(15, 15, 15); 50 | setDiscountChain(order); 51 | 52 | printDiscounts(order); 53 | 54 | assertEquals(order.getTotalWithDiscount(), 42.75); 55 | assertEquals(order.getDiscounts().size(), 1); 56 | 57 | } 58 | 59 | @Test 60 | void whenPaymentWithPixThenGivePixPaymentDiscount(){ 61 | Order order = getOrderWithTwoBooks(20, 20); 62 | order.setPaymentType(PaymentType.PIX); 63 | setDiscountChain(order); 64 | 65 | printDiscounts(order); 66 | 67 | assertEquals(order.getTotalWithDiscount(), 38); 68 | assertEquals(order.getDiscounts().size(), 1); 69 | } 70 | 71 | @Test 72 | void whenOrderHasNoDiscountsThenTotalIsEqualTotalWithDiscount(){ 73 | Order order = getOrderWithTwoBooks(20, 20); 74 | setDiscountChain(order); 75 | 76 | printDiscounts(order); 77 | 78 | assertEquals(order.getTotalWithDiscount(), order.getTotal()); 79 | assertEquals(order.getDiscounts().size(), 0); 80 | } 81 | 82 | private void printDiscounts(Order order){ 83 | order.getDiscounts().stream() 84 | .map(DiscountType::getDiscountRule) 85 | .forEach(System.out::println); 86 | } 87 | 88 | private Order getOrderWithThreeBooks(double firstPrice, double secondPrice, double thirdPrice) { 89 | Order order = new Order(); 90 | order.setDate(Calendar.getInstance()); 91 | 92 | List items = new ArrayList<>(); 93 | items.add(new OrderItem("Lord of the rings", firstPrice)); 94 | items.add(new OrderItem("Narnia", secondPrice)); 95 | items.add(new OrderItem("Harry Potter", thirdPrice)); 96 | order.setOrderItens(items); 97 | 98 | return order; 99 | } 100 | 101 | private Order getOrderWithTwoBooks(double firstPrice, double secondPrice) { 102 | Order order = new Order(); 103 | order.setDate(Calendar.getInstance()); 104 | 105 | List items = new ArrayList<>(); 106 | items.add(new OrderItem("Lord of the rings", firstPrice)); 107 | items.add(new OrderItem("Narnia", secondPrice)); 108 | 109 | order.setOrderItens(items); 110 | 111 | return order; 112 | } 113 | 114 | private void setDiscountChain(Order order){ 115 | Discount discountPackage = new DiscountPackage(); 116 | Discount discountPremiumCustomer = new DiscountPremiumCustomer(); 117 | Discount discountPixPayment = new DiscountPixPayment(); 118 | 119 | discountPackage.setNext(discountPremiumCustomer); 120 | discountPremiumCustomer.setNext(discountPixPayment); 121 | 122 | discountPackage.applyDiscount(order); 123 | 124 | } 125 | } 126 | -------------------------------------------------------------------------------- /Design Patterns/Composite Pattern/com.composite.principal/Content.java: -------------------------------------------------------------------------------- 1 | public abstract class Content { 2 | public void add(Content content) { 3 | throw new UnsupportedOperationException(); 4 | } 5 | 6 | public void remove(Content content) { 7 | throw new UnsupportedOperationException(); 8 | } 9 | 10 | public void display(int level) { 11 | throw new UnsupportedOperationException(); 12 | } 13 | 14 | protected String spaceRepeat(int quantidade) { 15 | return " ".repeat(quantidade); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /Design Patterns/Composite Pattern/com.composite.principal/Lesson.java: -------------------------------------------------------------------------------- 1 | public class Lesson extends Content{ 2 | private String title; 3 | 4 | public Lesson(String title) { 5 | this.title = title; 6 | } 7 | 8 | @Override 9 | public void display(int level) { 10 | System.out.println(spaceRepeat(level) + title); 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /Design Patterns/Composite Pattern/com.composite.principal/Main.java: -------------------------------------------------------------------------------- 1 | public class Main { 2 | public static void main(String[] args) { 3 | 4 | var lesson0 = new Lesson("Lesson 00: Introdução"); 5 | 6 | var lesson1 = new Lesson("Lesson 01: Sintaxe básica"); 7 | var lesson2 = new Lesson("Lesson 02: Variáveis"); 8 | 9 | var module1 = new Module("Module 01: Primeiros passos com Java"); 10 | module1.add(lesson1); 11 | module1.add(lesson2); 12 | 13 | var completeJavaModule = new Module("Course: Aprendendo Java"); 14 | 15 | completeJavaModule.add(lesson0); 16 | completeJavaModule.add(module1); 17 | 18 | completeJavaModule.display(0); 19 | 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /Design Patterns/Composite Pattern/com.composite.principal/Module.java: -------------------------------------------------------------------------------- 1 | import java.util.ArrayList; 2 | import java.util.List; 3 | 4 | public class Module extends Content { 5 | private String name; 6 | 7 | public Module(String name) { 8 | this.name = name; 9 | } 10 | private List contents = new ArrayList<>(); 11 | 12 | @Override 13 | public void add(Content content) { 14 | contents.add(content); 15 | } 16 | 17 | @Override 18 | public void remove(Content content) { 19 | contents.remove(content); 20 | } 21 | 22 | @Override 23 | public void display(int level) { 24 | System.out.println(spaceRepeat(level) + name); 25 | contents.forEach(content -> content.display(level + 2)); 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /Design Patterns/Composite Pattern/com.composite.principal/README.md: -------------------------------------------------------------------------------- 1 | # Composite Pattern 2 | O padrão Composite é um padrão estrutural que permite compor objetos em estruturas de árvore para representar hierarquias parte-todo, ou seja, objetos individuais e grupos de objetos são tratados da mesma maneira dentro de um sistema. 3 | 4 | > 📚 Os padrões de projeto estruturais se concentram em como as classes e objetos são compostos para formar estruturas maiores. Leia mais em [refactoring.guru](https://refactoring.guru/design-patterns/composite). 5 | 6 | ## Estrutura de árvore 7 | De forma simplificada, a estrutura de árvore é composta por dois tipos de objetos: os nós e as folhas. Os nós são os objetos que contém outros objetos, enquanto as folhas são os objetos que não contém outros objetos. 8 | 9 | ```mermaid 10 | graph TD 11 | No[Nó] --> No1[Nó] 12 | No --> Folha1[Folha] 13 | No1 --> No2[Nó] 14 | No1 --> Folha2[Folha] 15 | No2 --> Folha3[Folha] 16 | No2 --> Folha4[Folha] 17 | ``` 18 | 19 | ## Exemplo 20 | Para exemplicar, a presente implementação contém três classes principais: _Content_, _Lesson_ e _Module_. A classe _Content_ é a **classe abstrata** que representa o nó, enquanto as classes _Lesson_ e _Module_ são as classes que representam as folhas, conforme explicado anteriormente. 21 | 22 | ```mermaid 23 | classDiagram 24 | Content <|-- Lesson 25 | Content <|-- Module 26 | Content : +add(Content) 27 | Content : +delete(Content) 28 | Content : +display() 29 | Content : +spaceRepeat(level) 30 | Lesson : -title 31 | Lesson : +display() 32 | Module : -name 33 | Module : -contents 34 | Module : +add(Content) 35 | Module : +delete(Content) 36 | Module : +display() 37 | ``` 38 | 39 | #### Observações 40 | 41 | - O uso da classe abstrata para representar _Content_ é necessário para que as classes _Lesson_ e _Module_ possam ser tratadas da mesma forma, ou seja, tanto _Lesson_ quanto _Module_ são _Content_. Além disso, é possível definir implementações padrões que lançam exceções para métodos que não fazem sentido para todos os tipos de conteúdo. Por exemplo, o método `add(Content)` não faz sentido para a classe _Lesson_, pois uma _Lesson_ não pode conter outros conteúdos. 42 | - O método `spaceRepeat(int level)` é um auxiliar para imprimir o resultado de forma hierárquica no console, constribuindo para uma melhor visualização da composição final dos objetos. 43 | 44 | ## Sua vez 45 | Implemente mais um tipo de conteúdo, por exemplo, _Exercise_, e adicione-o ao _Module 01: Primeiros passos com Java_. 46 | 47 | # Referências 48 | - [refactoring.guru](https://refactoring.guru/design-patterns/composite) 49 | - [wikipedia.org](https://en.wikipedia.org/wiki/Composite_pattern) 50 | - [OtavioMiranda - Youtube](https://www.youtube.com/watch?v=I0RqHDFQjVY) -------------------------------------------------------------------------------- /Design Patterns/Facade Pattern/README.md: -------------------------------------------------------------------------------- 1 | FACADE PATTERN 2 | 3 | DEFINIÇÃO

4 | O Facade é um padrão de projeto estrutural que fornece uma interface simplificada para uma biblioteca, um framework, ou qualquer conjunto complexo de classes. 5 | 6 | PROBLEMA

7 | Imagine que você precisa fazer seu código funcionar com um amplo conjunto de objetos que pertencem a uma sofisticada biblioteca ou framework.

8 | Normalmente, você precisaria inicializar todos aqueles objetos, rastrear as dependências, executar métodos na ordem correta, e assim por diante.

9 | Como resultado, a lógica de negócio de suas classes vai ficar firmemente acoplada aos detalhes de implementação das classes de terceiros, tornando difícil compreendê-lo e mantê-lo. 10 | 11 | BENEFÍCIOS

12 | Simplicar a utilização de bibliotecas complexas, expondo ao cliente somente as operações necessárias. 13 | 14 | DESVANTAGENS

15 | Uma fachada pode fornecer funcionalidades limitadas em comparação com trabalhar com os subsistemas diretamente. 16 | 17 | REFERÊNCIAS

18 | Este exemplo foi inspirado no artigo da plataforma Medium: How to implement Facade Design Pattern using Java? by Rohan Ravindra Kadam 19 | https://bit.ly/45Ateds 20 | 21 | Curso na Udemy: Padrões de Projeto em JAVA na Prática - Cod3r 22 | Site Refactoring Guru: https://refactoring.guru/design-patterns/facade -------------------------------------------------------------------------------- /Design Patterns/Facade Pattern/com/facade/java/enumeration/TransportType.java: -------------------------------------------------------------------------------- 1 | package com.facade.java.enumeration; 2 | 3 | public enum TransportType { 4 | BICYCLE(30), 5 | CAR(350), 6 | TRUCK(800); 7 | 8 | private final double maximumVolume; 9 | 10 | TransportType (double maximumVolume){ 11 | this.maximumVolume = maximumVolume; 12 | 13 | } 14 | 15 | public double getMaximumVolume() { 16 | return maximumVolume; 17 | } 18 | 19 | } 20 | -------------------------------------------------------------------------------- /Design Patterns/Facade Pattern/com/facade/java/model/DeliveryByBicycle.java: -------------------------------------------------------------------------------- 1 | package com.facade.java.model; 2 | 3 | public class DeliveryByBicycle implements DeliveryTransport { 4 | 5 | @Override 6 | public String delivery(PackageInfo packageInfo) { 7 | String message = "Delivery using bicycle. " + packageInfo; 8 | System.out.println(message); 9 | return message; 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /Design Patterns/Facade Pattern/com/facade/java/model/DeliveryByCar.java: -------------------------------------------------------------------------------- 1 | package com.facade.java.model; 2 | 3 | public class DeliveryByCar implements DeliveryTransport { 4 | 5 | @Override 6 | public String delivery(PackageInfo packageInfo) { 7 | String message = "Delivery using car. " + packageInfo; 8 | System.out.println(message); 9 | return message; 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /Design Patterns/Facade Pattern/com/facade/java/model/DeliveryByTruck.java: -------------------------------------------------------------------------------- 1 | package com.facade.java.model; 2 | 3 | public class DeliveryByTruck implements DeliveryTransport{ 4 | 5 | @Override 6 | public String delivery(PackageInfo packageInfo) { 7 | String message = "Delivery using truck. " + packageInfo; 8 | System.out.println(message); 9 | return message; 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /Design Patterns/Facade Pattern/com/facade/java/model/DeliveryTransport.java: -------------------------------------------------------------------------------- 1 | package com.facade.java.model; 2 | 3 | public interface DeliveryTransport { 4 | 5 | String delivery(PackageInfo packageInfo); 6 | 7 | } 8 | -------------------------------------------------------------------------------- /Design Patterns/Facade Pattern/com/facade/java/model/PackageInfo.java: -------------------------------------------------------------------------------- 1 | package com.facade.java.model; 2 | 3 | public class PackageInfo { 4 | private double kilogramsWeight; // kilogram 5 | private double metersHeight; // meter 6 | private double metersWidth; // meter 7 | private double metersLength; // meter 8 | 9 | public PackageInfo(double kilogramsWeight, double metersHeight, double metersWidth, double metersLength) { 10 | this.kilogramsWeight = kilogramsWeight; 11 | this.metersHeight = metersHeight; 12 | this.metersWidth = metersWidth; 13 | this.metersLength = metersLength; 14 | } 15 | 16 | public double getKilogramsWeight() { 17 | return kilogramsWeight; 18 | } 19 | 20 | public void setKilogramsWeight(double kilogramsWeight) { 21 | this.kilogramsWeight = kilogramsWeight; 22 | } 23 | 24 | public double getMetersHeight() { 25 | return metersHeight; 26 | } 27 | 28 | public void setMetersHeight(double metersHeight) { 29 | this.metersHeight = metersHeight; 30 | } 31 | 32 | public double getMetersWidth() { 33 | return metersWidth; 34 | } 35 | 36 | public void setMetersWidth(double metersWidth) { 37 | this.metersWidth = metersWidth; 38 | } 39 | 40 | public double getMetersLength() { 41 | return metersLength; 42 | } 43 | 44 | public void setMetersLength(double metersLength) { 45 | this.metersLength = metersLength; 46 | } 47 | 48 | @Override 49 | public String toString() { 50 | return "PackageInfo -> " + 51 | "Weight: " + kilogramsWeight + 52 | ", Height: " + metersHeight + 53 | ", Width: " + metersWidth + 54 | ", Length: " + metersLength; 55 | } 56 | } 57 | -------------------------------------------------------------------------------- /Design Patterns/Facade Pattern/com/facade/java/service/CalcService.java: -------------------------------------------------------------------------------- 1 | package com.facade.java.service; 2 | 3 | import java.math.BigDecimal; 4 | import java.math.RoundingMode; 5 | 6 | public class CalcService { 7 | 8 | public double calculateVolume (double height, double width, double length){ 9 | double area = height * width * length; 10 | System.out.println("area " + area); 11 | // arredonda o valor para 2 casas decimais 12 | return new BigDecimal(area).setScale(2, RoundingMode.HALF_UP).doubleValue(); 13 | } 14 | 15 | public double convertCubicMetersToLiters (double cubicMetersVolume) { 16 | System.out.println("liters " + cubicMetersVolume*1000); 17 | return cubicMetersVolume * 1000; 18 | } 19 | 20 | } 21 | -------------------------------------------------------------------------------- /Design Patterns/Facade Pattern/com/facade/java/service/ManageDelivery.java: -------------------------------------------------------------------------------- 1 | package com.facade.java.service; 2 | 3 | import com.facade.java.enumeration.TransportType; 4 | import com.facade.java.model.DeliveryByBicycle; 5 | import com.facade.java.model.DeliveryByCar; 6 | import com.facade.java.model.DeliveryByTruck; 7 | import com.facade.java.model.PackageInfo; 8 | 9 | public class ManageDelivery { 10 | CalcService calcService; 11 | 12 | public String deliverPackage (PackageInfo packageInfo) { 13 | calcService = new CalcService(); 14 | 15 | double packageVolume = calcService.calculateVolume(packageInfo.getMetersHeight(), 16 | packageInfo.getMetersWidth(), packageInfo.getMetersLength()); 17 | 18 | double packageVolumeInLiters = calcService.convertCubicMetersToLiters(packageVolume); 19 | 20 | if (packageVolumeInLiters <= TransportType.BICYCLE.getMaximumVolume()) 21 | return new DeliveryByBicycle().delivery(packageInfo); 22 | else if (packageVolumeInLiters <= TransportType.CAR.getMaximumVolume()) 23 | return new DeliveryByCar().delivery(packageInfo); 24 | else if (packageVolumeInLiters <= TransportType.TRUCK.getMaximumVolume()) 25 | return new DeliveryByTruck().delivery(packageInfo); 26 | else 27 | return "Package volume exceeds all tranport types. Please, contact the client !"; 28 | 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /Design Patterns/Facade Pattern/com/facade/java/test/FacadeTest.java: -------------------------------------------------------------------------------- 1 | package com.facade.java.test; 2 | 3 | import static org.junit.jupiter.api.Assertions.assertTrue; 4 | 5 | import com.facade.java.model.PackageInfo; 6 | import com.facade.java.service.ManageDelivery; 7 | import org.junit.jupiter.api.Test; 8 | 9 | public class FacadeTest { 10 | PackageInfo packageInfo; 11 | ManageDelivery manageDelivery; 12 | 13 | @Test 14 | void whenVolumeInLitersLessThan30ThenDeliverByBike(){ 15 | packageInfo = new PackageInfo(0.5, 0.30, 0.25, 0.40); 16 | manageDelivery = new ManageDelivery(); 17 | assertTrue(manageDelivery.deliverPackage(packageInfo).contains("bicycle")); 18 | 19 | } 20 | 21 | @Test 22 | void whenVolumeInLitersMoreThan30AndLessThan305ThenDeliverByCar(){ 23 | packageInfo = new PackageInfo(2.5, 0.30, 0.75, 0.80); 24 | manageDelivery = new ManageDelivery(); 25 | assertTrue(manageDelivery.deliverPackage(packageInfo).contains("car")); 26 | 27 | } 28 | 29 | @Test 30 | void whenVolumeInLitersMoreThan350AndLessThan800ThenDeliverByTruck(){ 31 | packageInfo = new PackageInfo(75, 0.50, 0.75, 1.5); 32 | manageDelivery = new ManageDelivery(); 33 | assertTrue(manageDelivery.deliverPackage(packageInfo).contains("truck")); 34 | 35 | } 36 | 37 | @Test 38 | void whenVolumeExceedsAllTranportTypes(){ 39 | packageInfo = new PackageInfo(2.75, 1.30, 2.10, 1.5); 40 | manageDelivery = new ManageDelivery(); 41 | assertTrue(manageDelivery.deliverPackage(packageInfo).contains("client")); 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /Design Patterns/FactoryMethod/README.md: -------------------------------------------------------------------------------- 1 | 2 | # Factory Method Pattern 3 | 4 | Neste exemplo, implementar o padrão Factory Method em Java para criar randomicamente tipos de animais, 5 | você precisará criar uma interface e, em seguida, implementar essa interface em classes concretas 6 | que representam diferentes tipos de animais. Aqui está uma implementação básica desse padrão. -------------------------------------------------------------------------------- /Design Patterns/FactoryMethod/com/factorymethod/java/Animal.java: -------------------------------------------------------------------------------- 1 | public abstract class Animal { 2 | private Animal(){ 3 | System.out.println("Animal should not be created here"); 4 | } 5 | public void eat() { 6 | System.out.println("Animal is eating"); 7 | } 8 | 9 | } 10 | 11 | public class Dog extends Animal { 12 | public void bark() { 13 | System.out.println("Dog is barking"); 14 | } 15 | } 16 | 17 | public class Cat extends Animal { 18 | public void meow() { 19 | System.out.println("Cat is meowing"); 20 | } 21 | } -------------------------------------------------------------------------------- /Design Patterns/FactoryMethod/com/factorymethod/java/AnimalFactory.java: -------------------------------------------------------------------------------- 1 | public interface AnimalFactory { 2 | Animal createAnimal(); 3 | } 4 | -------------------------------------------------------------------------------- /Design Patterns/FactoryMethod/com/factorymethod/java/MainAnimalFactory.java: -------------------------------------------------------------------------------- 1 | public class MainAnimalFactory { 2 | public static void main(String[] args) { 3 | AnimalFactory animalFactory = new RandomAnimalFactory(); 4 | Animal randomAnimal = animalFactory.createAnimal(); 5 | 6 | randomAnimal.eat(); // Todos os animais podem comer 7 | 8 | if (randomAnimal instanceof Dog) { 9 | ((Dog) randomAnimal).bark(); 10 | } else if (randomAnimal instanceof Cat) { 11 | ((Cat) randomAnimal).meow(); 12 | } 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /Design Patterns/FactoryMethod/com/factorymethod/java/RandomAnimalFactory.java: -------------------------------------------------------------------------------- 1 | import java.util.Random; 2 | 3 | public class RandomAnimalFactory implements AnimalFactory { 4 | public Animal createAnimal() { 5 | Random random = new Random(); 6 | int randomAnimalType = random.nextInt(2); // Gere um número aleatório (0 ou 1) 7 | 8 | if (randomAnimalType == 0) { 9 | return new Dog(); 10 | } else { 11 | return new Cat(); 12 | } 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /Design Patterns/Observer Pattern/README.md: -------------------------------------------------------------------------------- 1 |

OBSERVER PATTERN

2 | 3 | Definição:

4 | É um padrão de projeto comportamental que permite que você defina um mecanismo de assinatura para 5 | notificar múltiplos objetos sobre quaisquer eventos que aconteçam com o objeto que eles estão observando.

6 | 7 | Problema:

8 | Imagine que você tem dois tipos de objetos: um Cliente e uma Loja. O cliente está muito interessado em uma marca particular de um produto (digamos que seja um novo modelo de iPhone) que logo deverá estar disponível na loja.

9 | O cliente pode visitar a loja todos os dias e checar a disponibilidade do produto. Mas enquanto o produto ainda está a caminho, a maioria dessas visitas serão em vão.

10 | Por outro lado, a loja poderia mandar milhares de emails (que poderiam ser considerados como spam) para todos os clientes cada vez que um novo produto se torna disponível. Isso salvaria alguns clientes de incontáveis viagens até a loja. Porém, ao mesmo tempo, irritaria outros clientes que não estão interessados em novos produtos.

11 | Parece que temos um conflito. Ou o cliente gasta tempo verificando a disponibilidade do produto ou a loja gasta recursos notificando os clientes errados.

12 | 13 | Solução: 14 | O objeto que tem um estado interessante é quase sempre chamado de subject ou publisher.

15 | Todos os outros objetos que querem saber das mudanças do estado do publicador são chamados de observer ou subscriber.

16 | O padrão Observer sugere que você adicione um mecanismo de registro na classe subject (inclusão ou cancelamento). Esse mecanismo consiste em 1) um vetor para armazenar uma lista de referências aos objetos do Subject e 2) alguns métodos públicos que permitem adicionar assinantes e removê-los da lista.

17 | Quando um evento importante acontece com o Subject, ele chama um método específico de notificação de seus Observers.

18 | Todos os Observers implementam a mesma interface para que o Subject comunique-se com eles através daquela interface.

19 | 20 | Projeto:

21 | Imagine que você tenha um e-commerce com diversos produtos, no qual alguns deles encontram-se sem estoque.

22 | Este e-commerce permite que o cliente cadastre seu e-mail para receber uma notificação quando houver reposição do produto em estoque.

23 | 24 | 25 | Referências:

26 | https://refactoring.guru/pt-br/design-patterns/observer

27 | Curso Padrões de Projeto em JAVA na Prática - Udemy - Cod3r

28 | Medium - Observer Design Pattern in Java (https://medium.com/javarevisited/observer-design-pattern-in-java-updated-2023-800e2f997aff) -------------------------------------------------------------------------------- /Design Patterns/Observer Pattern/com/observer/java/model/Product.java: -------------------------------------------------------------------------------- 1 | package com.observer.java.model; 2 | 3 | public class Product { 4 | private String description; 5 | private int productsInStock; 6 | 7 | public Product(String description, int productsInStock) { 8 | this.description = description; 9 | this.productsInStock = productsInStock; 10 | } 11 | 12 | public String getDescription() { 13 | return description; 14 | } 15 | 16 | public void setDescription(String description) { 17 | this.description = description; 18 | } 19 | 20 | public int getProductsInStock() { 21 | return productsInStock; 22 | } 23 | 24 | public void setProductsInStock(int productsInStock) { 25 | this.productsInStock = productsInStock; 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /Design Patterns/Observer Pattern/com/observer/java/observer/ClientProductObserver.java: -------------------------------------------------------------------------------- 1 | package com.observer.java.observer; 2 | 3 | import com.observer.java.subject.Subject; 4 | 5 | public class ClientProductObserver implements Observer{ 6 | String observerEmail; 7 | Subject subjectSubscribed; 8 | public ClientProductObserver(String observerEmail) { 9 | this.observerEmail = observerEmail; 10 | } 11 | 12 | @Override 13 | public void update() { 14 | String newMessage = (String) subjectSubscribed.getUpdate(); 15 | if (newMessage == null) { 16 | System.out.println(observerEmail + " No products received yet!!!"); 17 | } else { 18 | System.out.println(observerEmail + " New products received: " + newMessage); 19 | } 20 | } 21 | 22 | @Override 23 | public void update(String newMessage) { 24 | if (newMessage == null) { 25 | System.out.println(observerEmail + " No products received yet !!!"); 26 | } else { 27 | System.out.println(observerEmail + " New products received! " + newMessage); 28 | } 29 | } 30 | 31 | @Override 32 | public void setSubject(Subject subject) { 33 | subjectSubscribed = subject; 34 | } 35 | 36 | } 37 | -------------------------------------------------------------------------------- /Design Patterns/Observer Pattern/com/observer/java/observer/Observer.java: -------------------------------------------------------------------------------- 1 | package com.observer.java.observer; 2 | 3 | import com.observer.java.subject.Subject; 4 | 5 | public interface Observer { 6 | 7 | //Method to check for an update from subject for state change 8 | void update(); 9 | 10 | //Method used by Subject to update Observer for state change 11 | void update(String message); 12 | 13 | //Attach the observer to a subject 14 | void setSubject(Subject subject); 15 | 16 | } 17 | -------------------------------------------------------------------------------- /Design Patterns/Observer Pattern/com/observer/java/service/ProductStockService.java: -------------------------------------------------------------------------------- 1 | package com.observer.java.service; 2 | 3 | import com.observer.java.subject.Subject; 4 | import com.observer.java.model.Product; 5 | 6 | public class ProductStockService { 7 | Product product; 8 | Subject subject; 9 | 10 | public ProductStockService (Product product, Subject subject){ 11 | this.product = product; 12 | this.subject = subject; 13 | 14 | } 15 | 16 | public void addProductsToStock(int productsToAdd) { 17 | if (product.getProductsInStock() == 0) 18 | if (productsToAdd > 0) 19 | subject.postMessage("Available product NOW ! Buy " + product.getDescription() + "!"); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /Design Patterns/Observer Pattern/com/observer/java/subject/ProductOutOfStockSubject.java: -------------------------------------------------------------------------------- 1 | package com.observer.java.subject; 2 | 3 | import com.observer.java.observer.Observer; 4 | import java.util.ArrayList; 5 | import java.util.List; 6 | 7 | public class ProductOutOfStockSubject implements Subject{ 8 | private List observersList; 9 | private String message; 10 | 11 | public ProductOutOfStockSubject() { 12 | observersList = new ArrayList<>(); 13 | } 14 | 15 | @Override 16 | public void register(Observer observer) { 17 | if (observer == null) { 18 | throw new NullPointerException(); 19 | } 20 | observersList.add(observer); 21 | } 22 | 23 | @Override 24 | public void unregister(Observer observer) { 25 | observersList.remove(observer); 26 | } 27 | 28 | @Override 29 | public void notifyObservers() { 30 | if (observersList != null && !observersList.isEmpty()) { 31 | for (Observer observer : observersList) { 32 | observer.update(message); 33 | } 34 | } else { 35 | System.out.println("No observers to notify!!!"); 36 | } 37 | } 38 | 39 | @Override 40 | public Object getUpdate() { 41 | return message; 42 | } 43 | 44 | @Override 45 | public void postMessage(String message) { 46 | System.out.println("Message posted on topic : " + message); 47 | this.message = message; 48 | notifyObservers(); 49 | } 50 | 51 | } 52 | -------------------------------------------------------------------------------- /Design Patterns/Observer Pattern/com/observer/java/subject/Subject.java: -------------------------------------------------------------------------------- 1 | package com.observer.java.subject; 2 | 3 | import com.observer.java.observer.Observer; 4 | 5 | public interface Subject { 6 | 7 | //register an subject to a subject 8 | void register(Observer observer); 9 | 10 | //unregister an subject from a subject 11 | void unregister(Observer observer); 12 | 13 | //notify all observers for the change in subject's state 14 | void notifyObservers(); 15 | 16 | //method to get update from subject by the observer 17 | Object getUpdate(); 18 | 19 | //post message to observers 20 | void postMessage(String message); 21 | } -------------------------------------------------------------------------------- /Design Patterns/Observer Pattern/com/observer/java/test/ObserverTest.java: -------------------------------------------------------------------------------- 1 | package com.observer.java.test; 2 | 3 | import com.observer.java.model.Product; 4 | import com.observer.java.observer.ClientProductObserver; 5 | import com.observer.java.observer.Observer; 6 | import com.observer.java.subject.ProductOutOfStockSubject; 7 | import com.observer.java.service.ProductStockService; 8 | import com.observer.java.subject.Subject; 9 | import java.util.ArrayList; 10 | import java.util.List; 11 | import org.junit.jupiter.api.Test; 12 | 13 | public class ObserverTest { 14 | 15 | @Test 16 | void whenProductOutOfStockThenAddStockAndNotifyObservers(){ 17 | 18 | Product product = new Product("Java Effective book", 0); 19 | 20 | Subject productOutOfStock = new ProductOutOfStockSubject(); 21 | List observers = getObservers(); 22 | registerObservers(productOutOfStock, observers); 23 | 24 | ProductStockService productStockService = new ProductStockService(product, productOutOfStock); 25 | 26 | productStockService.addProductsToStock(2); 27 | 28 | // Check console for notification messages 29 | 30 | } 31 | 32 | List getObservers(){ 33 | List observers = new ArrayList<>(); 34 | 35 | //Create observers 36 | for (int i = 1; i <= 3; i++) { 37 | observers.add(new ClientProductObserver("email" + i + "@gmail.com")); 38 | } 39 | 40 | return observers; 41 | 42 | } 43 | 44 | void registerObservers(Subject subject, List observers){ 45 | //Register observers to Subject (productOutOfStock) 46 | for (Observer observer : observers) { 47 | subject.register(observer); 48 | observer.setSubject(subject); 49 | } 50 | } 51 | } 52 | -------------------------------------------------------------------------------- /Design Patterns/Proxy Pattern/README.md: -------------------------------------------------------------------------------- 1 | # Proxy Pattern 2 | 3 | O Proxy é um padrão de projeto estrutural que permite que você forneça um substituto ou um espaço reservado para outro objeto. 4 | Um proxy controla o acesso ao objeto original, permitindo que você faça algo ou antes ou depois do pedido chegar 5 | ao objeto original. 6 | 7 | ## Quando usar o padrão de design de proxy? 8 | 9 | 1. Fornecer um substituto ou espaço reservado para outro objeto para controlar o acesso a ele. 10 | 2. Para dar suporte ao acesso distribuído, regulamentado ou inteligente, adicione outra indireção. 11 | 3. Para evitar que o componente real se torne excessivamente complexo, adicione um wrapper e uma delegação. 12 | 13 | ## Vantagens 14 | 15 | - A segurança é um benefício do padrão de proxy. 16 | - Esse design evita a duplicação de itens potencialmente muito grandes e que consomem muita memória. Isso melhora o desempenho do aplicativo. 17 | 18 | ## Desvantagens 19 | 20 | - Esse padrão adiciona outra camada de abstração, que ocasionalmente pode causar problemas se alguns clientes acessarem o código do assunto Real diretamente, enquanto outros acessarem as classes Proxy. Isso pode causar comportamento inconsistente. 21 | 22 | # Referências 23 | - [refactoring.guru](https://refactoring.guru/design-patterns/proxy) 24 | - [java.dev.journal](https://www.javadevjournal.com/java-design-patterns/proxy-design-pattern/) -------------------------------------------------------------------------------- /Design Patterns/Proxy Pattern/com.proxy.principle/DownloadPlatform.java: -------------------------------------------------------------------------------- 1 | public class DownloadPlatform { 2 | 3 | public static void main(String[] args) { 4 | 5 | Video video = new ProxyVideo("testVideo.mp4"); 6 | 7 | video.download(); 8 | System.out.println("Download Complete!"); 9 | 10 | System.out.println("Loading file..."); 11 | 12 | video.playing(); 13 | } 14 | } -------------------------------------------------------------------------------- /Design Patterns/Proxy Pattern/com.proxy.principle/ProxyVideo.java: -------------------------------------------------------------------------------- 1 | public class ProxyVideo implements Video { 2 | 3 | private RealVideo realVideo; 4 | private String fileName; 5 | 6 | public ProxyVideo(String fileName){ 7 | this.fileName = fileName; 8 | } 9 | 10 | @Override 11 | public void download() { 12 | if(realVideo == null){ 13 | realVideo = new RealVideo(fileName); 14 | } 15 | realVideo.download(); 16 | } 17 | 18 | @Override 19 | public void playing() { 20 | if(realVideo == null){ 21 | realVideo = new RealVideo(fileName); 22 | } 23 | realVideo.playing(); 24 | } 25 | } -------------------------------------------------------------------------------- /Design Patterns/Proxy Pattern/com.proxy.principle/RealVideo.java: -------------------------------------------------------------------------------- 1 | public class RealVideo implements Video { 2 | 3 | private String fileName; 4 | 5 | public RealVideo(String fileName){ 6 | this.fileName = fileName; 7 | } 8 | 9 | @Override 10 | public void download() { 11 | System.out.println("Downloading file " + fileName); 12 | } 13 | 14 | @Override 15 | public void playing() { 16 | System.out.println("Playing file " + fileName); 17 | } 18 | } -------------------------------------------------------------------------------- /Design Patterns/Proxy Pattern/com.proxy.principle/Video.java: -------------------------------------------------------------------------------- 1 | public interface Video { 2 | 3 | void download(); 4 | 5 | void playing(); 6 | } -------------------------------------------------------------------------------- /Design Patterns/README.md: -------------------------------------------------------------------------------- 1 | # Design Patterns com Java 2 | 3 | Contribua nesta pasta com exemplos de aplicação de Design Patterns com Java, siga os passos: 4 | 5 | 1. Crie uma pasta com o nome do Design Pattern 6 | 2. Crie um Readme explicando sobre o Design Pattern 7 | 3. Crie o package no formato "com.{design-pattern}.principle 8 | 4. Faça as classes em Java com a aplicação do Design Pattern 9 | 10 | O Strategy Pattern está como exemplo. 11 | 12 | Go Hacking! -------------------------------------------------------------------------------- /Design Patterns/Singleton/README.md: -------------------------------------------------------------------------------- 1 | # Singleton Pattern 2 | A estratégia Singleton é uma forma de garantir que uma classe tenha apenas uma instância criada, e ao mesmo tempo, disponibilizar acesso a esta única instância. Este padrão de projeto tem como objetivo controlar o acesso a um único recurso que será utilizado em vários lugares, como por exemplo: conexão compartilhada ao banco de dados, *logger*, gerenciador de arquivos. 3 | 4 | ## Implementação 5 | Para implementar uma classe do tipo Singleton, são necessários dois passos: 6 | 7 | 1. Transformar o construtor da classe em um método privado, para que apenas a própria classe seja capaz de criar uma instância. 8 | 2. Disponibilizar um método de acesso público com a responsabilidade de retornar a instância criada. 9 | 10 | ## Vantagens 11 | - A classe só será instanciada quando for pedida pela primeira vez 12 | - Garantia de que apenas uma instância existe o tempo todo 13 | - Ponto de acesso global a instância criada através do método acessor 14 | 15 | ## Desvantagens 16 | - Este padrão viola o princípio de responsabilidade única, já que a classe fica responsável não só por disponibilizar um ponto de acesso mas também pela sua própria criação. 17 | - A instância pode a qualquer momento ser alterada por algum cliente e causar problemas em outros clientes que dependam de um estado específico, caso não haja garantia de imutabilidade da classe (por exemplo, métodos que alterem propriedades da única instância). 18 | - Em ambientes multi-thread, como o Java, é necessário tratamento especial para que a classe não possa ser inicializada ao mesmo tempo em threads diferentes, resultando em múltiplas instâncias. 19 | -------------------------------------------------------------------------------- /Design Patterns/Singleton/com.singleton.java/MySingleton.java: -------------------------------------------------------------------------------- 1 | public class MySingleton { 2 | 3 | private static MySingleton instance = null; 4 | 5 | private MySingleton() { 6 | } 7 | 8 | public static synchronized MySingleton getInstance() { 9 | if (instance == null) { 10 | instance = new MySingleton(); 11 | } 12 | 13 | return instance; 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /Design Patterns/Strategy Pattern/README.md: -------------------------------------------------------------------------------- 1 | # Strategy Pattern 2 | Estratégia (Strategy Pattern): é categorizado como um padrão comportamental de desenvolvimento de software. 3 | O objetivo é representar uma operação realizada sobre os elementos de uma estrutura de objetos. O padrão Strategy permite definir novas operações sem alterar as classes dos elementos sobre os quais opera. Strategy permite que o algoritmo varie independentemente dos clientes que o utilizam. 4 | 5 | Segue a estratégia de adição(Addition), subtração(Subtraction), multiplicação(Multiplication) e divisão(Division). 6 | 7 | 8 | 9 | -------------------------------------------------------------------------------- /Design Patterns/Strategy Pattern/com.strategy.java/Addition.java: -------------------------------------------------------------------------------- 1 | public class Addition extends Strategy { 2 | 3 | @Override 4 | public double calculate(double a, double b){ 5 | return a + b; 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /Design Patterns/Strategy Pattern/com.strategy.java/Context.java: -------------------------------------------------------------------------------- 1 | public class Context { 2 | 3 | private Strategy strategy; 4 | 5 | public Context(Strategy strategy){ 6 | this.strategy = strategy; 7 | } 8 | 9 | public double doCalculate(double a, double b){ 10 | return this.strategy.calculate(a, b); 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /Design Patterns/Strategy Pattern/com.strategy.java/Division.java: -------------------------------------------------------------------------------- 1 | public class Division extends Strategy{ 2 | 3 | @Override 4 | public double calculate(double a, double b) { 5 | return a / b; 6 | } 7 | 8 | } 9 | -------------------------------------------------------------------------------- /Design Patterns/Strategy Pattern/com.strategy.java/Multiplication.java: -------------------------------------------------------------------------------- 1 | public class Multiplication extends Strategy { 2 | 3 | @Override 4 | public double calculate(double a, double b) { 5 | return a * b; 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /Design Patterns/Strategy Pattern/com.strategy.java/Strategy.java: -------------------------------------------------------------------------------- 1 | public abstract class Strategy { 2 | 3 | public abstract double calculate(double a, double b); 4 | } -------------------------------------------------------------------------------- /Design Patterns/Strategy Pattern/com.strategy.java/Subtraction.java: -------------------------------------------------------------------------------- 1 | public class Subtraction extends Strategy { 2 | 3 | @Override 4 | public double calculate(double a, double b) { 5 | return a - b; 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /Exception Handling/Acessando Indice/README.md: -------------------------------------------------------------------------------- 1 | # Acessando Index 2 | 3 | ### Introdução 4 | 5 | Ao utilizarmos arrays em Java lidamos com a possibilidade do lançamento de exceções. 6 | 7 | Somente em tempo de execução é possível saber o retorno da consulta do índice de um array, caso não seja exista, 8 | uma exceção do tipo ArrayIndexOutOfBoundsException é lançada e nossa aplicação precisa estar preparada para lidar com 9 | essa situação mantendo seu fluxo normal. 10 | 11 | ## Funcionamento do Programa 12 | 13 | O programa realiza as seguintes etapas: 14 | 15 | 1. Cria um array de inteiros com tamanho 8. 16 | 2. Solicita ao usuário que digite um índice que deseja acessar. 17 | 3. Tenta acessar o valor no índice especificado no array. 18 | 4. Se o índice for válido, ele imprime o valor. 19 | 5. Se o índice não existir (for maior ou igual a 8), ele trata a exceção `ArrayIndexOutOfBoundsException` e exibe uma 20 | mensagem de erro. -------------------------------------------------------------------------------- /Exception Handling/Acessando Indice/com.accessing.index/java/Main.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class Main { 4 | 5 | private static final int[] arrayInteiros = {1, 2, 3, 5, 8, 13, 21, 34}; 6 | 7 | public static void main(String[] args) { 8 | Scanner scanner = new Scanner(System.in); 9 | 10 | System.out.print("Qual índice do array você deseja acessar? "); 11 | 12 | int indice = scanner.nextInt(); 13 | 14 | try { 15 | int resultado = arrayInteiros[indice]; 16 | System.out.printf("Valor: %d", resultado); 17 | } catch (ArrayIndexOutOfBoundsException exception) { 18 | System.out.println("Índice inexistente."); 19 | } 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /Exception Handling/Custom Exception/com.custom.java/README.md: -------------------------------------------------------------------------------- 1 | # Exceções customizadas 2 | 3 | ## Introdução 4 | 5 | Ao utilizarmos a linguagem Java, podemos criar exceções personalizadas que são criadas a partir da classe Exception. Dessa forma, quando um comportamento determinado ocorrer, podemos lançar uma exceção que possua um nome que facilite o entendimento da causa e, consequentemente, a identificação e correção. Isso ajuda muito pois permite criar exceções que são próprias do projeto, e com regras de negócio inerentes a ele. 6 | 7 | ## Funcionamento do Programa 8 | 9 | 1. Ao executar a classe Main 10 | 2. Será feito a verificação se a idade da pessoa esta entre 0 e 150 anos. 11 | 3. Em caso de não estar em acordo, a exceção IdadeInvalidaException será lançada. -------------------------------------------------------------------------------- /Exception Handling/Custom Exception/com.custom.java/domain/Pessoa.java: -------------------------------------------------------------------------------- 1 | package domain; 2 | 3 | import exceptions.IdadeInvalidaException; 4 | 5 | public class Pessoa { 6 | 7 | private static final short ZERO = 0; 8 | private static final short CENTO_CINQUENTA = 150; 9 | private static final String IDADE_NAO_PERMITIDA = "Idade Não Permitida"; 10 | 11 | private String nome; 12 | private short idade; 13 | 14 | public String getNome() { 15 | return nome; 16 | } 17 | 18 | public void setNome(String nome) { 19 | this.nome = nome; 20 | } 21 | 22 | public short getIdade() { 23 | return idade; 24 | } 25 | 26 | public void setIdade(short idade){ 27 | this.idade = idade; 28 | } 29 | 30 | public void verificaIdade() throws IdadeInvalidaException{ 31 | if(this.idade < ZERO || this.idade > CENTO_CINQUENTA){ 32 | throw new IdadeInvalidaException(IDADE_NAO_PERMITIDA); 33 | } 34 | } 35 | 36 | } 37 | -------------------------------------------------------------------------------- /Exception Handling/Custom Exception/com.custom.java/exceptions/IdadeInvalidaException.java: -------------------------------------------------------------------------------- 1 | package exceptions; 2 | public class IdadeInvalidaException extends Exception { 3 | 4 | public IdadeInvalidaException(String erro){ 5 | super(erro); 6 | } 7 | 8 | } 9 | 10 | 11 | -------------------------------------------------------------------------------- /Exception Handling/Custom Exception/com.custom.java/impl/Main.java: -------------------------------------------------------------------------------- 1 | package impl; 2 | 3 | import java.util.Scanner; 4 | import domain.Pessoa; 5 | import exceptions.IdadeInvalidaException; 6 | 7 | public class Main { 8 | 9 | public static void main(String[] args) { 10 | 11 | System.out.println("Iniciando criação de uma pessoa... 💁"); 12 | System.out.println("Digite o nome:"); 13 | Pessoa pessoa = new Pessoa(); 14 | Scanner scanner = new Scanner(System.in); 15 | String nome = scanner.nextLine(); 16 | System.out.println("Digite a idade:"); 17 | Short idade = scanner.nextShort(); 18 | scanner.close(); 19 | 20 | try { 21 | pessoa.setNome(nome); 22 | pessoa.setIdade(idade); 23 | pessoa.verificaIdade(); 24 | System.out.println("A pessoa com nome: " + nome + " e idade: " + idade + " foi criada com sucesso!"); 25 | } catch (IdadeInvalidaException e) { 26 | e.printStackTrace(); 27 | } 28 | } 29 | 30 | } 31 | -------------------------------------------------------------------------------- /Exception Handling/Encadeamento de Excecoes/com.encadeamento.excecoes.java/Main.java: -------------------------------------------------------------------------------- 1 | import exception.AcessoNegadoException; 2 | 3 | import java.nio.file.AccessDeniedException; 4 | 5 | public class Main { 6 | 7 | public static void main(String[] args) { 8 | try { 9 | // Simulando uma AccessDeniedException lançando uma exceção de acesso negado 10 | throw new AccessDeniedException("Acesso negado: arquivo-secreto.txt"); 11 | } catch (AccessDeniedException e) { 12 | try { 13 | // Captura a AccessDeniedException e lança a exceção personalizada 14 | throw new AcessoNegadoException("Ocorreu uma exceção de acesso negado: " + e.getMessage()); 15 | } catch (AcessoNegadoException minhaExcecao) { 16 | System.err.println("Exceção capturada: " + minhaExcecao.getMessage()); 17 | } 18 | } 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /Exception Handling/Encadeamento de Excecoes/com.encadeamento.excecoes.java/README.md: -------------------------------------------------------------------------------- 1 | # Exceções em Java e Encadeamento de Exceções 2 | 3 | Este README fornece uma visão geral das exceções em Java e como você pode lidar com elas, incluindo o encadeamento de exceções. 4 | 5 | ## Introdução às Exceções em Java 6 | 7 | Em Java, exceções são eventos anormais ou erros que ocorrem durante a execução de um programa. As exceções permitem que você lide com erros de maneira mais controlada e forneçam informações detalhadas sobre o que deu errado. As exceções podem ser divididas em duas categorias principais: 8 | 9 | 1. Exceções Verificadas (Checked Exceptions): Essas são exceções que o compilador Java exige que você trate explicitamente, usando blocos try-catch ou declarando que seu método lança a exceção. Um exemplo comum é a IOException. 10 | 11 | 2. Exceções Não Verificadas (Unchecked Exceptions): Também conhecidas como exceções de tempo de execução, essas exceções não são verificadas pelo compilador e geralmente resultam de erros lógicos ou problemas de programação, como tentar acessar um elemento de uma lista vazia. Um exemplo é a NullPointerException. 12 | 13 | ## Lidando com Exceções 14 | 15 | Para lidar com exceções em Java, você pode usar blocos try-catch para capturar e tratar exceções. Aqui está um exemplo básico: 16 | 17 | ```java 18 | public class Exemplo { 19 | 20 | try { 21 | // Código que pode gerar uma exceção 22 | } catch (TipoDeExcecao e) { 23 | // Trate a exceção aqui 24 | } 25 | } 26 | ``` 27 | No bloco try, você coloca o código que pode lançar uma exceção. No bloco catch, você especifica o tipo de exceção que deseja capturar e define como tratá-la. 28 | 29 | ## Encadeamento de Exceções 30 | O encadeamento de exceções é a prática de capturar uma exceção, transformá-la em outra e lançá-la novamente. 31 | Isso pode ser útil quando você deseja adicionar informações específicas sobre a causa da exceção ou quando deseja criar exceções personalizadas. 32 | 33 | Aqui está um exemplo de encadeamento de exceções: 34 | 35 | ```java 36 | public class Exemplo { 37 | 38 | try { 39 | // Algum código que pode lançar uma exceção 40 | } catch (IOException e) { 41 | throw new ExcecaoPersonalizada("Ocorreu um erro específico: " + e.getMessage()); 42 | } 43 | } 44 | ``` 45 | Neste exemplo, uma IOException é capturada e, em seguida, uma exceção personalizada chamada ExcecaoPersonalizada é lançada com uma mensagem específica, incluindo informações da exceção original. 46 | 47 | ## Conclusão 48 | Lidar com exceções é uma parte essencial da programação em Java. Com o uso adequado de blocos try-catch e a capacidade de encadear exceções, 49 | você pode desenvolver aplicativos mais robustos e diagnosticar problemas de maneira mais eficaz. -------------------------------------------------------------------------------- /Exception Handling/Encadeamento de Excecoes/com.encadeamento.excecoes.java/exception/AcessoNegadoException.java: -------------------------------------------------------------------------------- 1 | package exception; 2 | 3 | public class AcessoNegadoException extends Exception { 4 | public AcessoNegadoException(String mensagem) { 5 | super(mensagem); 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /Exception Handling/File Not Found/Arquivos/arquivo.txt: -------------------------------------------------------------------------------- 1 | Seja bem vinda! -------------------------------------------------------------------------------- /Exception Handling/File Not Found/Main.java: -------------------------------------------------------------------------------- 1 | import java.io.FileInputStream; 2 | import java.io.FileNotFoundException; 3 | import java.io.IOException; 4 | 5 | public class Main { 6 | 7 | public static void main(String[] args) throws IOException { 8 | 9 | try { 10 | 11 | FileInputStream fileInputStream = new FileInputStream("./Arquivos/arquivo.txt"); 12 | 13 | int conteudo; 14 | 15 | while ((conteudo = fileInputStream.read()) != -1) { 16 | System.out.print((char) conteudo); 17 | } 18 | 19 | } catch (FileNotFoundException e) { 20 | e.printStackTrace(); 21 | } 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /Exception Handling/File Not Found/README.md: -------------------------------------------------------------------------------- 1 | # Exceções relacionadas a arquivos não encontrados 2 | 3 | ## Introdução 4 | 5 | Ao tentar ler um arquivo, é possível que ocorram alguns problemas no fluxo como, por exemplo, o arquivo não estar na pasta esperada, ou o arquivo estar nomeado incorretamente, dentre outras situações. É possível verificar esse tipo de situações e lançar exceção File Not Found Exception, que ajude a entender e resolver o problema. 6 | 7 | ## Funcionamento 8 | 9 | Executar Main.java 10 | 11 | via console: 12 | ```console 13 | 14 | javac Main.java 15 | java Main 16 | 17 | ``` 18 | Ou 19 | 20 | Outras formas são executando com botão direito sobre o arquivo -> Run As java application (maioria das IDEs) 21 | 22 | 1. O programa foi feito para ler o arquivo exemplo que esta na pasta Arquivos. 23 | 2. Caso o arquivo exemplo que esta na pasta Arquivos exista, será exibido o seu conteúdo no console. 24 | 3. Caso não seja encontrado, a exceção java.io.FileNotFoundException será lançada. -------------------------------------------------------------------------------- /Exception Handling/Leitura e Processamento de arquivo/Color.txt: -------------------------------------------------------------------------------- 1 | Rosa 2 | Azul 3 | Verde 4 | Marrom 5 | Cinza 6 | Dourado 7 | Vermelho 8 | Branco 9 | Preto 10 | 11 | Roxo 12 | Amarelo 13 | -------------------------------------------------------------------------------- /Exception Handling/Leitura e Processamento de arquivo/README.md: -------------------------------------------------------------------------------- 1 | # Leitura e processamento de arquivo 2 | 3 | ## Introdução 4 | Para leitura e processamento de arquivo em Java se pode utilizar as classes *FileReader* e a *BufferedReader*. 5 | 6 | A classe *FileReader* é um subtipo da classe *Reader* utilizada para leitura de arquivos que contêm texto. Caso algo não ocorra bem, ela lança a exception *FileNotFoundException*. 7 | 8 | A classe *BufferedReader* lê o arquivo de forma eficiente. Na construção dessa classe é preciso passar uma classe tipo Reader. A exceção lançada por essa classe é a *IOException*. 9 | 10 | O *try with resources* é uma forma de capturar exceções garantindo que os recursos utilizados por algumas classes, como as classes FileReader e BufferedReader, sejam liberados após a execução do programa ou falha. 11 | 12 | ## Funcionamento do programa 13 | 1. Dado que exista o arquivo Color.tx no diretório raiz do projeto 14 | 2. Ao executar a classe main, o caminho do arquivo existente é montado 15 | 3. Com esse caminho é feito a leitura do conteúdo do arquivo com o auxilio das classes FileReader e BufferedReader dentro de um try with resources 16 | 4. Caso não seja lançadas nenhuma exceção do tipo IOException 17 | 5. O conteúdo do arquivo é populado em uma Lista 18 | 6. A Lista é ordernada por ordem alfabética e exibida no console. 19 | 20 | ## Links auxiliares 21 | 22 | * [Class BufferedReader](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/io/BufferedReader.html) 23 | * [Class FileReader](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/io/FileReader.html) 24 | * [How to Read a File in Java](https://www.baeldung.com/reading-file-in-java) 25 | * [Class IOException](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/IOException.html) 26 | * [The try-with-resources Statement](https://docs.oracle.com/javase/tutorial/essential/exceptions/tryResourceClose.html) -------------------------------------------------------------------------------- /Exception Handling/Leitura e Processamento de arquivo/src/Main.java: -------------------------------------------------------------------------------- 1 | import java.io.BufferedReader; 2 | import java.io.File; 3 | import java.io.FileNotFoundException; 4 | import java.io.FileReader; 5 | import java.io.IOException; 6 | import java.util.ArrayList; 7 | import java.util.Collections; 8 | import java.util.List; 9 | import java.util.Objects; 10 | 11 | public class Main { 12 | 13 | public static void main(String[] args){ 14 | File file = new File(""); 15 | String path = file.getAbsolutePath().concat("/Exception Handling/Leitura e Processamento de arquivo/Color.txt"); 16 | 17 | List data = readFileReader(path); 18 | 19 | Collections.sort(data); 20 | data.forEach(System.out::println); 21 | } 22 | 23 | public static List readFileReader(String pathAbs) { 24 | List data = new ArrayList<>(); 25 | try (BufferedReader bufferedReader = new BufferedReader(new FileReader(pathAbs))){ 26 | String line; 27 | while(Objects.nonNull(line = bufferedReader.readLine())) { 28 | data.add(line); 29 | } 30 | } catch (FileNotFoundException e){ 31 | System.out.println("Arquivo não encontrado, verifique se ele existe!"); 32 | } catch (IOException e){ 33 | System.out.println(e.getMessage()); 34 | } 35 | return data; 36 | } 37 | } -------------------------------------------------------------------------------- /Exception Handling/Multiple Exceptions/.gitignore: -------------------------------------------------------------------------------- 1 | ### IntelliJ IDEA ### 2 | out/ 3 | !**/src/main/**/out/ 4 | !**/src/test/**/out/ 5 | 6 | ### Eclipse ### 7 | .apt_generated 8 | .classpath 9 | .factorypath 10 | .project 11 | .settings 12 | .springBeans 13 | .sts4-cache 14 | bin/ 15 | !**/src/main/**/bin/ 16 | !**/src/test/**/bin/ 17 | 18 | ### NetBeans ### 19 | /nbproject/private/ 20 | /nbbuild/ 21 | /dist/ 22 | /nbdist/ 23 | /.nb-gradle/ 24 | 25 | ### VS Code ### 26 | .vscode/ 27 | 28 | ### Mac OS ### 29 | .DS_Store -------------------------------------------------------------------------------- /Exception Handling/Multiple Exceptions/README.md: -------------------------------------------------------------------------------- 1 | 2 | ## Múltiplas Exceções 3 | 4 | Em Java, é possível capturar múltiplas exceções em um único bloco **catch** usando o caractere pipe **|** para 5 | separar os tipos de exceção. 6 | 7 | Também é possível usar blocos **catch** separados para lidar com os diferentes tipos de exceções. 8 | 9 | Neste exemplo, o bloco **try** contém código que pode lançar uma **ArithmeticException** (se a divisão for por zero) 10 | ou um 11 | **ArrayIndexOutOfBoundsException** (se tentar acessar um elemento de array que não existe). Essas exceções são capturadas no primeiro bloco **catch**. 12 | 13 | Um bloco **try-catch-finally** separado demonstra como capturar uma **NumberFormatException** e executar um bloco **finally** que é executado independentemente de ter ocorrido uma exceção ou não. 14 | -------------------------------------------------------------------------------- /Exception Handling/Multiple Exceptions/src/MultipleExceptionsExample.java: -------------------------------------------------------------------------------- 1 | public class MultipleExceptionsExample { 2 | public static void main(String[] args) { 3 | int[] numbers = {1, 0}; 4 | int[] denom = {0, 2}; 5 | 6 | for (int i = 0; i < 2; i++) { 7 | try { 8 | // Essa linha pode lançar uma exceção 9 | int result = numbers[i] / denom[i]; 10 | System.out.println("Result: " + result); 11 | } catch (ArithmeticException | ArrayIndexOutOfBoundsException e) { 12 | // Capturando múltiplas exceções em um bloco catch 13 | System.out.println("Exception caught: " + e); 14 | } 15 | } 16 | 17 | try { 18 | // Tentativa de executar algum código que pode lançar exceções 19 | int result = Integer.parseInt("abc"); 20 | System.out.println("Result: " + result); 21 | } catch (NumberFormatException e) { 22 | // Tratando um tipo diferente de exceção em outro bloco catch 23 | System.out.println("Exception caught: " + e); 24 | } finally { 25 | // Esse bloco sempre será executado 26 | System.out.println("Finally block executed"); 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /Exception Handling/Null Pointer Exception/README.md: -------------------------------------------------------------------------------- 1 | # Lidando com Exceções de Ponteiro Nulo (NullPointerException) 2 | 3 | ## Introdução 4 | Null Pointer Exceptions (Exceções de Ponteiro Nulo) ocorrem quando se tenta acessar ou operar em um objeto que não foi 5 | inicializado, ou seja, tem um valor nulo. 6 | Essas exceções ocorrem porque o programa tenta utilizar uma referência que aponta para nenhum local na memória. 7 | Esta documentação explora cenários comuns em que NullPointerExceptions ocorrem e como você pode lidar com elas de forma eficaz. 8 | 9 | ## Cenários 10 | 11 | Para ilustrar os cenários em que as NullPointerExceptions podem ocorrer, criamos uma classe chamada "Produto" com um único atributo: "descrição". 12 | O objetivo é tentar acessar a descrição desse produto, considerando situações em que o atributo não foi preenchido. 13 | 14 | ```java 15 | public class Produto { 16 | private String descricao; 17 | } 18 | ``` 19 | 20 | ### Acessando a descrição de um objeto nulo 21 | 22 | No primeiro cenário, o objeto "Produto" não é instanciado, e em vez disso, é definido como nulo. 23 | 24 | ```java 25 | public static void mostrarDescricaoObjetoNulo(){ 26 | System.out.println("Produto Nulo:"); 27 | Produto produto = null; 28 | } 29 | ``` 30 | 31 | Como a variável "produto" é do tipo "Produto," ela tem acesso aos métodos da classe "Produto," incluindo "getDescricao." 32 | Ao tentar obter a descrição do produto, uma exceção NullPointerException é lançada, pois estamos tentando acessar um valor que não está armazenado na memória. 33 | 34 | ### Acessando um objeto instanciado sem inicializar seu atributo 35 | 36 | No segundo cenário, um objeto "Produto" é instanciado, mas seu atributo "descricao" não é inicializado explicitamente. 37 | 38 | ```java 39 | public static void mostrarDescricaoNula(){ 40 | System.out.println("Produto Sem Descrição:"); 41 | Produto produto = new Produto(); 42 | } 43 | ``` 44 | 45 | Quando um objeto é criado, os atributos da classe são inicializados com valores padrão, que, no caso de uma String, 46 | é "null". Portanto, ao tentar acessar a descrição usando "getDescricao," uma NullPointerException não é lançada, 47 | pois a descrição tem um valor padrão de "null". 48 | 49 | Para que a exceção fosse lançada, o getter da classe Produto foi modificado. 50 | 51 | ```java 52 | public String getDescricao(){ 53 | if(descricao==null){ 54 | throw new NullPointerException("Descrição não preenchida."); 55 | } 56 | return descricao; 57 | } 58 | ``` 59 | 60 | O método primeiro verifica se "descricao" é nula. Se for, o método lança uma exceção dizendo que a descrição do 61 | produto não foi preenchida. Caso não seja nula, retornará a descrição. 62 | 63 | ### Acessando um objeto instanciado e atributo inicializado 64 | 65 | No terceiro cenário, um objeto "Produto" é instanciado, e o atributo "descricao" é preenchido com um valor. 66 | 67 | ```java 68 | public static void mostrarDescricaoPreenchida(){ 69 | System.out.println("Produto com Descrição:"); 70 | Produto produto = new Produto("Livro 'A Vida de Ada Lovelace'"); 71 | } 72 | ``` 73 | 74 | Ao usar "getDescricao" para obter a descrição do produto, o valor da descrição é retornado, pois agora o atributo "descricao" foi inicializado. 75 | 76 | ## Remediação 77 | 78 | Quando uma exceção é lançada, o programa é interrompido no momento em que a exceção ocorre, a menos que haja tratamento adequado. Para lidar com exceções, você pode usar a estrutura "try/catch" ("tente" e "capture"). 79 | 80 | ```java 81 | public static void main(String[] args){ 82 | try { 83 | mostrarDescricaoPreenchida(); 84 | mostrarDescricaoNula(); 85 | mostrarDescricaoObjetoNulo(); 86 | } catch (NullPointerException e) { 87 | System.err.println(e.getMessage()); 88 | } 89 | } 90 | ``` 91 | 92 | No método "main", chamamos os três cenários mencionados anteriormente. Tudo o que queremos que o programa tente 93 | fazer é colocado dentro do bloco "try". Se ocorrer alguma exceção, o programa entrará no bloco "catch" para tratá-la. 94 | Isso nos permite continuar a execução do programa, mesmo após uma exceção. 95 | 96 | O resultado no terminal será: 97 | 98 | ```bash 99 | Produto com Descrição: 100 | Livro 'A Vida de Ada Lovelace' 101 | Produto Sem Descrição: 102 | Descrição não preenchida. 103 | ``` 104 | 105 | Com tratamento apropriado das exceções, o programa pode continuar a execução sem ser interrompido por exceções de ponteiro nulo. -------------------------------------------------------------------------------- /Exception Handling/Null Pointer Exception/com.npe/java/Produto.java: -------------------------------------------------------------------------------- 1 | public class Produto { 2 | 3 | private String descricao; 4 | 5 | public Produto() { 6 | } 7 | public Produto(String descricao) { 8 | this.descricao = descricao; 9 | } 10 | 11 | public String getDescricao() { 12 | if(descricao == null) { 13 | throw new NullPointerException("Descrição não preenchida."); 14 | } 15 | return descricao; 16 | } 17 | 18 | public void setDescricao(String descricao) { 19 | this.descricao = descricao; 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /Exception Handling/Null Pointer Exception/com.npe/java/ServicoProduto.java: -------------------------------------------------------------------------------- 1 | public class ServicoProduto { 2 | public static void main(String[] args) { 3 | try { 4 | mostrarDescricaoPreenchida(); 5 | mostrarDescricaoNula(); 6 | mostrarDescricaoOjetoNulo(); 7 | 8 | } catch (NullPointerException e) { 9 | System.err.println(e.getMessage()); 10 | } 11 | } 12 | 13 | public static void mostrarDescricaoOjetoNulo() { 14 | System.out.println("Produto Nulo:"); 15 | Produto produto = null; 16 | String descricao = produto.getDescricao(); 17 | System.out.println(descricao); 18 | } 19 | 20 | 21 | public static void mostrarDescricaoNula() { 22 | System.out.println("Produto Sem Descrição:"); 23 | Produto produto = new Produto(); 24 | String descricao = produto.getDescricao(); 25 | System.out.println(descricao); 26 | } 27 | 28 | public static void mostrarDescricaoPreenchida() { 29 | System.out.println("Produto com Descrição:"); 30 | Produto produto = new Produto("Livro 'A Vida de Ada Lovelace'"); 31 | String descricao = produto.getDescricao(); 32 | System.out.println(descricao); 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /Exception Handling/README.md: -------------------------------------------------------------------------------- 1 | # Lidando com exceções em Java 2 | 3 | ### Introdução 4 | 5 | Uma exceção é um evento inesperado ou indesejado que ocorre em tempo de execução e que interrompe o fluxo normal das instruções do programa. O tratamento de exceções em Java é um dos mecanismos poderosos para lidar com erros em tempo de execução, de modo que o fluxo normal da aplicação possa ser mantido. 6 | 7 | Como desenvolvedora ou desenvolvedor Java é essencial, que saibamos lidar com isso. 8 | 9 | ### Como contribuir 10 | 11 | Contribua seguindo os passos: 12 | 13 | 1. Crie um Readme explicando sobre Exceções em Java. 14 | 2. Faça os exercicios que você foi atribuido. 15 | 16 | Go Hacking! -------------------------------------------------------------------------------- /Java Basic Sintax/README.md: -------------------------------------------------------------------------------- 1 | # Sintaxe Básica de Java 2 | 3 | ### Introdução 4 | 5 | Além de ser uma linguagem orientada a objetos, Java tem uma sintaxe básica muito importante. É estruturada em pacotes, com classes contendo métodos. A assinatura de uma classe inclui sua visibilidade e nome, enquanto a de um método inclui seu retorno, nome e parâmetros e seus arquivos tem uma regra clara. Variáveis são declaradas com tipos específicos e nomes, seguindo convenções de nomenclatura, como CamelCase para classes e minúsculas para variáveis. 6 | A sintaxe básica é de extrema importância para compreensão da linguagem. 7 | 8 | # Estrutura de Arquivo Java 9 | 10 | Um arquivo Java segue uma estrutura padrão que inclui várias partes essenciais. Confira abaixo cada uma delas: 11 | 12 | ## 1. Declaração de Pacotes (Package Declaration) 13 | 14 | Pacotes são empregados para agrupar classes afins. Essa abordagem nos permite prevenir conflitos de nomes entre classes, simplificar a manutenção e atualização do código. Além disso, pacotes tornam a localização e identificação de classes, interfaces e enumerações mais acessíveis. 15 | 16 | Exemplo de declaração de pacote: 17 | ```java 18 | package com.example.minhapasta; 19 | ``` 20 | 21 | ## 2. Declaração de Importações (Import Statements) 22 | 23 | As declarações de importações permitem que você use classes de outros pacotes sem a necessidade de especificar o caminho completo toda vez. 24 | 25 | Exemplo de declaração de importações: 26 | ```java 27 | import java.util.ArrayList; 28 | import java.io.File; 29 | ``` 30 | 31 | IMPORTANTE: O termo "import" é uma palavra reservada e não pode ser utilizada para nomear variável. 32 | 33 | ## 3. Declaração de Classe (Class Declaration) 34 | 35 | Uma classe é um modelo usado para definir vários objetos com características semelhantes. Os elementos básicos de uma classe são divididos em duas categorias: 36 | 37 | Exemplo de declaração de classe: 38 | ```java 39 | public class MinhaClasse { 40 | // Conteúdo da classe aqui 41 | } 42 | ``` 43 | 44 | ## 4. Tipos permitidos no arquivo 45 | 46 | Um arquivo Java pode conter os seguintes tipos: 47 | 48 | - **Classes**: Definem objetos e seu comportamento. 49 | - **Interfaces**: Define um contrato que as classes devem seguir. 50 | - **Enums**: Enumerações definem um conjunto de valores constantes. 51 | 52 | ### Exemplo de Arquivo Java 53 | 54 | Aqui está um exemplo de arquivo Java que ilustra os conceitos acima: 55 | 56 | ```java 57 | package com.example.minhapasta; 58 | 59 | import java.util.ArrayList; 60 | import java.io.File; 61 | 62 | // Classe principal 63 | public class MinhaClasse { 64 | 65 | // Atributos 66 | private String nome; 67 | private int idade; 68 | 69 | // Construtor 70 | public MinhaClasse(String nome, int idade) { 71 | this.nome = nome; 72 | this.idade = idade; 73 | } 74 | 75 | // Método da classe 76 | public void saudacao() { 77 | System.out.println("Olá, meu nome é " + nome + " e tenho " + idade + " anos."); 78 | } 79 | 80 | // Enumeração 81 | enum DiaDaSemana { 82 | SEGUNDA, TERÇA, QUARTA, QUINTA, SEXTA, SÁBADO, DOMINGO 83 | } 84 | 85 | // Interface 86 | interface Saudacao { 87 | void cumprimentar(); 88 | } 89 | } 90 | ``` 91 | 92 | # Variáveis 93 | 94 | As variáveis server para nomear\armazenar dados e elas são compostas por: 95 | 96 | - Tipo 97 | - Nome 98 | - Valor 99 | 100 | Por exemplo: 101 | ```java 102 | int pontos = 80; 103 | int jogadas = 3 104 | ``` 105 | 106 | ### Tipo 107 | 108 | Existem dois tipos: 109 | 110 | - Primitivos 111 | Os tipos primitivos são boolea (ex: true\false), byte (ex: 100), char (ex: 'A'), short (ex:-20), int (ex: 98), long(8765456878L), float (ex: 19.99f) e double (ex: 2.1827182763752). 112 | 113 | - Referência 114 | Os tipos por referência, são classes que especificam os tipos de objeto Strings (ex: "Olá!"), Arrays (ex: [1, 2, "a", "u"]) e Objetos(ex: {"fruta": "uva"}). 115 | 116 | 117 | ### Nomemclatura de variáveis 118 | 119 | Existe uma convenção de nomenclatura, que são recomendações para nomear variáveis. O objetivo disso existir é para fazer com que os códigos sigam uma padrão onde qualquer desenvolvedor consiga ler o cõdigo, ou seja, é uma boa prática. 120 | 121 | Confira abaixo algumas delas: 122 | 123 | - Camel case 124 | Camel case deve começar com a primeira letra minúscula e a primeira letra de cada nova palavra subsequente maiúscula 125 | 126 | ```java 127 | coisasParaFazer = ... 128 | 129 | idadeDoAmigo = ... 130 | 131 | valorFinal = ... 132 | ``` 133 | 134 | - Pascal case 135 | Também conhecido como “upper camel case” ou “capital case”, pascal case combina palavras colocando todas com a primeira letra maiúscula 136 | 137 | ```java 138 | CoisasParaFazer = ... 139 | 140 | IdadeDoAmigo = ... 141 | 142 | ValorFinal = ... 143 | ``` 144 | 145 | - Snake case 146 | Em snake case, conhecido também como “underscore case”, utilizamos underline no lugar do espaço para separar as palavras. Quando o snake case está em caixa alta, ele é chamado de “screaming snake case” 147 | 148 | ```java 149 | coisas_para_fazer = ... 150 | 151 | idade_do_amigo = ... 152 | 153 | valor_final = ... 154 | 155 | PRIMEIRO_NOME = ... 156 | 157 | LISTA_INICIAL = ... 158 | ``` 159 | 160 | IMPORTANTE: O Java possui o [Java Secure Coding Guidelines](https://www.oracle.com/java/technologies/javase/codeconventions-namingconventions.html), uma documentação disponibilizada pela Oracle, baseada nos padrões de codificação apresentados no Java Language Specification. É importante ressaltar que essas convenções de código Java foram escritas em 1999 e não foram atualizadas desde então, portanto algumas informações contidas no documento podem não estar atualizadas. As convenções mais comuns são: 161 | 162 | camelCase para variáveis, atributos e métodos; 163 | PascalCase para classes, enum e interfaces; 164 | SCREAMING_SNAKE_CASE para constantes. 165 | 166 | Fontes: 167 | 168 | [Boson Treinamentos em Ciência e Tecnologia](http://www.bosontreinamentos.com.br/java/curso-de-java-o-que-sao-packages-pacotes/#:~:text=Os%20pacotes%20s%C3%A3o%20usados%20para,de%20classes%2C%20interfaces%20e%20enumera%C3%A7%C3%B5es.) 169 | 170 | [DevMedia](https://www.devmedia.com.br/tipos-de-dados-por-valor-e-por-referencia-em-java/25293#:~:text=As%20vari%C3%A1veis%20de%20inst%C3%A2ncia%20de,boolean%20s%C3%A3o%20inicializadas%20como%20false.) 171 | 172 | [ALURA](https://www.alura.com.br/artigos/convencoes-nomenclatura-camel-pascal-kebab-snake-case#camel-case) 173 | -------------------------------------------------------------------------------- /POO/Abstracao/README.md: -------------------------------------------------------------------------------- 1 | # POO - Abstração 2 | Na Programação orientada a objetos(POO), a abstração consiste em simplificar sistemas complexos do mundo real, ocultando detalhes irrelevantes e focando nos aspectos essenciais de objetos e classes. 3 | 4 | ## O que são **classes** e **objetos**? 5 | São os dois principais aspectos da programação orientada a objetos. 6 | As classes são como "moldes" para construção(instanciação) dos objetos. 7 | 8 | ## Abstração em Java 9 | A abstração em Java pode ser representada em classes abstratas ou interfaces. 10 | A palavra reservada *abstract* é um modificador sem acesso usado para classes e métodos: 11 | 12 | - classe abstrata: é uma classe restrita, que não pode ser utilizada para gerar objetos. Para ser acessada, deverá ser *herdada* por outra classe. 13 | - método abstrato: só poder ser usado em classes abstratas e não possui corpo, este será definido na subclasse herdeira. 14 | - classe filha: utiliza a palavra reservada **extends** para indicar a classe da qual herda os métodos abstrados(classe pai). 15 | - notação *@Override*: utilizada para indicar, na classe filha, o método da classe pai que está sendo definido. 16 | 17 | --- 18 | 19 | ## Bibliografia: 20 | - [w3schools - Java](https://www.w3schools.com/java/default.asp) 21 | - [ChatGPT](https://chat.openai.com/) 22 | 23 | 24 | -------------------------------------------------------------------------------- /POO/Abstracao/circulo.java: -------------------------------------------------------------------------------- 1 | package POO.Abstracao; 2 | 3 | public class circulo extends formaGeometrica { 4 | 5 | private double raio; 6 | 7 | @Override 8 | public double area() { 9 | //área do circulo: 10 | return 3.14*this.raio*this.raio; 11 | } 12 | 13 | } 14 | -------------------------------------------------------------------------------- /POO/Abstracao/formaGeometrica.java: -------------------------------------------------------------------------------- 1 | package POO.Abstracao; 2 | 3 | public abstract class formaGeometrica { 4 | 5 | //método que calcula a área da forma geométrica: 6 | public abstract double area(); 7 | } 8 | -------------------------------------------------------------------------------- /POO/Abstracao/quadrado.java: -------------------------------------------------------------------------------- 1 | package POO.Abstracao; 2 | 3 | public class quadrado extends formaGeometrica { 4 | 5 | private double lado; 6 | 7 | @Override 8 | public double area() { 9 | //área do quadrado: 10 | return this.lado * this.lado; 11 | } 12 | 13 | } -------------------------------------------------------------------------------- /POO/Abstracao/triangulo.java: -------------------------------------------------------------------------------- 1 | package POO.Abstracao; 2 | 3 | public class triangulo extends formaGeometrica { 4 | //medidas do triangulo como atributos 5 | private double altura; 6 | private double base; 7 | 8 | @Override 9 | public double area() { 10 | //área do triangulo 11 | return (this.altura*this.base)/2; 12 | } 13 | 14 | } 15 | -------------------------------------------------------------------------------- /POO/Polimorfismo/README.md: -------------------------------------------------------------------------------- 1 | # Polimorfismo 2 | 3 | ## Um dos pilares da programação orientada a objetos (POO) 4 | 5 | Morfologicamente falando ao separar a palava temos _Poli_ que significa muitos, vários e _morfismo_ que está relacionado à forma. 6 | Sendo assim _Polimorfismo_ que dizer "várias formas". 7 | 8 | O polimorfismo permite que objetos de classes diferentes respondam à mesma mensagem ou método de maneiras diferentes. Isso é possível porque objetos de tipos diferentes podem ter métodos com o mesmo nome, mas comportamentos diferentes. 9 | 10 | Portanto, o polimorfismo é uma característica importante da POO, pois torna o código mais versátil e flexível. Isso significa que você pode escrever código que funcione para objetos de várias classes diferentes, desde que essas classes implementem métodos com assinatura igual esperada. 11 | 12 | Podemos pontuar também o fato dele ser complementado pela _herança_ (um outro pilar da POO). 13 | 14 | E por se dividir em dois tipos principais: 15 | - _Sobrecarga_. 16 | - _Sobrescrita_. 17 | 18 | ### Sobrecarga 19 | 20 | A sobrecarga é a capacidade de uma classe ter dois ou mais métodos com o mesmo nome, mas com assinaturas diferentes. A assinatura de um método é composta pelo seu nome, tipo de retorno e lista de parâmetros. 21 | 22 | ### Sobrescrita 23 | 24 | A sobrescrita é a capacidade de uma subclasse substituir o comportamento de um método herdado da superclasse. A sobrescrita requer que o método na subclasse tenha a mesma assinatura do método na superclasse. 25 | 26 | #### Diferenças entre os tipos: 27 | | Característica | Sobrecarga | Sobrescrita | 28 | |---|---|---| 29 | | Definição | Capacidade de uma classe ter dois ou mais métodos com o mesmo nome, mas com assinaturas diferentes | Capacidade de uma subclasse substituir o comportamento de um método herdado da superclasse | 30 | | Assinatura | Diferente | Igual | 31 | | Tipo de retorno | Pode ser diferente | Deve ser o mesmo | 32 | | Lista de parâmetros | Pode ser diferente | Deve ser a mesma | 33 | | Modificadores | Qualquer | Não pode ser `final` ou `static` | 34 | 35 | 36 | ## Referências 37 | 38 | - [Java - Oracle ](https://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html) 39 | 40 | - [UFSC - Prof Frank Siqueira ](http://www.inf.ufsc.br/~frank.siqueira/INE5605/10.Polimorfismo.pdf) 41 | 42 | - [UNESP - Prof Daniel Cardozo Mourao ](https://www.feg.unesp.br/Home/PaginasPessoais/profadanielacardozomourao/polimorfismo.pdf) 43 | 44 | - [UFSM - Flash utilizando Orientação a Objetos e a linguagem XML. ](http://www-usr.inf.ufsm.br/~rose/curso3/cafe/cap4_Polimorfismo.pdf) 45 | -------------------------------------------------------------------------------- /POO/Polimorfismo/exemplos/PolimorfismoSobrecarga.java: -------------------------------------------------------------------------------- 1 | public class PolimorfismoSobrecarga { 2 | 3 | // Método que aceita dois inteiros como argumentos 4 | public int somar(int a, int b) { 5 | return a + b; 6 | } 7 | 8 | // Método que aceita três inteiros como argumentos 9 | public int somar(int a, int b, int c) { 10 | return a + b + c; 11 | } 12 | 13 | // Método que aceita dois números de ponto flutuante como argumentos 14 | public double somar(double a, double b) { 15 | return a + b; 16 | } 17 | 18 | public static void main(String[] args) { 19 | PolimorfismoSobrecarga calculadora = new PolimorfismoSobrecarga(); 20 | 21 | // Chamando o método de soma com dois inteiros 22 | int resultado1 = calculadora.somar(5, 10); 23 | System.out.println("Soma de inteiros: " + resultado1); 24 | 25 | // Chamando o método de soma com três inteiros 26 | int resultado2 = calculadora.somar(5, 10, 15); 27 | System.out.println("Soma de três inteiros: " + resultado2); 28 | 29 | // Chamando o método de soma com dois números de ponto flutuante 30 | double resultado3 = calculadora.somar(3.5, 2.5); 31 | System.out.println("Soma de números de ponto flutuante: " + resultado3); 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /POO/Polimorfismo/exemplos/PolimorfismoSobrescrita.Java: -------------------------------------------------------------------------------- 1 | // Classe pai (superclasse) 2 | class Animal { 3 | public void fazerSom() { 4 | System.out.println("Animal faz algum som"); 5 | } 6 | } 7 | 8 | // Classe filha (subclasse) 9 | class Cachorro extends Animal { 10 | @Override 11 | public void fazerSom() { 12 | System.out.println("Cachorro late"); 13 | } 14 | } 15 | 16 | // Outra classe filha (subclasse) 17 | class Gato extends Animal { 18 | @Override 19 | public void fazerSom() { 20 | System.out.println("Gato mia"); 21 | } 22 | } 23 | 24 | public class PolimorfismoSobrescrita { 25 | public static void main(String[] args) { 26 | Animal meuAnimal; 27 | 28 | meuAnimal = new Cachorro(); 29 | meuAnimal.fazerSom(); // Chama o método sobrescrito da classe Cachorro 30 | 31 | meuAnimal = new Gato(); 32 | meuAnimal.fazerSom(); // Chama o método sobrescrito da classe Gato 33 | } 34 | } -------------------------------------------------------------------------------- /POO/README.md: -------------------------------------------------------------------------------- 1 | Crie um arquivo explicando cada um dos pilares da POO (com exemplos) -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Sobre nossa comunidade 2 | O Devs JavaGirl é uma comunidade tecnológica focada na união de mulheres envolvidas com a linguagem de programação Java, sejam elas desenvolvedoras experientes ou iniciantes. Nosso propósito é promover a inclusão e o aprendizado, proporcionando um ambiente acolhedor para aquelas que codam em Java ou têm interesse no assunto. Aqui, você encontrará um espaço dedicado à troca de conhecimentos e ao fortalecimento de conexões valiosas em tecnologia. 3 | 4 | # java-trainning 5 | Este repositório tem como principal objetivo a disponibilização de conteúdos e exercícios introdutórios de Java. Nele, reunimos materiais fundamentais para a aprendizagem desta linguagem de programação, bem como do paradigma de Orientação a Objetos. Aqui estão presentes os conteúdos e desafios para aprimorar suas habilidades em Java e solidificar sua base nesse universo. 6 | Principais tópicos: 7 | - Conceitos de OO, 8 | - Sintaxe básica da linguagem 9 | - Principais APIs e bibliotecas do Java 10 | - Exercicios 11 | - e muito mais.. 12 | 13 | # Como contribuir 14 | Veja como contribuir para esse repo [aqui](https://github.com/devs-javagirl/java-trainning/blob/9880534b111602b8db240be6aaa9f4d65bed5263/CONTRIBUTING.md) 15 | -------------------------------------------------------------------------------- /Testes/README.md: -------------------------------------------------------------------------------- 1 | Crie um arquivo explicando cada tipo / ferramenta de teste (com exemplos) -------------------------------------------------------------------------------- /java-trainning.iml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | --------------------------------------------------------------------------------