Esta mentoria tem como objetivo ajudar os Devs participantes do Programa GFT Start #5 Java a resolver o Desafio Técnico que será proposto aos selecionados para as vagas oferecidas no fim do Bootcamp.
3 |
🛑 Pré-requistos
4 |
5 | - [x] Java JDK 8+ (Usarei JDK 11)
6 | - [x] IDE para desenvolvimento Java (Usarei IntelliJ Community)
7 | - [x] O básico sobre Git e GitHub
8 | - [x] Sintáxe básica Java
9 | - [x] Noção acerca de POO
10 |
11 |
Pensamento Computacional e Programação Orientada a Objetos
12 |
13 |
Pensamento Computacional
14 |
A capacidade criativa, crítica e estratégica de utilizar as bases computacionais nas diferentes áreas de conhecimento para a resolução de problemas.
15 |
16 |
17 |
18 |
Programação Orientada a Objetos
19 |
Modelo de análise, projeto e programação baseado na aproximação entre o mundo real e o mundo virtual, através da criação e interação entre classes, atributos, métodos, objetos, entre outros.
20 |
21 |
Vantagens da Orientação a Objetos
22 |
23 |
Paradigma mais utilizado no desenvolvimento
24 |
Redução do custo de manutenção
25 |
Aumento de reutilização de código
26 |
Aumento de segurança de sistemas
27 |
Melhor interação entre as fases do projeto
28 |
Torna o trabalho em equipe mais produtivo
29 |
30 |
31 |
32 |
33 |
34 |
EXERCICIOS
35 |
36 |
37 |
38 | Número Reverso:
39 | Faça um programa que leia um valor inteiro (este número deverá conter 4 dígitos). A saída deverá ser o reverso de um número inteiro informado.
40 | Exemplo: Digamos que a entrada foi 3257. A resposta será 7523.
41 |
42 |
43 | Regras:
44 | a) A entrada deverá estar entre 1000 e 9999;
45 | b) Se o usuário digitar 3 dígitos ou menos, o Programa avisa que tem que conter 4 dígitos e continuar a programação até a resposta final.
46 |
47 |
48 |
49 |
50 | Classe Macaco:
51 | Faça um programa e teste interativamente uma classe que modele um macaco com os atributos “nome” e “bucho” (estômago) e os métodos “comer”, “verBucho” e “digerir”.
52 |
53 |
54 | Regras:
55 | a) Crie 2 macacos;
56 | b) Considere que a quantidade máxima de alimentos é 3. Com isso, lembre-se de verificar o conteúdo do estômago a cada refeição (método “comer”). Por fim, o método “digerir” deve esvaziar o bucho do Macaco;
57 | c) Alimentos “digeríveis” devem ser do tipo String, garanta isso em seu código para que não haja nenhum Macaco canibal 🙈.
58 |
59 |
60 |
61 |
62 | Funcionários:
63 | Considerando o diagrama abaixo, feito para uma empresa de vendas. Nesse contexto, utilize o conceito de Herança para remodelá-lo e implemente um programa que explore o domínio em questão:
64 |
65 |
66 |
67 | Regras:
68 | a) Crie uma classe mãe chamada Funcionario com os atributos nome, cpf (passados pelo construtor), uma constante para armazenar o valor do salário mínimo e um método abstrato “calcularSalario”;
69 | b) Vendedores ganham 1 salário mínimo, mais uma comissão por vendas;
70 | c) Consultores ganham somente pelas horas que trabalharam.
71 |
72 |
73 |
74 |
75 |
76 |
DESAFIO
77 |
78 | Jogo de Craps:
79 | Faça um programa que implemente um jogo de Craps. O jogador lança um par de dados, obtendo um valor entre 2 e 12.
80 |
81 | Regras:
82 |
83 | a) Se, na primeira jogada, você tirar 7 ou 11, você é um "Natural" e ganha;
84 | b) Se você tirar 2, 3 ou 12 na primeira jogada, isto é chamado de "Craps" e você perdeu;
85 | c) Se, na primeira jogada, você fez um 4, 5, 6, 8, 9 ou 10, este é seu "Ponto";
86 | d) Seu objetivo agora é continuar jogando os dados até tirar este número novamente;
87 | e) Você perde, no entanto, se tirar um 7 antes de tirar este Ponto novamente;
88 |
89 |
90 |
🤝 Contribuindo
91 |
92 | Este repositório foi criado para fins de estudo, então contribua com ele.
93 | Se te ajudei de alguma forma, ficarei feliz em saber. E caso você conheça alguém que se identidique com o conteúdo, não deixe de compatilhar.
94 |
95 | Se possível:
96 | ⭐️ Star o projeto
97 | 🐛 Encontrar e relatar issues
98 |
99 |
100 |
101 | Disponibilizado com ♥ por [cami-la](https://www.linkedin.com/in/cami-la/ "cami-la").
102 |
103 |
104 |
105 |
106 |
107 |
--------------------------------------------------------------------------------
/desafio-tecnico-GFT.iml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
--------------------------------------------------------------------------------
/desafio-tecnico-GFT/.idea/workspace.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
23 |
24 |
25 |
26 |
27 |
28 |
29 |
30 |
31 |
32 |
33 |
34 |
35 |
36 |
37 |
38 |
39 |
40 |
41 | 1653333786116
42 |
43 |
44 | 1653333786116
45 |
46 |
47 |
48 |
49 |
50 |
51 |
52 |
--------------------------------------------------------------------------------
/src/Main.java:
--------------------------------------------------------------------------------
1 | import desafios.Macaco;
2 | import desafios.NumeroReverso;
3 | import desafios.desafio.JogoCraps;
4 | import desafios.funcionarios.Consultor;
5 | import desafios.funcionarios.Vendedor;
6 |
7 | public class Main {
8 | public static void main(String[] args) {
9 | //NumeroReverso.numeroReverso();
10 |
11 | /*Macaco macaco1 = new Macaco();
12 | Macaco macaco2 = new Macaco();
13 |
14 | macaco1.comer("banana");
15 | macaco1.comer("banana");
16 | macaco1.comer("banana");
17 |
18 |
19 | macaco2.comer("pêra");
20 | macaco2.comer("uva");
21 | macaco2.comer("maçã");
22 | System.out.println("------");
23 | macaco1.digerir();
24 | macaco1.digerir();
25 | macaco1.digerir();
26 | macaco2.digerir();
27 | macaco2.digerir();
28 | macaco2.digerir();
29 | macaco2.digerir();*/
30 |
31 | /*Vendedor vendedor = new Vendedor("Camila Vendedora", 123456789L, 10d, 5);
32 | System.out.println(vendedor.calcularSalario());
33 |
34 | Consultor consultor = new Consultor("Consultor", 789456123L, 100.5d, 10);
35 | System.out.println(consultor.calcularSalario());*/
36 |
37 | JogoCraps.jogar();
38 |
39 |
40 | }
41 | }
--------------------------------------------------------------------------------
/src/desafios/Macaco.java:
--------------------------------------------------------------------------------
1 | package desafios;
2 |
3 | import java.util.ArrayList;
4 | import java.util.List;
5 |
6 | /*
7 | Classe Macaco:
8 | Faça um programa e teste interativamente uma classe que modele um macaco com os atributos “nome”
9 | e “bucho” (estômago) e os métodos “comer”, “verBucho” e “digerir”.
10 |
11 | Regras:
12 | a) Crie 2 macacos;
13 | b) Considere que a quantidade máxima de alimentos é 3. Com isso,
14 | lembre-se de verificar o conteúdo do estômago a cada refeição (método “comer”).
15 | Por fim, o método “digerir” deve esvaziar o bucho do Macaco;
16 | c) Alimentos “digeríveis” devem ser do tipo String, garanta isso em seu código para que não haja
17 | nenhum Macaco canibal.
18 | */
19 | public class Macaco {
20 | //atributos
21 | private String nome;
22 | private List bucho = new ArrayList<>();
23 |
24 | //metodos
25 | public void comer(String comida) {
26 | if (bucho.size() == 3) {
27 | System.out.println("Bucho Cheio!");
28 | } else {
29 | bucho.add(comida);
30 | }
31 | System.out.println(bucho);
32 | }
33 |
34 | public void digerir() {
35 | if (bucho.isEmpty()) {
36 | System.out.println("Bucho Vazio!");
37 | } else {
38 | bucho.remove(bucho.get(0));
39 | }
40 | System.out.println(bucho);
41 | }
42 |
43 | }
44 |
--------------------------------------------------------------------------------
/src/desafios/NumeroReverso.java:
--------------------------------------------------------------------------------
1 | package desafios;
2 |
3 | import java.util.Scanner;
4 |
5 | /*
6 | Número Reverso:
7 | Faça um programa que leia um valor inteiro (este número deverá conter 4 dígitos).
8 | A saída deverá ser o reverso de um número inteiro informado.
9 | Exemplo: Digamos que a entrada foi 3257. A resposta será 7523.
10 |
11 | Regras:
12 | a) A entrada deverá estar entre 1000 e 9999;
13 | b) Se o usuário digitar 3 dígitos ou menos, o Programa avisa que tem que conter 4 dígitos e continuar
14 | a programação até a resposta final.
15 | */
16 | public class NumeroReverso {
17 |
18 | public static void numeroReverso() {
19 | Scanner scan = new Scanner(System.in);
20 | do {
21 | System.out.println("Informe um valor inteiro e positivo (este número deverá conter 4 dígitos): ");
22 | int numeroInformado = scan.nextInt();
23 | String numeroInformadoString = String.valueOf(numeroInformado);
24 | if(numeroInformado >= 1000 && numeroInformado <= 9999) {
25 | StringBuilder stringBuilder = new StringBuilder(numeroInformadoString);
26 | System.out.println(stringBuilder.reverse());
27 | break;
28 | } else if(numeroInformadoString.length() < 4) {
29 | System.out.println("O número informado deverá conter 4 dígitos!");
30 | }
31 | } while(true);
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/src/desafios/desafio/JogoCraps.java:
--------------------------------------------------------------------------------
1 | package desafios.desafio;
2 |
3 | import java.util.Arrays;
4 | import java.util.List;
5 | import java.util.Random;
6 |
7 | public class JogoCraps {
8 | public static void jogar() {
9 | int rodada = 0;
10 | int seuPonto = 0;
11 | //Lembra da etapa da decomposição e abstração?
12 | List natural = Arrays.asList(7, 11); //Valores que representa o NATURAL na primeira rodada - GANHA
13 | List craps = Arrays.asList(2, 3, 12); //Valores que representa o CRAPS na primeira rodada - PERDE
14 | List ponto = Arrays.asList(4, 5, 6, 8, 9, 10); //Valores que representa seu ponto nas demais rodads
15 |
16 | do { //faça
17 | rodada++; //Marca a rodada atual
18 | int dado1 = gerarValorDado(); //lançamento dado 1
19 | int dado2 = gerarValorDado(); //lançamento dado 2
20 | int somaDados = dado1 + dado2; //soma dos dados
21 |
22 | if (rodada == 1) { //Primeiramente, testando as regras para a rodada 1.
23 | if (natural.contains(somaDados)) { //Se a soma dos dados for um natural, você ganha.
24 | System.out.printf("RODADA = %d\n\nVocê tirou %d na rodada %d\nVocê é um NATURAL!\n", rodada, somaDados, rodada);
25 | System.out.println("**** GANHOU ****");
26 | break;
27 | } else if (craps.contains(somaDados)) { //Se a soma dos dados for um Craps, você perde
28 | System.out.printf("RODADA = %d\n\nVocê tirou %d na rodada %d = CRAPS\n", rodada, somaDados, rodada);
29 | System.out.println("**** PERDEU ****");
30 | break;
31 | } else { //Se não, a soma dos dados é seu ponto e você continua jogando.
32 | seuPonto = somaDados;
33 | }
34 | } else { //Testando as regras para as demais rodas
35 | if (somaDados == seuPonto) { //Se a soma dos dados for igual ao seu ponto (definido na primeira rodada), você ganha.
36 | System.out.printf("RODADA = %d\n\nSeu ponto %d é igual soma dos dados %d\n", rodada, seuPonto, somaDados);
37 | System.out.println("**** GANHOU ****");
38 | break;
39 | } else if (somaDados == 7) { //Se a soma dos dados for igual a 7, antes de tirar seu ponto novamente, você ganha.
40 | System.out.printf("RODADA = %d\n\nVocê tirou %d na rodada %d\n", rodada, somaDados, rodada);
41 | System.out.println("**** PERDEU ****");
42 | break;
43 | } else { //Caso não contemple os dos if's anteriores, você continua lançando os dados.
44 | continue;
45 | }
46 | }
47 | } while (true); //Enquanto o laço não é interrompido pelo break.
48 | }
49 |
50 | private static int gerarValorDado() { //método de geração dos valor do dado
51 | Random random = new Random(); //Classe que faz a geração de números aleatórios no Java.
52 | return random.nextInt(6) + 1; //função que gera um número aleatório entre 1 e 6. (Valores possíveis de um dado)
53 | }
54 | }
55 |
56 |
--------------------------------------------------------------------------------
/src/desafios/funcionarios/Consultor.java:
--------------------------------------------------------------------------------
1 | package desafios.funcionarios;
2 |
3 | public class Consultor extends Funcionario {
4 | private double valorHora;
5 | private long horasTrabalhadas;
6 |
7 | public Consultor(String nome, long cpf, double valorHora, long horasTrabalhadas) {
8 | super(nome, cpf);
9 | this.valorHora = valorHora;
10 | this.horasTrabalhadas = horasTrabalhadas;
11 | }
12 |
13 | @Override
14 | public double calcularSalario() {
15 | return valorHora * horasTrabalhadas;
16 | }
17 |
18 | public double getValorHora() {
19 | return valorHora;
20 | }
21 |
22 | public void setValorHora(double valorHora) {
23 | this.valorHora = valorHora;
24 | }
25 |
26 | public long getHorasTrabalhadas() {
27 | return horasTrabalhadas;
28 | }
29 |
30 | public void setHorasTrabalhadas(long horasTrabalhadas) {
31 | this.horasTrabalhadas = horasTrabalhadas;
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/src/desafios/funcionarios/Funcionario.java:
--------------------------------------------------------------------------------
1 | package desafios.funcionarios;
2 | /*
3 | Considerando o diagrama abaixo, feito para uma empresa de vendas.
4 | Nesse contexto, utilize o conceito de Herança para remodelá-lo e implemente um programa que explore
5 | o domínio em questão:
6 |
7 | Regras:
8 | a) Crie uma classe mãe chamada Funcionario com os atributos nome, cpf (passados pelo construtor),
9 | uma constante para armazenar o valor do salário mínimo e um método abstrato “calcularSalario”;
10 | b) Vendedores ganham 1 salário mínimo, mais uma comissão por vendas;
11 | c) Consultores ganham somente pelas horas que trabalharam.
12 | */
13 | public abstract class Funcionario {
14 | private String nome;
15 | private long cpf;
16 | protected final Double SALARIO_MINIMO = 1000.0;
17 |
18 | public Funcionario(String nome, long cpf) {
19 | this.nome = nome;
20 | this.cpf = cpf;
21 | }
22 | public abstract double calcularSalario();
23 |
24 | public String getNome() {
25 | return nome;
26 | }
27 |
28 | public void setNome(String nome) {
29 | this.nome = nome;
30 | }
31 |
32 | public long getCpf() {
33 | return cpf;
34 | }
35 |
36 | public void setCpf(long cpf) {
37 | this.cpf = cpf;
38 | }
39 |
40 | public Double getSALARIO_MINIMO() {
41 | return SALARIO_MINIMO;
42 | }
43 | }
44 |
--------------------------------------------------------------------------------
/src/desafios/funcionarios/Vendedor.java:
--------------------------------------------------------------------------------
1 | package desafios.funcionarios;
2 |
3 | public class Vendedor extends Funcionario {
4 | private double comissao;
5 | private long numeroVendas;
6 |
7 | public Vendedor(String nome, long cpf, double comissao, long numeroVendas) {
8 | super(nome, cpf);
9 | this.comissao = comissao;
10 | this.numeroVendas = numeroVendas;
11 | }
12 |
13 | @Override
14 | public double calcularSalario() {
15 | return super.SALARIO_MINIMO + (this.comissao * this.numeroVendas);
16 | }
17 |
18 | public double getComissao() {
19 | return comissao;
20 | }
21 |
22 | public void setComissao(double comissao) {
23 | this.comissao = comissao;
24 | }
25 |
26 | public long getNumeroVendas() {
27 | return numeroVendas;
28 | }
29 |
30 | public void setNumeroVendas(long numeroVendas) {
31 | this.numeroVendas = numeroVendas;
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
31 |
32 |
33 | 
65 |