Advertisement
LightProgrammer000

Adivinhacao de animais

Apr 17th, 2020
679
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 10.82 KB | None | 0 0
  1. // Pacote
  2. package Tarefas_1;
  3.  
  4. // Bibliotecas
  5. import java.util.Scanner;
  6.  
  7. public class EX_11
  8. {
  9.     // Instanciacao
  10.     static Scanner ent = new Scanner(System.in);
  11.  
  12.     public static void main(String[] args)
  13.     {
  14.         System.out.println("# Programa EX_11");
  15.  
  16.         try
  17.         {
  18.             // Apresentacao
  19.             System.out.println("\n----- Genio da lampada -----\n");
  20.             System.out.println("+ Vou adivinhar o animal que o senhor(a) escolheu dentre os abaixo\n");
  21.  
  22.             // Programa
  23.             exec_program();
  24.         }
  25.  
  26.         catch(Exception e)
  27.         {
  28.             System.err.println(e);
  29.         }
  30.     }
  31.  
  32.     // Metodo: Execucao do programa principal
  33.     private static void exec_program()
  34.     {
  35.         // Variavel
  36.         String animal;
  37.         String[] lista = {"leao", "cavalo", "homem", "macaco", "morcego",
  38.                           "baleia", "avestruz", "pinguim", "pato", "aguia",
  39.                           "tartaruga", "crocodilo", "cobra"};
  40.  
  41.         // Aprensentacao das opcoes
  42.         System.out.println("# Animais possiveis: ");
  43.         for (int i = 0; i < lista.length; i++)
  44.         {
  45.             System.out.printf("[%d]. %s\n",(i + 1), lista[i]);          
  46.         }
  47.  
  48.         while(true)
  49.         {
  50.             // Chamada de funcao
  51.             animal = questionario();
  52.  
  53.             // Estrutura de decisao
  54.             if (!animal.equals("nenhum"))
  55.             {
  56.                 System.out.println("\n---------------- Resultado ----------------");
  57.                 System.out.println("\n# Entao o animal escolhido foi o " + animal);
  58.                 System.out.println("\n-------------------------------------------");
  59.                 System.exit(0);
  60.             }
  61.  
  62.             else
  63.             {
  64.                 System.out.println("\n---------------- Resultado ----------------");
  65.                 System.out.println("\n# Nao consegui adivinhar");
  66.                 System.out.println("\n-------------------------------------------");
  67.             }
  68.         }
  69.     }
  70.  
  71.     // Funcao: Escolha dentre os tipos de animais
  72.     private static String questionario()
  73.     {
  74.         // Variavel
  75.         String opc = null;
  76.  
  77.         // Estrutura em escolha
  78.         switch (animais())
  79.         {
  80.             case "mamiferos":
  81.  
  82.                 // Mamifero
  83.                 opc = mamiferos();
  84.                 break;
  85.  
  86.             case "aves":
  87.  
  88.                 // Aves
  89.                 opc = aves();
  90.                 break;
  91.  
  92.             case "repteis":
  93.  
  94.                 // Repteis
  95.                 opc = repteis();
  96.                 break;
  97.  
  98.             case "nenhum":
  99.                 opc = "nenhum";
  100.  
  101.             default:
  102.                 break;
  103.         }
  104.  
  105.         return opc;
  106.     }
  107.  
  108.     // Funcao: Analise de animais
  109.     private static String animais()
  110.     {
  111.         // Variavel
  112.         String opc;
  113.  
  114.         // Entrada de dados
  115.         System.out.print("\n* Mamifero \n[s] Sim \n[n] Nao \nOpc: ");
  116.         opc = ent.next().toLowerCase();
  117.  
  118.         // Estrutura de decisao: Mamiferos
  119.         if (opc.equals("s"))
  120.         {
  121.             opc = "mamiferos";
  122.         }
  123.  
  124.         else
  125.         {
  126.             System.out.print("\n* Aves \n[s] Sim \n[n] Nao \nOpc: ");
  127.             opc = ent.next().toLowerCase();
  128.  
  129.             // Estrutura de decisao: Aves
  130.             if (opc.equals("s"))
  131.             {
  132.                 opc = "aves";                
  133.             }
  134.  
  135.             else
  136.             {
  137.                 System.out.print("\n* Repteis \n[s] Sim \n[n] Nao \nOpc: ");
  138.                 opc = ent.next().toLowerCase();
  139.  
  140.                 // Estrutura de decisao: Repteis
  141.                 if (opc.equals("s"))
  142.                 {
  143.                     opc = "repteis";                
  144.                 }
  145.  
  146.                 else
  147.                 {
  148.                     opc = "nenhum";
  149.                 }
  150.             }
  151.         }
  152.  
  153.         return opc;
  154.     }
  155.  
  156.     // Funcao: Analise dos mamiferos
  157.     private static String mamiferos()
  158.     {
  159.         // Variavel
  160.         String opc;
  161.  
  162.         // Entrada de dados
  163.         System.out.print("\n* Quadrupede \n[s] Sim \n[n] Nao \nOpc: ");
  164.         opc = ent.next().toLowerCase();
  165.  
  166.         // Estrutura de decisao: Quadrupede
  167.         if(opc.equals("s"))
  168.         {
  169.             System.out.print("\n* Carnivoro \n[s] Sim \n[n] Nao \nOpc: ");
  170.             opc = ent.next().toLowerCase();
  171.  
  172.             // Estrutura em escolha
  173.             switch (opc)
  174.             {
  175.                 // Escolha: Resultado -> leao
  176.                 case "s":
  177.  
  178.                     opc = "leao";
  179.                     break;
  180.  
  181.                 // Escolha: Herbivoro
  182.                 case "n":
  183.  
  184.                     System.out.print("\n* Herbivoro \n[s] Sim \n[n] Nao \nOpc: ");
  185.                     opc = ent.next().toLowerCase();
  186.  
  187.                     // Estrutura de decisao: Resultado -> cavalo
  188.                     if (opc.equals("s"))
  189.                     {
  190.                         opc = "cavalo";
  191.                     }
  192.  
  193.                     else
  194.                     {
  195.                         opc = "nenhum";
  196.                     }
  197.  
  198.                     break;
  199.  
  200.                 default:
  201.                     break;
  202.             }
  203.         }
  204.  
  205.         else
  206.         {
  207.             System.out.print("\n* Bipedes \n[s] Sim \n[n] Nao \nOpc: ");
  208.             opc = ent.next().toLowerCase();
  209.  
  210.             // Estrutura de decisao: Bipedes
  211.             if (opc.equals("s"))
  212.             {
  213.                 System.out.print("\n* Onivoros \n[s] Sim \n[n] Nao \nOpc: ");
  214.                 opc = ent.next().toLowerCase();
  215.  
  216.                 // Estrutura em escolha
  217.                 switch (opc)
  218.                 {
  219.                     // Escolha: Resultado -> homem
  220.                     case "s":
  221.  
  222.                         opc = "homem";
  223.                         break;
  224.  
  225.                     // Escolha: Frutivoros
  226.                     case "n":
  227.  
  228.                         System.out.print("\n* Frutivoros \n[s] Sim \n[n] Nao \nOpc: ");
  229.                         opc = ent.next().toLowerCase();
  230.  
  231.                         // Estrutura de decisao: Resultado -> Macaco
  232.                         if (opc.equals("s"))
  233.                         {
  234.                             opc = "Macaco";
  235.                         }
  236.  
  237.                         else
  238.                         {
  239.                             opc = "nenhum";
  240.                         }
  241.  
  242.                         break;
  243.  
  244.                     default:
  245.                         break;
  246.                 }
  247.             }
  248.  
  249.             // Estrutura de decisao: Voadores
  250.             else
  251.             {
  252.                 System.out.print("\n* Voadores \n[s] Sim \n[n] Nao \nOpc: ");
  253.                 opc = ent.next().toLowerCase();
  254.  
  255.                 // Estrutura em escolha
  256.                 switch (opc)
  257.                 {
  258.                     // Escolha: Resultado -> Morcego
  259.                     case "s":
  260.  
  261.                         opc = "morcego";
  262.                         break;
  263.  
  264.                     // Escolha: Aquaticos
  265.                     case "n":
  266.  
  267.                         System.out.print("\n* Aquaticos \n[s] Sim \n[n] Nao \nOpc: ");
  268.                         opc = ent.next().toLowerCase();
  269.  
  270.                         if (opc.equals("s"))
  271.                         {
  272.                             opc = "baleia";
  273.                         }
  274.  
  275.                         else
  276.                         {
  277.                             opc = "nenhum";
  278.                         }
  279.  
  280.                         break;
  281.  
  282.                     default:
  283.                         break;
  284.                 }
  285.             }
  286.         }
  287.  
  288.         return opc;
  289.     }
  290.    
  291.     private static String aves()
  292.     {
  293.         // Variavel
  294.         String opc;
  295.  
  296.         // Entrada de dados
  297.         System.out.print("\n* Nao-voadoras \n[s] Sim \n[n] Nao \nOpc: ");
  298.         opc = ent.next().toLowerCase();
  299.        
  300.         // Estrutura de decisao: Nao-voadoras
  301.         if(opc.equals("s"))
  302.         {
  303.             System.out.print("\n* Tropicais \n[s] Sim \n[n] Nao \nOpc: ");
  304.             opc = ent.next().toLowerCase();
  305.  
  306.             // Estrutura em escolha
  307.             switch (opc)
  308.             {
  309.                 // Escolha: Resultado -> Avestruz
  310.                 case "s":
  311.  
  312.                     opc = "avestruz";
  313.                     break;
  314.  
  315.                 // Escolha: Polares
  316.                 case "n":
  317.  
  318.                     System.out.print("\n* Polares \n[s] Sim \n[n] Nao \nOpc: ");
  319.                     opc = ent.next().toLowerCase();
  320.  
  321.                     // Estrutura de decisao: Polares
  322.                     if (opc.equals("s"))
  323.                     {
  324.                         opc = "pinguim";
  325.                     }
  326.  
  327.                     else
  328.                     {
  329.                         opc = "nenhum";
  330.                     }
  331.  
  332.                     break;
  333.  
  334.                 default:
  335.                     break;
  336.             }
  337.         }
  338.  
  339.         else
  340.         {
  341.             System.out.print("\n* Nadadoras \n[s] Sim \n[n] Nao \nOpc: ");
  342.             opc = ent.next().toLowerCase();
  343.  
  344.             // Estrutura de decisao: Nadadoras
  345.             if (opc.equals("s"))
  346.             {
  347.                 opc = "pato";  
  348.             }
  349.  
  350.             else
  351.             {
  352.                 System.out.print("\n* De rapina \n[s] Sim \n[n] Nao \nOpc: ");
  353.                 opc = ent.next().toLowerCase();
  354.  
  355.                 // Estrutura de decisao: De rapina
  356.                 if (opc.equals("s"))
  357.                 {
  358.                     opc = "aguia";                    
  359.                 }
  360.  
  361.                 else
  362.                 {
  363.                     opc = "nenhum";
  364.                 }
  365.             }
  366.         }
  367.  
  368.         return opc;
  369.     }
  370.    
  371.     private static String repteis()
  372.     {
  373.         // Variavel
  374.         String opc;
  375.  
  376.         // Entrada de dados
  377.         System.out.print("\n* Com casco \n[s] Sim \n[n] Nao \nOpc: ");
  378.         opc = ent.next().toLowerCase();
  379.  
  380.         // Estrutura de decisao: Com casco
  381.         if(opc.equals("s"))
  382.         {
  383.             opc = "tartaruga";
  384.         }
  385.  
  386.         else
  387.         {
  388.             System.out.print("\n* Carnivoros \n[s] Sim \n[n] Nao \nOpc: ");
  389.             opc = ent.next().toLowerCase();
  390.            
  391.             // Estrutura de decisao: Carnivoros
  392.             if (opc.equals("s"))
  393.             {
  394.                 opc = "crocodilo";  
  395.             }
  396.  
  397.             else
  398.             {
  399.                 System.out.print("\n* Sem patas \n[s] Sim \n[n] Nao \nOpc: ");
  400.                 opc = ent.next().toLowerCase();
  401.  
  402.                 // Estrutura de decisao: Sem patas
  403.                 if (opc.equals("s"))
  404.                 {
  405.                     opc = "cobra";                    
  406.                 }
  407.  
  408.                 else
  409.                 {
  410.                     opc = "nenhum";
  411.                 }
  412.             }
  413.         }
  414.  
  415.         return opc;
  416.     }
  417. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement