{"subject_id":"3a3cc48d0099814e8930ff97da2b8a68","topico":"Java: JVM/JDK/JRE, POO, coleções, exceções checked × unchecked, streams, Spring","stems":["Julgue os itens a seguir, relativos a clean code e às linguagens de programação COBOL e Java.","No que diz respeito aos servidores de aplicação Java, julgue os itens que se seguem.","Acerca dos conceitos fundamentais relativos a padrões de projeto e modelagem, julgue os itens a seguir.","Julgue os itens a seguir, relativos a Java, Swagger, PostgreSQL e JSON.","A respeito de desenvolvimento de sistemas, julgue os itens a seguir.","Julgue o próximo item, relativo ao framework Hibernate.","A respeito de arquiteturas de microsserviços, julgue os itens que se seguem.","Julgue os próximos itens, relativos a Java, API RESTful e JSON.","Julgue os itens subsequentes, referentes a Python e Java.","Julgue os itens que se seguem, referentes a HTML, CSS e JavaScript, Python e Java.","Julgue os próximos itens, relativos a Spring Eureka, Zuul, Map Struct, service discovery e Swagger.","No que concerne a Java, Zuul e Spring Cloud, julgue os itens a seguir.","Acerca de desenvolvimento de sistemas, julgue os próximos itens.","Julgue os itens seguintes, com base nos conceitos de linguagem de programação Ruby e Java.","Em relação à linguagem de programação Java, julgue o item a seguir.","Julgue os próximos itens, relativos a Java, JavaScript e Python.","Acerca das tecnologias que atendem a PDPJ-Br, julgue os próximos itens.","Com relação ao padrão MVC (Model View Controller), a padrões de projeto e a orientação a objetos, julgue os itens subsequentes.","Julgue o próximo item, relativo a Java.","A respeito de linguagens de programação, julgue os itens seguintes.","A respeito de linguagens de programação, julgue os próximos itens.","Com relação às linguagens de programação Java e PHP, julgue os itens a seguir.","Determinado sistema tem duas classes, Carro e Bicicleta. Ambas têm atributos como marca e modelo, além de métodos próprios, mas compartilham uma classe-pai comum de nome Veiculo. A partir dessa situação hipotética, julgue o item a seguir, a respeito de herança em orientação a objetos.","Julgue os próximos itens, relativos a controle de dados, compilação e engenharia de software.","No que se refere a testes de verificação de qualidade de códigos automatizados e a persistência, julgue os próximos itens.","Considerando linguagens de programação, julgue os itens que se seguem.","Julgue os itens a seguir, relacionados a desenvolvimento web em Java.","A respeito de programação estruturada e orientada a objetos, julgue os itens subsequentes.","Acerca de Spring Boot, julgue os itens que se seguem.","A respeito de engenharia de software, julgue os itens subsecutivos.","Julgue os itens a seguir, relativos a Python e Java.","Julgue os itens que se seguem, a respeito de Python, Java e orientação a objetos.","Com relação aos conceitos de Spring Boot, Net Core e thread, julgue os itens seguintes.","Julgue os próximos itens, relativos a Hibernate Envers e Swagger.","No que se refere a Shell Script e a Java, julgue os itens a seguir.","Julgue os itens subsequentes, relativos a JVM, NGINX e Jboss.","Julgue os itens a seguir, a respeito de projeto e desenvolvimento de sistemas.","Julgue os seguintes itens, relativos a linguagens de programação.","Julgue o item seguinte a respeito de conceitos em Java.","Com relação a linguagens de programação, julgue os itens a seguir.","Com base nos fundamentos da Engenharia de Software, julgue os itens a seguir relativos às decisões adequadas que devem ser tomadas pelas equipes de analistas quando do planejamento para o desenvolvimento de um novo sistema.","Julgue os próximos itens, a respeito de Spring Framework, JDBC, iText, Java 8 e Apache CXF.","No que se refere a banco de dados relacional (SQL) e não relacional (NoSQL) e ao framework JPA, julgue os itens subsecutivos.","Acerca de programação orientada a objetos, Java e PHP, julgue os itens a seguir.","Julgue os itens a seguir, a respeito da linguagem de programação Java.","Com relação ao uso dos frameworks AngularJS e Hibernate, julgue os itens a seguir.","Julgue o item a seguir, acerca de formato de arquivos Java para implantação.","Julgue os próximos itens, relativos a lógica de programação e linguagens de programação.","Julgue os itens que se seguem, a respeito de EJB, Clean Code, desenvolvimento orientado a testes, lógica de programação e paradigmas de programação.","Considerando o trecho de código precedente, com a definição de algumas variáveis, julgue os itens a seguir.","Acerca de padrões de projeto, JSE e JME, julgue os itens a seguir.","A respeito de construção de sistemas, julgue os itens subsequentes.","A respeito das tecnologias relacionadas ao desenvolvimento web em Java, julgue os itens a seguir.","No que se refere ao desenvolvimento de sistemas e às linguagens de programação Java e JavaScript, julgue os itens a seguir.","A respeito dos conceitos de análise orientada a objetos em engenharia de software, julgue os seguintes itens.","Acerca de análise e projetos orientados a objetos, julgue os itens que se seguem.","A linguagem Java, amplamente utilizada em programação web, permite que o desenvolvedor seja independente de fornecedores de software, uma vez que Java é um software livre. Com referência a esse assunto, julgue os itens subsecutivos.","Acerca dos servidores de aplicação JEE e Red Hat JBoss, julgue os itens subsequentes."],"questions":[{"id":"459b858f35bb","number":51,"stem":0,"statement":"A linguagem Java utiliza ponteiros para o gerenciamento de endereços de memória, o que garante mais segurança para o uso do Garbage Collector.","answer":"E","source":{"slug":"INFRASA_26_ANALISTA","ano":2026},"explanation":{"verdict_reason":"Java não expõe ponteiros nem aritmética de endereços: o que existe são referências, cujo endereço o programador não lê nem manipula. Justamente essa ausência é o que viabiliza o coletor de lixo, que pode mover objetos no heap sem invalidar nada — com ponteiros na mão do programador, não poderia.","distortion_type":"troca_de_termo","distorted_span":"utiliza ponteiros para o gerenciamento de endereços de memória","corrected_statement":"A linguagem Java utiliza referências, e não ponteiros, para o acesso a objetos em memória, o que garante mais segurança para o uso do Garbage Collector.","concept":"Java tem referências, não ponteiros","citation":null,"trap_note":"Referência não permite aritmética, não pode ser convertida em inteiro e não é liberada manualmente. Sempre que o item der ponteiros a Java, a relação de causa que ele constrói em seguida também cai."}},{"id":"bf03cb904477","number":15,"stem":1,"statement":"Um enterprise bean de sessão permite que aplicativos Java EE processem mensagens de forma assíncrona, semelhantemente a um ouvinte de eventos.","answer":"E","source":{"slug":"TCE_RS_25","ano":2025},"explanation":{"verdict_reason":"Quem processa mensagens de forma assíncrona, atuando como ouvinte de uma fila ou tópico JMS, é o message-driven bean. O session bean implementa a lógica de negócio invocada diretamente pelo cliente, de forma síncrona, seja com estado (stateful) ou sem estado (stateless).","distortion_type":"troca_de_termo","distorted_span":"Um enterprise bean de sessão","corrected_statement":"Um enterprise bean orientado a mensagem permite que aplicativos Java EE processem mensagens de forma assíncrona, semelhantemente a um ouvinte de eventos.","concept":"Session bean é síncrono; message-driven bean é assíncrono","citation":null,"trap_note":"Três famílias de EJB: sessão (síncrono, com ou sem estado), orientado a mensagem (assíncrono, via JMS) e, nas versões antigas, entidade (persistência, substituída pela JPA). A palavra assíncrono aponta sempre para o message-driven."}},{"id":"7ed137e803a9","number":51,"stem":2,"statement":"Encapsulamento consiste em ocultar os detalhes internos de implementação de um objeto, expondo apenas uma interface bem definida.","answer":"C","source":{"slug":"TELEBRAS_25","ano":2025},"explanation":{"verdict_reason":"Ocultar a implementação interna e expor apenas um contrato estável é a definição corrente de encapsulamento, também chamada de ocultação de informação. Quem consome o objeto depende do que ele promete, não de como ele guarda os dados — o que permite mudar o interior sem quebrar o cliente.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"Encapsulamento como ocultação de informação","citation":null,"trap_note":"Encapsulamento esconde o como; abstração escolhe o que é relevante representar. Quando o item falar em ocultar detalhes internos, a resposta é encapsulamento, mesmo que a palavra abstração apareça na alternativa vizinha."}},{"id":"956322e196b3","number":61,"stem":3,"statement":"Considere o código em Java a seguir, especialmente em relação aos valores descritos na notação JSON.\n\nimport java.util.Arrays;\nimport java.util.Collections;\npublic class JsonSortDescendingExample {\n  public static void main(String[] args) {\n   String jsonString =\n“{\\”TJPA\\”:[\\”Tribunal\\”,\\”Justica\\”,\\”Estado\\”\n,\\”Para\\”]}”;\n   String arrayContent =\njsonString.substring(\n     jsonString.indexOf(“[“) + 1,\n     jsonString.indexOf(“]”)\n   );\n   String[] values =\narrayContent.replaceAll(“\\”“, ““).split(“,”);\n   Arrays.sort(values,\nCollections.reverseOrder());\n   // Exibindo os valores ordenados\n   System.out.println(“Resultado:”);\n   for (int i = values.length - 1; i >= 0; i--)\n{\n   System.out.println(values[i]);\n   }\n  }\n}\n\nEsse código, ao ser executado, apresentará o resultado a seguir.\n\n   Resultado:\n   Estado\n   Justica\n   Para\n   Tribunal\nCREATE TABLE processos (\n   idproc INT PRIMARY KEY,\n   descricao VARCHAR(50),\n   referencia INT REFERENCES processos(idproc)\n);\nINSERT INTO processos (idproc, descricao,\nreferencia) VALUES\n(1, 'Gabinete', NULL),\n(2, 'Processo A', 1),\n(3, 'Processo B', 2),\n(4, 'Recurso 1', 3);","answer":"C","source":{"slug":"TJ_PA_25_SERVIDOR","ano":2025},"explanation":{"verdict_reason":"Duas inversões se cancelam. O Arrays.sort com Collections.reverseOrder deixa o vetor em ordem decrescente — Tribunal, Para, Justica, Estado — mas o laço percorre de values.length-1 até 0, ou seja, de trás para frente, imprimindo Estado, Justica, Para e Tribunal, que é a ordem crescente e é exatamente o resultado apresentado.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"Ordenação decrescente percorrida de trás para frente","citation":null,"trap_note":"Em item de código, conte as inversões antes de responder: ordenar ao contrário e percorrer ao contrário devolve a ordem original. A banca aposta que você para de ler no reverseOrder."}},{"id":"8ab6e33130df","number":61,"stem":4,"statement":"A linguagem Java permite herança múltipla de classes, de modo que uma classe pode ser subclasse de outras duas classes diretamente.","answer":"E","source":{"slug":"TELEBRAS_25","ano":2025},"explanation":{"verdict_reason":"Java admite apenas herança simples de classes: uma classe estende no máximo uma outra, decisão tomada para evitar a ambiguidade do problema do diamante. A herança múltipla existe em Java apenas no plano de tipos, pela implementação de várias interfaces.","distortion_type":"inversao","distorted_span":"permite herança múltipla de classes","corrected_statement":"A linguagem Java não permite herança múltipla de classes, de modo que uma classe não pode ser subclasse de outras duas classes diretamente.","concept":"Herança simples de classes, múltipla de interfaces","citation":null,"trap_note":"Em Java: extends aceita uma classe, implements aceita várias interfaces. C++ e Python permitem herança múltipla de classes; Java e C# não. Item que conceda a Java o que é do C++ está errado."}},{"id":"a34d623c453b","number":69,"stem":5,"statement":"O método persist() do EntityManager é utilizado para inserir uma nova entidade no banco de dados, sendo lançada uma exceção caso a entidade já esteja associada ao contexto de persistência e com o mesmo identificador.","answer":"E","source":{"slug":"FUB_25","ano":2025},"explanation":{"verdict_reason":"Pela especificação da JPA, chamar persist() sobre uma instância que já está gerenciada no contexto de persistência é simplesmente ignorado — a operação não tem efeito e não lança exceção. O EntityExistsException surge em situação diferente: quando a entidade já existe no banco ou quando se tenta persistir uma instância desanexada.","distortion_type":"inversao","distorted_span":"sendo lançada uma exceção caso a entidade já esteja associada ao contexto de persistência e com o mesmo identificador","corrected_statement":"O método persist() do EntityManager é utilizado para inserir uma nova entidade no banco de dados, sendo a operação ignorada caso a entidade já esteja associada ao contexto de persistência e com o mesmo identificador.","concept":"persist sobre entidade já gerenciada é ignorado","citation":null,"trap_note":"Os estados da JPA decidem quase tudo: nova, gerenciada, desanexada e removida. persist promove nova para gerenciada e ignora a já gerenciada; merge é que serve à desanexada. Item que confunda os estados troca o comportamento do método."}},{"id":"ed56aa57b81d","number":74,"stem":6,"statement":"O MapStruct exige que todas as propriedades dos objetos de origem e destino tenham exatamente o mesmo nome; caso contrário, o mapeamento falhará durante a compilação.","answer":"E","source":{"slug":"TJ_PA_25_SERVIDOR","ano":2025},"explanation":{"verdict_reason":"O MapStruct trabalha por convenção sobre configuração: propriedades de mesmo nome são mapeadas sozinhas, mas quando os nomes divergem existe a anotação @Mapping, com os atributos source e target, justamente para declarar a correspondência. A exigência absoluta descrita no item não existe.","distortion_type":"generalizacao","distorted_span":"exige que todas as propriedades dos objetos de origem e destino tenham exatamente o mesmo nome","corrected_statement":"O MapStruct mapeia automaticamente as propriedades de origem e destino que tenham o mesmo nome; quando os nomes divergem, a correspondência é declarada com a anotação @Mapping.","concept":"Convenção sobre configuração admite configuração explícita","citation":null,"trap_note":"Convenção sobre configuração nunca significa ausência de configuração: significa que o padrão vale quando você não diz nada. Item que transforme a convenção em exigência rígida está errado por generalização."}},{"id":"4369c71ceb67","number":86,"stem":7,"statement":"A execução do código a seguir, escrito em Java, retornará o resultado True.\n\npackage com.mcnz.recursion;\npublic class checkpgm {\n  public static void main(String[] args) {\n    boolean flag = Check(\"STM\");\n    System.out.println(flag);\n  }\n  public static boolean Check(String s){\n    if(s.length() == 0 || s.length() == 1) {\n      return true;\n    }\n    if(s.charAt(0) == s.charAt(s.length()-1)) {\n      return Check(s.substring(1, s.length()-\n1));\n    }\n    return false;\n  }\n}","answer":"E","source":{"slug":"STM_25","ano":2025},"explanation":{"verdict_reason":"O método compara o primeiro com o último caractere para decidir se a palavra é palíndromo. Em STM, o primeiro caractere é S e o último é M: como são diferentes, a execução cai direto no return false, sem nem chegar à chamada recursiva. O programa imprime false.","distortion_type":"inversao","distorted_span":"retornará o resultado True","corrected_statement":"A execução do código a seguir, escrito em Java, retornará o resultado false.","concept":"Verificação recursiva de palíndromo","citation":null,"trap_note":"Antes de seguir a recursão, teste a primeira comparação: se ela já decide, o resto do código é decoração. E lembre que Java imprime booleanos em minúsculas, false e true — não True."}},{"id":"b60650ceb031","number":88,"stem":7,"statement":"A execução do seguinte código, escrito em Java, resultará um código JSON válido.\n\npublic class CriaJson {\n    public static void main(String[] args)\n{\n        String json = \"{\\n\" +\n                      \"\\\"nome\\\":\n\\\"Supremo\\\";\\n\" +\n                      \"\\\"nome\\:\n\\\"Tribunal\\\";\\n\" +\n                      \"\\\"nome\\\":\n\\\"Militar\\\"\\n\" +\n         System.out.println(json);\n    }\n}","answer":"E","source":{"slug":"STM_25","ano":2025},"explanation":{"verdict_reason":"A cadeia montada usa ponto e vírgula para separar os pares em vez de vírgula, deixa uma das chaves com as aspas mal escapadas e repete três vezes a mesma chave nome. Nenhuma dessas construções é aceita pela gramática JSON, de modo que o texto impresso não é um documento JSON válido.","distortion_type":"troca_de_termo","distorted_span":"resultará um código JSON válido","corrected_statement":"A execução do seguinte código, escrito em Java, resultará em um texto que não é um código JSON válido, pois os pares são separados por ponto e vírgula.","concept":"Separador de pares em JSON é a vírgula","citation":null,"trap_note":"Em JSON, vírgula separa pares e dois-pontos separa chave de valor; chave é sempre string entre aspas duplas e não se repete no mesmo objeto. Item de JSON mal formado quase sempre troca a vírgula por ponto e vírgula."}},{"id":"c457096a5595","number":96,"stem":8,"statement":"import java.util.*;\n\npublic class Prova {\n  public static void main(String[] args) {\n    Set<String> conjunto = new HashSet<>();\n    conjunto.add(“Java”);\n    conjunto.add(“Python”);\n    conjunto.add(“Javascript”);\n    conjunto.add(“Java”);\n    System.out.println(conjunto);\n  }\n}\n\nO código Java precedente, ao ser executado, apresentará o resultado a seguir.\n\n   [Java, Javascript, Python]\n<html>\n  <table border=1>\n    <tr>\n      <td rowspan=2> abcd </td>\n      <td colspan=2> efgh </td>\n    </tr>\n    <tr>\n      <td> ijkl </td>\n      <td rowspan=2> mnop </td>\n    </tr>\n      <tr> <td colspan=2> rstu </td>\n    </tr>\n  </table>\n</html>","answer":"C","source":{"slug":"TJ_PA_25_SERVIDOR","ano":2025},"explanation":{"verdict_reason":"O contrato de Set é não admitir elementos duplicados: a segunda inserção de Java é descartada e o conjunto fica com três elementos, e não quatro. É essa eliminação da duplicata que a questão cobra, e o conteúdo impresso confere com o conjunto resultante.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"Set não admite elementos duplicados","citation":null,"trap_note":"List aceita repetição e mantém a ordem de inserção; Set recusa repetição, e o HashSet não promete ordem nenhuma (quem mantém a de inserção é o LinkedHashSet, quem ordena é o TreeSet). Quase todo item de coleção se decide nessas duas linhas."}},{"id":"5a85ee087277","number":102,"stem":9,"statement":"No Java, versão 21, o bloqueio de uma virtual thread, por exemplo, em uma operação de I/O, bloqueia a platform thread subjacente.","answer":"E","source":{"slug":"SUSEP_25","ano":2025},"explanation":{"verdict_reason":"A razão de ser das virtual threads do Java 21 é exatamente o contrário: quando a virtual thread bloqueia em I/O, ela é desmontada da platform thread que a carregava, liberando essa carrier thread para executar outra virtual thread. Se o bloqueio propagasse para a thread do sistema operacional, o modelo não traria ganho algum sobre as threads tradicionais.","distortion_type":"inversao","distorted_span":"bloqueia a platform thread subjacente","corrected_statement":"No Java, versão 21, o bloqueio de uma virtual thread, por exemplo, em uma operação de I/O, não bloqueia a platform thread subjacente, que fica livre para executar outra virtual thread.","concept":"Virtual thread desmonta da carrier thread ao bloquear","citation":null,"trap_note":"Virtual thread é barata porque o bloqueio não custa uma thread do sistema operacional. Guardada essa frase, qualquer item que faça o bloqueio se propagar para baixo se resolve sozinho."}},{"id":"229fc610bc5a","number":109,"stem":10,"statement":"Swagger é um conjunto de ferramentas de código aberto construídas em torno da especificação OpenAPI que permite projetar, criar, documentar e consumir APIs REST.","answer":"C","source":{"slug":"STM_25","ano":2025},"explanation":{"verdict_reason":"O Swagger é o conjunto de ferramentas construído em torno da especificação OpenAPI — editor, gerador de código e interface de teste —, cobrindo o ciclo de projetar, documentar e consumir APIs REST a partir de um mesmo documento descritivo.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"Swagger como ferramental da especificação OpenAPI","citation":null,"trap_note":"OpenAPI é a especificação, Swagger é o ferramental em torno dela. Item que chame o Swagger de especificação, ou que o descreva como framework de construção da API, trocou os papéis."}},{"id":"39824a7346b0","number":110,"stem":10,"statement":"No contexto do framework Spring, o service discovery é um dos princípios fundamentais de uma arquitetura baseada em microsserviços, pois, quando um cliente se registra no servidor Eureka, este receberá heartbeat messages de cada instância pertencente a um serviço e, caso a mensagem falhe em um horário configurável, a instância poderá ser removida do registro.","answer":"C","source":{"slug":"STM_25","ano":2025},"explanation":{"verdict_reason":"É o funcionamento do Eureka: cada instância se registra no servidor e passa a enviar heartbeats periódicos; se o servidor deixa de recebê-los dentro do intervalo configurado, considera a instância indisponível e a retira do registro, de modo que os clientes parem de encaminhar requisições para ela.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"Service discovery por registro e heartbeat no Eureka","citation":null,"trap_note":"Descoberta de serviços existe porque, em microsserviços, instâncias sobem e descem com endereços variáveis. Registro mais heartbeat mais expiração é o mesmo trio no Eureka, no Consul e no etcd."}},{"id":"5713aa345122","number":111,"stem":10,"statement":"MapStruct é um gerador de código que permite realizar a implementação de mapeamentos entre tipos de bean Java com base em uma abordagem de convenção sobre configuração, permitindo gerar mapeamentos de bean em tempo de compilação.","answer":"C","source":{"slug":"STM_25","ano":2025},"explanation":{"verdict_reason":"O MapStruct é um processador de anotações: a partir de uma interface anotada, ele gera em tempo de compilação a classe que copia propriedade a propriedade entre os beans, usando convenção sobre configuração para os nomes coincidentes. Por gerar código, não há reflexão em tempo de execução.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"MapStruct gera o mapeamento em tempo de compilação","citation":null,"trap_note":"Geração em tempo de compilação é o diferencial declarado do MapStruct frente a mapeadores baseados em reflexão: erros aparecem no build e não em produção, e não há custo de reflexão na execução."}},{"id":"a5e47629be86","number":112,"stem":10,"statement":"Zuul é um gateway de aplicativos L7 que fornece recursos para roteamento dinâmico e monitoramento, além de permitir avaliar os limites de desempenho e capacidade de sistemas, com vistas a ajustar políticas de escalonamento automático.","answer":"C","source":{"slug":"STM_25","ano":2025},"explanation":{"verdict_reason":"O Zuul é o gateway de borda da pilha Netflix, operando em camada 7: roteia dinamicamente as requisições HTTP para os serviços internos, aplica filtros e coleta métricas de tráfego, o que fornece a base para avaliar limites de desempenho e alimentar políticas de escalonamento automático.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"Zuul como gateway de borda em camada 7","citation":null,"trap_note":"Gateway de aplicação trabalha em camada 7 e decide por URL, cabeçalho e método; balanceador de camada 4 decide por IP e porta. A distinção de camada é o que separa Zuul e Ingress de um balanceador comum."}},{"id":"55e726a25cab","number":51,"stem":11,"statement":"No código a seguir, desenvolvido em Java, a substituição dos caracteres #XPTO por @extends fará que a execução do código apresente BMW x3 como resultado.\n\npublic class Veiculo {\n  protected String nome;\n  public Veiculo(String nome) {\n    this.nome = “BMW”;\n  }\n  public void Modelo() {\n  }\n  public static void main(String[] args) {\n    Veiculo Veiculo = new Veiculo(““);\n    Veiculo.Modelo();\n    Veiculo bmw = new Veiculo(““) {\n      public void Modelo() {\n        System.out.println(nome + “ “ + “x3”);\n    };\n    bmw.Modelo();\n  }\n}","answer":"E","source":{"slug":"CPNUJE_24","ano":2024},"explanation":{"verdict_reason":"Não existe anotação @extends em Java: extends é palavra reservada usada na declaração de uma classe, e não pode aparecer precedida de arroba nem substituir o corpo de uma classe anônima. A sobrescrita mostrada no código já é feita pela classe anônima, cuja anotação cabível seria @Override.","distortion_type":"troca_de_termo","distorted_span":"a substituição dos caracteres #XPTO por @extends","corrected_statement":"No código a seguir, desenvolvido em Java, a substituição dos caracteres #XPTO por @Override fará que a execução do código apresente BMW x3 como resultado.","concept":"extends é palavra reservada, não anotação","citation":null,"trap_note":"Palavra reservada e anotação não se confundem: extends, implements e class não aceitam arroba; @Override, @Deprecated e @FunctionalInterface são anotações. Item que transforme palavra-chave em anotação inventa sintaxe."}},{"id":"dd7d4c0c70e3","number":53,"stem":11,"statement":"O Spring Cloud fornece ferramentas para os desenvolvedores criarem rapidamente alguns dos padrões comuns em sistemas distribuídos, como, por exemplo, gerenciamento de configuração e descoberta de serviços.","answer":"C","source":{"slug":"CPNUJE_24","ano":2024},"explanation":{"verdict_reason":"É a descrição oficial do projeto: o Spring Cloud reúne implementações prontas dos padrões recorrentes de sistemas distribuídos — configuração centralizada, descoberta de serviços, roteamento, disjuntor, rastreamento distribuído —, integradas ao Spring Boot.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"Spring Cloud implementa padrões de sistemas distribuídos","citation":null,"trap_note":"Spring Boot resolve a aplicação isolada; Spring Cloud resolve o conjunto de aplicações. Config Server, Eureka, Gateway e Circuit Breaker são os quatro nomes que aparecem com mais frequência."}},{"id":"5f14d6932ed8","number":57,"stem":12,"statement":"Em Java, uma das maneiras de se implementar o polimorfismo é a partir de interfaces que permitem o tratamento de objetos de classes diferentes de forma uniforme.","answer":"C","source":{"slug":"TRT10_24","ano":2024},"explanation":{"verdict_reason":"Uma interface define um tipo comum que classes sem qualquer parentesco podem implementar; uma referência daquele tipo pode então apontar para objetos de qualquer uma delas, e a chamada é despachada para a implementação concreta em tempo de execução. É polimorfismo obtido sem herança de classe.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"Interface como fonte de polimorfismo","citation":null,"trap_note":"Polimorfismo não exige superclasse comum: basta um tipo comum, que pode ser interface. É o que permite tratar de modo uniforme classes que nada compartilham na hierarquia."}},{"id":"29fc4d9bfbc9","number":57,"stem":13,"statement":"Ao se utilizar a estrutura try-catch-finally para tratar certos tipos de erros em um programa Java, as instruções do bloco finally são úteis para realizar operações, independentemente do resultado do bloco try.","answer":"C","source":{"slug":"MP_GO_24_SERVIDOR","ano":2024},"explanation":{"verdict_reason":"O bloco finally é executado tanto quando o try termina normalmente quanto quando uma exceção é lançada e capturada — e mesmo quando não é capturada, ou quando há um return dentro do try. É por isso que ele é o lugar próprio para liberar recursos, como fechar conexão ou arquivo.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"finally executa em qualquer desfecho do try","citation":null,"trap_note":"finally sempre executa (salvo System.exit ou parada da JVM). Item que condicione o finally à ocorrência de exceção, ou que o faça pular quando há return, inverteu a regra."}},{"id":"4575ff40db7d","number":61,"stem":14,"statement":"Durante a execução do código a seguir, ocorrerá uma exceção ArithmeticException.\n\npublic class Main {\n  public static void main(String[] args) {\n     int numero = 10;\n     int divisor = 0;\n     try {\n       int resultado = numero / divisor;\n       System.out.println(“Resultado: “ +\n          resultado);\n     } catch (ArithmeticException e) {\n     e.printStackTrace();\n  }\n}","answer":"C","source":{"slug":"MP_TO_24_SERVIDOR","ano":2024},"explanation":{"verdict_reason":"A divisão de inteiros por zero lança ArithmeticException com a mensagem de divisão por zero, e é isso que ocorre na linha numero dividido por divisor. Por ser uma exceção não verificada, o código compila mesmo sem tratamento — aqui há o catch, que recebe a exceção e imprime a pilha.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"ArithmeticException na divisão inteira por zero","citation":null,"trap_note":"Divisão inteira por zero lança exceção; divisão de ponto flutuante por zero não lança nada e devolve Infinity ou NaN. O tipo dos operandos decide o comportamento, e a banca usa isso nos dois sentidos."}},{"id":"63ee5af60ab3","number":63,"stem":15,"statement":"class Main {\n\n public static void main(String[] args) {\n   char[] letras = {'M', 'P', 'G', 'O'};\n   for (char x: letras) {\n     System.out.println(x);\n   }\n }\n}\n\nConsiderando-se que o código precedente foi desenvolvido em Java, é correto afirmar que o resultado, após sua execução, será","answer":"E","source":{"slug":"MP_GO_24_SERVIDOR","ano":2024},"explanation":{"verdict_reason":"O for-each percorre o vetor na ordem em que os elementos foram declarados, sem ordenar nada, e o println dentro do laço emite uma quebra de linha a cada iteração. A saída é, portanto, M, P, G e O, um caractere por linha e nessa ordem — não uma única linha nem uma sequência reordenada.","distortion_type":"troca_de_termo","distorted_span":"o resultado, após sua execução, será","corrected_statement":"Considerando-se que o código precedente foi desenvolvido em Java, é correto afirmar que o resultado, após sua execução, será M, P, G e O, cada um em uma linha.","concept":"for-each preserva a ordem do array; println quebra linha","citation":null,"trap_note":"Duas coisas decidem itens desse formato: o for-each não ordena e não reindexa, apenas percorre; e print continua na mesma linha enquanto println muda de linha. Confira qual dos dois o código usa antes de decidir o formato da saída."}},{"id":"e5e27d9fb1b5","number":63,"stem":16,"statement":"O JPA 2.0 suporta coleções do tipo embeddable, que são classes com dados a serem persistidos, mas que não são entidades.","answer":"C","source":{"slug":"CNJ_24","ano":2024},"explanation":{"verdict_reason":"A JPA 2.0 ampliou o suporte a embeddables, inclusive em coleções, com @ElementCollection: são classes cujos dados são persistidos junto com a entidade dona, mas que não têm identidade própria nem tabela de identidade, e portanto não são entidades.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"Embeddable é persistido sem identidade própria","citation":null,"trap_note":"O que separa entidade de embeddable é a identidade: entidade tem chave e ciclo de vida próprios, embeddable vive dentro do dono e morre com ele. A mesma distinção decide se cabe @Entity ou @Embeddable."}},{"id":"e9b346af64e0","number":64,"stem":17,"statement":"O trecho de código a seguir exemplifica um polimorfismo em Java, pois a classe Gerente implementa de maneira específica o método recebeSalario, ao mesmo tempo em que compartilha parte da funcionalidade da classe\n\nEmpregado.\nclass Empregado {\n  private String nome;\n  private double salario;\n  public Empregado(String nome, double\n       salario) {\n       this.nome = nome;\n       this.salario = salario;\n  }\n  public double recebeSalario() {\n       return salario;\n  }\n}\nclass Gerente extends Empregado{\n   private double bonus;\n public Gerente(String nome, double\n        salario, double bonus) {\n     super(nome, salario);\n     this.bonus = bonus;\n  }\n@Override\n  public double recebeSalario() {\n   return super.recebeSalario() + bonus;\n  }\n}\nclass FolhaPagamento {\n   public static void main(String[] args) {\n   Gerente gerente = new Gerente(“Luiza”,\nSystem.out.println(gerente.recebeSalario());\n}\n}","answer":"C","source":{"slug":"MP_TO_24_SERVIDOR","ano":2024},"explanation":{"verdict_reason":"Gerente estende Empregado e redefine recebeSalario com @Override, mantendo a mesma assinatura e chamando super.recebeSalario() antes de acrescentar o bônus. É o caso típico de polimorfismo por sobrescrita: o mesmo método, invocado sobre objetos de tipos diferentes, executa comportamento próprio de cada um e ainda reaproveita a implementação herdada.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"Sobrescrita com chamada a super como polimorfismo","citation":null,"trap_note":"A presença de @Override com mesma assinatura, mais uma chamada a super, é a assinatura visual do polimorfismo por sobrescrita. Se a lista de parâmetros mudasse, seria sobrecarga e não haveria sobrescrita alguma."}},{"id":"39e867bcb00a","number":67,"stem":18,"statement":"import java.io.*;\n\nclass Easy\n{\n   public static void main(String[] args)\n   {\n     int x[] = {1, 3, 7, 22, 51};\n     for (int size : x)\n       System.out.print(size);\n   }\n}\n\nO resultado da execução do código precedente, desenvolvido em Java, será 6.","answer":"E","source":{"slug":"TRF6_24","ano":2024},"explanation":{"verdict_reason":"No for-each, a variável de laço recebe cada elemento do array, e o nome size não muda isso: ela vale 1, depois 3, depois 7, 22 e 51. Como se usa print, e não println, os valores saem concatenados na mesma linha, resultando em 1372251. O número 6 corresponderia ao tamanho do array, que o código nunca consulta.","distortion_type":"numero_errado","distorted_span":"será 6","corrected_statement":"O resultado da execução do código precedente, desenvolvido em Java, será 1372251.","concept":"for-each percorre elementos, não índices nem tamanho","citation":null,"trap_note":"Nome de variável não tem significado para o compilador. A banca batiza a variável de size, count ou index exatamente para induzir a leitura errada — leia o tipo e a posição na sintaxe, não o nome."}},{"id":"96ff3208d3dd","number":70,"stem":16,"statement":"Em Java, uma subclasse herda os membros, campos e métodos de sua superclasse direta, podendo acrescentar novos membros, desde que mantenha intactos os membros herdados.","answer":"E","source":{"slug":"CNJ_24","ano":2024},"explanation":{"verdict_reason":"A subclasse pode sobrescrever os métodos herdados, redefinindo-lhes o comportamento, e pode ocultar campos declarando outro de mesmo nome. A condição de manter intactos os membros herdados não existe — se existisse, não haveria sobrescrita nem polimorfismo dinâmico em Java.","distortion_type":"generalizacao","distorted_span":"desde que mantenha intactos os membros herdados","corrected_statement":"Em Java, uma subclasse herda os membros, campos e métodos de sua superclasse direta, podendo acrescentar novos membros e também sobrescrever os membros herdados.","concept":"A subclasse pode sobrescrever o que herdou","citation":null,"trap_note":"Herdar não é congelar. Expressões como desde que mantenha, sem alterar e sem modificar, aplicadas ao que a subclasse recebe, negam a sobrescrita e tornam o item errado."}},{"id":"8b5c14e875cf","number":71,"stem":16,"statement":"As interfaces do Java permitem que objetos de classes não relacionadas sejam processados de forma polimórfica.","answer":"C","source":{"slug":"CNJ_24","ano":2024},"explanation":{"verdict_reason":"Duas classes sem qualquer relação de herança passam a compartilhar um tipo comum ao implementarem a mesma interface, e podem então ser referenciadas e tratadas por esse tipo. O despacho da chamada vai para a implementação de cada uma, que é o comportamento polimórfico.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"Interface permite polimorfismo entre classes não relacionadas","citation":null,"trap_note":"Polimorfismo por interface é o que sustenta padrões como Strategy e Observer, em que os participantes só compartilham o contrato. Não confunda com herança: aqui não há superclasse comum."}},{"id":"65e868bc5e6a","number":73,"stem":19,"statement":"A execução da instrução abaixo, escrita em Java, gerará um erro, pois a inicialização de um array bidimensional deve ter todos os elementos com as mesmas quantidades. int[][] matriz = {{1, 2}, {3, 4, 5}}","answer":"E","source":{"slug":"MPO_24","ano":2024},"explanation":{"verdict_reason":"Em Java, um array bidimensional é um array de arrays, e cada linha é um objeto independente que pode ter comprimento próprio. A inicialização com {{1, 2}, {3, 4, 5}} cria um array irregular perfeitamente válido, sem erro de compilação nem de execução.","distortion_type":"generalizacao","distorted_span":"a inicialização de um array bidimensional deve ter todos os elementos com as mesmas quantidades","corrected_statement":"A execução da instrução abaixo, escrita em Java, não gerará erro, pois a inicialização de um array bidimensional admite linhas com quantidades diferentes de elementos. int[][] matriz = {{1, 2}, {3, 4, 5}}","concept":"Arrays irregulares (jagged) são válidos em Java","citation":null,"trap_note":"Array de arrays admite linhas desiguais; é por isso que se usa matriz[i].length, e não um único length para tudo. Item que exija retangularidade importa uma regra de outras linguagens."}},{"id":"9851a86cea82","number":75,"stem":20,"statement":"No relacionamento de herança de objetos, uma superclasse tem a mesma quantidade de objetos que o somatório dos objetos de suas subclasses.","answer":"C","source":{"slug":"PREF_CACHOEIRO_24_ADM","ano":2024},"explanation":{"verdict_reason":"Vale a relação é-um: todo objeto de uma subclasse é também um objeto da superclasse. Numa hierarquia de especialização em que a superclasse serve apenas para generalizar — e por isso não é instanciada diretamente —, o conjunto de suas instâncias é a união das instâncias das subclasses, de modo que as quantidades coincidem.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"Relação é-um: instância de subclasse também é instância da superclasse","citation":null,"trap_note":"Herança não cria dois objetos, cria um objeto que pertence a dois tipos. É esse mesmo raciocínio que sustenta o polimorfismo: a referência da superclasse aponta para o objeto da subclasse porque ele já é do tipo da superclasse."}},{"id":"6a6ffce88c88","number":76,"stem":20,"statement":"Os bytecodes gerados pelo compilador Java independem da plataforma em que são executados, diferentemente das instruções em linguagem de máquina.","answer":"C","source":{"slug":"PREF_CACHOEIRO_24_ADM","ano":2024},"explanation":{"verdict_reason":"O javac não produz código de máquina, e sim bytecode, um formato intermediário destinado a uma máquina abstrata. O mesmo arquivo .class roda em qualquer plataforma que tenha uma JVM, ao passo que instruções em linguagem de máquina são específicas do processador e do sistema operacional para os quais foram geradas.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"Bytecode independe de plataforma; código de máquina não","citation":null,"trap_note":"A portabilidade do Java está no bytecode, não na JVM: a JVM é que precisa existir em versão própria para cada plataforma. Item que inverta isso — bytecode específico e JVM universal — está errado."}},{"id":"d6ec633cec51","number":79,"stem":20,"statement":"A linguagem Java suporta arrays multidimensionais de forma direta, sem a necessidade de manipulação em cascata de arrays unidimensionais ou bidimensionais.","answer":"E","source":{"slug":"PREF_CACHOEIRO_24_ADM","ano":2024},"explanation":{"verdict_reason":"Em Java não existe array multidimensional propriamente dito: int[][] é um array cujos elementos são referências para outros arrays, o que a linguagem manipula em cascata. É justamente por isso que as linhas podem ter comprimentos diferentes e que matriz[i].length faz sentido linha a linha.","distortion_type":"troca_de_termo","distorted_span":"de forma direta, sem a necessidade de manipulação em cascata","corrected_statement":"A linguagem Java suporta arrays multidimensionais na forma de arrays de arrays, com manipulação em cascata de arrays unidimensionais.","concept":"Array multidimensional em Java é array de arrays","citation":null,"trap_note":"Array de arrays explica tudo o que cai sobre matrizes em Java: linhas de tamanhos diferentes são legais, cada linha é um objeto próprio, e new int[3][] cria só a primeira dimensão."}},{"id":"cbf7b9a3675f","number":91,"stem":21,"statement":"Na linguagem Java, os tipos int, char e long são exemplos de dados elementares, e os tipos matrizes e vetores são dados estruturados da linguagem.","answer":"C","source":{"slug":"PREF_CACHOEIRO_24_ADM","ano":2024},"explanation":{"verdict_reason":"int, char e long são tipos primitivos: guardam um único valor, têm tamanho fixo e não são objetos. Vetores e matrizes são estruturas que agregam vários elementos sob um mesmo identificador, com acesso indexado — daí a classificação em dados elementares e dados estruturados.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"Tipos primitivos × tipos estruturados","citation":null,"trap_note":"Java tem oito primitivos: byte, short, int, long, float, double, char e boolean. String não está na lista — é classe, e por isso é o exemplo preferido da banca para item de tipo primitivo."}},{"id":"4db94cefc0c5","number":93,"stem":22,"statement":"As classes Carro e Bicicleta fazem parte de uma estrutura de herança hierárquica, na qual os métodos e funcionalidades das subclasses são automaticamente sobrepostos e eliminados pelos da classe-pai Veiculo.","answer":"E","source":{"slug":"STJ_24","ano":2024},"explanation":{"verdict_reason":"A herança funciona no sentido contrário: a subclasse recebe os membros da superclasse e pode acrescentar novos ou sobrescrever os herdados. Nada do que Carro e Bicicleta definem é apagado por Veiculo — quando há sobrescrita, é a versão da subclasse que prevalece na chamada.","distortion_type":"inversao","distorted_span":"automaticamente sobrepostos e eliminados pelos da classe-pai Veiculo","corrected_statement":"As classes Carro e Bicicleta fazem parte de uma estrutura de herança hierárquica, na qual os métodos e funcionalidades da classe-pai Veiculo são herdados pelas subclasses, que podem sobrescrevê-los.","concept":"Herança flui da superclasse para a subclasse","citation":null,"trap_note":"Monte a seta antes de ler o item: superclasse define, subclasse herda, estende e pode sobrescrever. Qualquer enunciado em que a classe-pai apague ou sobreponha o que a filha definiu está com a seta invertida."}},{"id":"caa2d59f2c98","number":94,"stem":23,"statement":"Na linguagem Java, existe um mecanismo próprio de gerenciamento de memória denominado garbage collector.","answer":"C","source":{"slug":"PREF_CACHOEIRO_24_ADM","ano":2024},"explanation":{"verdict_reason":"A JVM incorpora o coletor de lixo, que identifica os objetos do heap que já não são alcançáveis por nenhuma referência viva e recupera a memória ocupada por eles, sem que o programa precise liberá-la explicitamente.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"Gerenciamento automático de memória pela JVM","citation":null,"trap_note":"O critério do coletor é alcançabilidade, não contagem de uso: objeto que ninguém alcança a partir das raízes é lixo, mesmo que dois objetos inalcançáveis apontem um para o outro. É o que resolve o problema das referências cíclicas."}},{"id":"0a88fb9842ca","number":99,"stem":24,"statement":"No JPA 2.0, a exceção OptimisticLockException pode ocorrer na tentativa de atualizar ou remover uma entidade modificada por outra transação, independentemente de controle de versão aplicado à entidade.","answer":"E","source":{"slug":"TRF6_24","ano":2024},"explanation":{"verdict_reason":"O bloqueio otimista da JPA depende de um atributo de versão marcado com @Version: é comparando essa versão na hora da escrita que o provedor detecta que outra transação alterou a linha e lança OptimisticLockException. Sem controle de versão na entidade não há como detectar o conflito, de modo que a exceção não ocorre independentemente desse controle.","distortion_type":"generalizacao","distorted_span":"independentemente de controle de versão aplicado à entidade","corrected_statement":"No JPA 2.0, a exceção OptimisticLockException pode ocorrer na tentativa de atualizar ou remover uma entidade modificada por outra transação, desde que haja controle de versão aplicado à entidade.","concept":"Bloqueio otimista exige @Version","citation":null,"trap_note":"Bloqueio otimista compara versões no momento da escrita e só funciona com @Version; bloqueio pessimista trava a linha no banco e não precisa dele. Expressões como independentemente de, sempre e em qualquer caso costumam apagar exatamente o pré-requisito que decide o item."}},{"id":"fbb914c6782c","number":103,"stem":25,"statement":"O código Java a seguir, após executado, apresentará 140 como resultado.\n\npublic class Main{\n  public static void main(String[] args) {\n    int soma=0;\n    for (int i = 5; i >= 1; i--) {\n      for (int j = 1; j <= i; j++) {\n        soma += j*i;\n    }\n    System.out.println(soma);\n  }\n}","answer":"C","source":{"slug":"SEPLAG_CE_24","ano":2024},"explanation":{"verdict_reason":"O laço externo vai de i igual a 5 até 1 e o interno acumula j*i com j de 1 até i, o que equivale a i vezes a soma de 1 até i. As parcelas são 75, 40, 18, 6 e 1, que somadas dão 140 — o valor final impresso.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"Laço aninhado com acumulador: somatório de i vezes a soma de 1 até i","citation":null,"trap_note":"Quando o acumulador é declarado fora dos dois laços, ele não zera a cada volta. Monte a tabela de uma linha por iteração do laço externo em vez de tentar prever o total de cabeça."}},{"id":"17622983342a","number":53,"stem":26,"statement":"Em JDBC, o uso da interface PreparedStatement para a execução de consultas deve ser feito em casos específicos, já que a consulta é compilada em tempo de execução.","answer":"E","source":{"slug":"CNMP_23","ano":2023},"explanation":{"verdict_reason":"O PreparedStatement é justamente a escolha padrão em JDBC, e não uma exceção: a instrução é pré-compilada pelo banco, o plano é reaproveitado nas execuções seguintes e os parâmetros viajam separados do texto SQL, o que neutraliza injeção de SQL. O item inverte a recomendação e ainda usa como justificativa exatamente a característica que a favorece.","distortion_type":"inversao","distorted_span":"deve ser feito em casos específicos","corrected_statement":"Em JDBC, o uso da interface PreparedStatement para a execução de consultas deve ser a regra, já que a consulta é pré-compilada e reaproveitada, além de proteger contra injeção de SQL.","concept":"PreparedStatement é o padrão, não a exceção","citation":null,"trap_note":"Statement × PreparedStatement × CallableStatement: o primeiro é SQL estático montado por concatenação, o segundo é pré-compilado e parametrizado, o terceiro chama procedimento armazenado. Item que recomende o Statement, ou restrinja o PreparedStatement, inverteu a boa prática."}},{"id":"4c46c7ff48ea","number":54,"stem":26,"statement":"A partir do Java 8 é possível ter métodos concretos em interfaces, o que permite evoluir uma interface sem que haja comprometimento à compatibilidade.","answer":"C","source":{"slug":"CNMP_23","ano":2023},"explanation":{"verdict_reason":"O Java 8 introduziu os métodos default e os métodos static em interfaces exatamente para resolver o problema da evolução: antes, acrescentar um método a uma interface publicada quebrava toda classe que já a implementava. Com implementação padrão na própria interface, o novo método passa a existir sem obrigar ninguém a escrevê-lo.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"Métodos default no Java 8 e compatibilidade retroativa","citation":null,"trap_note":"Interface com método concreto existe desde o Java 8 (default e static) e, desde o Java 9, também com método private. Item que afirme que interface em Java nunca tem corpo de método está preso à versão 7."}},{"id":"fb1075713f1e","number":66,"stem":27,"statement":"Em programação orientada a objetos, abstração é a propriedade que permite que um método de determinado nome tenha comportamentos distintos, em função de diferentes parâmetros recebidos.","answer":"E","source":{"slug":"SEFIN_FORTALEZA_CE_23","ano":2023},"explanation":{"verdict_reason":"O que o item descreve — mesmo nome de método com comportamentos distintos conforme os parâmetros recebidos — é sobrecarga, uma forma de polimorfismo estático. Abstração é outra coisa: representar do objeto real apenas os aspectos relevantes ao problema, ignorando os demais. A definição está correta; o nome que a assina é que foi trocado.","distortion_type":"troca_de_termo","distorted_span":"abstração é a propriedade que permite que um método de determinado nome tenha comportamentos distintos","corrected_statement":"Em programação orientada a objetos, polimorfismo é a propriedade que permite que um método de determinado nome tenha comportamentos distintos, em função de diferentes parâmetros recebidos.","concept":"Abstração × polimorfismo (sobrecarga)","citation":null,"trap_note":"Leia a definição primeiro e decida sozinho qual palavra ela nomeia; só depois olhe o substantivo do item. Abstração é modelagem, encapsulamento é esconder dado atrás de método, herança é reaproveitar, polimorfismo é mesmo nome com comportamentos diferentes."}},{"id":"e0aa7be4a517","number":85,"stem":28,"statement":"O uso do comando spring init é capaz de criar um novo projeto.","answer":"C","source":{"slug":"DATAPREV_23","ano":2023},"explanation":{"verdict_reason":"O comando spring init faz parte do Spring Boot CLI e é o equivalente em linha de comando ao Spring Initializr: ele gera a estrutura de um novo projeto, com o arquivo de build, as dependências escolhidas e a classe principal anotada.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"spring init gera projeto pelo Spring Boot CLI","citation":null,"trap_note":"Spring Initializr pela web, spring init pela linha de comando: os dois geram o mesmo esqueleto. Depois disso, spring run executa e o empacotamento fica com Maven ou Gradle."}},{"id":"66817d5f895a","number":86,"stem":28,"statement":"Como pré-requisito para a execução de um spring boot, é necessário ter uma versão válida do Java instalado.","answer":"C","source":{"slug":"DATAPREV_23","ano":2023},"explanation":{"verdict_reason":"Spring Boot é framework Java: a aplicação é compilada em bytecode e depende de uma JVM compatível para executar, além de exigir o JDK para compilar. Sem uma versão válida de Java instalada não há onde o artefato rodar.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"Spring Boot exige JVM compatível","citation":null,"trap_note":"Servidor embutido não substitui a JVM: o Spring Boot dispensa instalar Tomcat externo, não dispensa o Java. Cada versão do Spring Boot exige uma faixa mínima de versão do JDK."}},{"id":"4593f1fb1083","number":87,"stem":28,"statement":"GraalVM native images possibilitam deploy de aplicações Java e, quando comparadas a uma imagem JVM (Java virtual machine) padrão, consomem mais memória e, como consequência, possuem um tempo de inicialização maior.","answer":"E","source":{"slug":"DATAPREV_23","ano":2023},"explanation":{"verdict_reason":"É exatamente o contrário. A native image do GraalVM compila a aplicação antecipadamente em binário nativo, dispensando o carregamento de classes e o aquecimento do JIT; o resultado consome menos memória e inicia em frações do tempo de uma JVM padrão. O preço está no tempo de compilação e na perda de otimizações dinâmicas, não na inicialização.","distortion_type":"inversao","distorted_span":"consomem mais memória e, como consequência, possuem um tempo de inicialização maior","corrected_statement":"GraalVM native images possibilitam deploy de aplicações Java e, quando comparadas a uma imagem JVM (Java virtual machine) padrão, consomem menos memória e possuem um tempo de inicialização menor.","concept":"Compilação AOT reduz memória e tempo de inicialização","citation":null,"trap_note":"Compilação antecipada troca desempenho de pico e flexibilidade por partida rápida e consumo baixo — é o motivo de ela existir em cenários serverless e de contêiner. Item que atribua à native image os defeitos da JVM padrão inverteu a razão de ser da tecnologia."}},{"id":"3b0257304ccd","number":89,"stem":29,"statement":"Herança é uma característica do paradigma orientado a objetos, a qual possibilita que haja hierarquia de classes, de forma que as alterações em uma classe-pai possam ser imediatamente propagadas para a classe-filha.","answer":"C","source":{"slug":"DATAPREV_23","ano":2023},"explanation":{"verdict_reason":"A herança cria a hierarquia de classes e o vínculo é vivo: o que se altera na classe-pai passa a valer para as filhas, que não guardam cópia dos membros herdados. É esse reaproveitamento com propagação que torna a herança um mecanismo de manutenção, e não apenas de reuso.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"Herança propaga alterações da classe-pai para as filhas","citation":null,"trap_note":"Propagação automática é a vantagem e o risco da herança: mudança na superclasse atinge toda a hierarquia, o que é a base da crítica ao uso excessivo de herança frente à composição."}},{"id":"e85c933eeb2b","number":94,"stem":30,"statement":"Considere o seguinte código desenvolvido em Java.\n\npublic class Main {\n  public static void main(String[] args) {\n    int resultado = fun(3);\n    System.out.println(resultado);\n  }\n  public static int fun(int y) {\n    if (y > 1) {\n      return y + fun(y - 1);\n    } else {\n      return 0;\n    }\n  }\n}\n\nAo ser executado, esse código apresentará o seguinte resultado.","answer":"E","source":{"slug":"BCB_24","ano":2023},"explanation":{"verdict_reason":"A recursão devolve y + fun(y-1) enquanto y for maior que 1 e devolve 0 no caso-base. Assim fun(3) é 3 + fun(2), fun(2) é 2 + fun(1) e fun(1) cai no else devolvendo 0: o total impresso é 5, e não a soma 1+2+3 que a leitura apressada sugere.","distortion_type":"numero_errado","distorted_span":"esse código apresentará o seguinte resultado","corrected_statement":"Ao ser executado, esse código apresentará 5 como resultado.","concept":"Caso-base da recursão devolvendo 0, não 1","citation":null,"trap_note":"Em item de recursão, o que decide quase sempre é o caso-base. Some a série à mão a partir da última chamada para cima: trocar um retorno 0 por 1 muda o resultado inteiro, e é justamente ali que a banca mexe."}},{"id":"64389bc40b52","number":108,"stem":31,"statement":"Após ser executado, o código em Java a seguir apresentará 20 como resultado.\n\ninterface Foo{int x = 10;}\npublic class Acme {\n  public static void main(String[] args) {\n     Foo.x = 20;\n     System.out.println(Foo.x);\n  }\n}","answer":"E","source":{"slug":"SEFIN_FORTALEZA_CE_23","ano":2023},"explanation":{"verdict_reason":"Todo campo declarado em uma interface é implicitamente public, static e final. Logo, x vale 10 e é constante: a linha Foo.x = 20 é atribuição a uma variável final e o código sequer compila, não chegando a imprimir valor algum.","distortion_type":"numero_errado","distorted_span":"apresentará 20 como resultado","corrected_statement":"Após ser executado, o código em Java a seguir não apresentará resultado, pois não compila: campos de interface são implicitamente final.","concept":"Campo de interface é public static final","citation":null,"trap_note":"Em interface, campo é constante e método é abstrato por padrão — não é preciso escrever as palavras. Item que atribui valor a campo de interface, ou que declara campo de instância nela, está errado antes de qualquer cálculo."}},{"id":"cbef254b8c1e","number":110,"stem":32,"statement":"Spring Boot é uma tecnologia que se integra a ferramentas e linguagens de desenvolvimento web a fim de otimizar seu código, a partir de pequenos ajustes e trocas para deixar mais rápido o resultado do código.","answer":"E","source":{"slug":"SEFIN_FORTALEZA_CE_23","ano":2023},"explanation":{"verdict_reason":"Spring Boot não otimiza código alheio: ele é uma camada sobre o Spring Framework que elimina configuração por convenção, aplica autoconfiguração e embute o servidor de aplicação, de modo que a aplicação suba como um JAR executável. O que o item descreve — ajustes e trocas para acelerar o resultado do código — é trabalho de otimizador ou de profiler, não do framework.","distortion_type":"atribuicao_errada","distorted_span":"a fim de otimizar seu código, a partir de pequenos ajustes e trocas para deixar mais rápido o resultado do código","corrected_statement":"Spring Boot é uma tecnologia que se integra a ferramentas e linguagens de desenvolvimento web a fim de acelerar a criação de aplicações Spring, a partir de autoconfiguração, dependências agrupadas e servidor embutido.","concept":"Spring Boot é autoconfiguração, não otimização de código","citation":null,"trap_note":"Quando o item atribui a um framework um efeito de desempenho no código do usuário, desconfie. Framework organiza e configura; quem mexe no código gerado é o compilador, o JIT ou um otimizador dedicado."}},{"id":"c8a677726c2e","number":111,"stem":32,"statement":"Thread é um pequeno conjunto de instruções projetadas para serem agendadas e executadas pela CPU de forma independente do processo-pai.","answer":"C","source":{"slug":"SEFIN_FORTALEZA_CE_23","ano":2023},"explanation":{"verdict_reason":"A thread é a unidade de escalonamento: um fluxo de instruções que o escalonador do sistema operacional despacha para a CPU por conta própria, ainda que compartilhe o espaço de endereçamento do processo que a criou. É exatamente o que distingue thread de processo — o processo é a unidade de alocação de recursos, a thread é a unidade de execução.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"Thread como unidade de escalonamento independente","citation":null,"trap_note":"Processo detém os recursos (memória, arquivos abertos); thread detém apenas pilha, registradores e contador de programa, e é ela que a CPU escalona. Itens que invertem esses dois papéis são o formato mais comum do assunto."}},{"id":"521f68bcd4c4","number":112,"stem":32,"statement":"NET Core é uma framework que trabalha com servidores web da Microsoft para integrar e automatizar os processos de deploy nos servidores, a fim de agilizar os processos e poupar os desenvolvedores desse trabalho.","answer":"E","source":{"slug":"SEFIN_FORTALEZA_CE_23","ano":2023},"explanation":{"verdict_reason":"O .NET Core é uma plataforma de desenvolvimento e execução — runtime, bibliotecas e compilador — multiplataforma e de código aberto, que roda em Windows, Linux e macOS. Automatizar publicação em servidores web da Microsoft é papel de ferramentas de integração e entrega contínua, não da plataforma em si.","distortion_type":"atribuicao_errada","distorted_span":"que trabalha com servidores web da Microsoft para integrar e automatizar os processos de deploy nos servidores","corrected_statement":"NET Core é uma framework multiplataforma e de código aberto que fornece runtime e bibliotecas para a execução de aplicações em Windows, Linux e macOS.","concept":".NET Core é plataforma de execução, não ferramenta de deploy","citation":null,"trap_note":"Plataforma executa, esteira publica. Sempre que o item descrever automação de implantação, verifique se o produto citado é a plataforma ou a ferramenta de CI/CD — é a mesma armadilha que troca JVM por Jenkins."}},{"id":"adece284a699","number":115,"stem":33,"statement":"O Hibernate Envers permite realizar gerenciamento de identidade por meio de JPA no WildFly ou JBoss, de modo a habilitar single-sign on nas aplicações, uma vez que, logado no Envers, os usuários não precisam fazer login novamente para acessar um aplicativo diferente.","answer":"E","source":{"slug":"INPI_23","ano":2023},"explanation":{"verdict_reason":"O Hibernate Envers faz auditoria e versionamento de entidades: ele mantém tabelas de histórico com as revisões de cada registro, permitindo consultar como a entidade estava em determinado momento. Autenticação única entre aplicações é competência de solução de identidade, como Keycloak ou PicketLink, nada relacionado ao Envers.","distortion_type":"atribuicao_errada","distorted_span":"permite realizar gerenciamento de identidade por meio de JPA no WildFly ou JBoss, de modo a habilitar single-sign on nas aplicações","corrected_statement":"O Hibernate Envers permite realizar auditoria e versionamento de entidades JPA, registrando o histórico de revisões de cada registro.","concept":"Envers faz auditoria de entidades, não identidade","citation":null,"trap_note":"Envers audita, Validator valida, Search indexa, OGM mapeia NoSQL — os módulos do Hibernate têm nomes que sugerem a função. Item que atribua segurança ou autenticação a um módulo de persistência está trocando a camada."}},{"id":"26b5e507d026","number":116,"stem":34,"statement":"O resultado da execução do código a seguir, escrito em Java, será SubA.\n\nabstract class FuncaoA {\n FuncaoA() {\n this(null);\n System.out.print(“FuncaoA”);\n }\n FuncaoA(SubA s) { this.init(); }\n abstract void init();\n}\nclass SubA extends FuncaoA {\n void init() { System.out.print(“SubA”); }\n public static void main (String[] arg) {\n SubA a = new SubA(); }\n}","answer":"E","source":{"slug":"DATAPREV_23","ano":2023},"explanation":{"verdict_reason":"O construtor implícito de SubA chama super(), que executa FuncaoA(): este delega a FuncaoA(SubA) por this(null), e ali this.init() já despacha para a versão sobrescrita em SubA, imprimindo SubA. Ao voltar, a execução de FuncaoA() continua e imprime FuncaoA. A saída completa é SubAFuncaoA.","distortion_type":"troca_de_termo","distorted_span":"será SubA","corrected_statement":"O resultado da execução do código a seguir, escrito em Java, será SubAFuncaoA.","concept":"Encadeamento de construtores: this(...) executa e retorna","citation":null,"trap_note":"Chamar this(...) no início de um construtor não encerra o construtor: ele executa o outro e depois continua nas linhas seguintes. Item de saída em cadeia de construtores costuma mostrar só a primeira metade do que é impresso."}},{"id":"4783ed05edd0","number":118,"stem":35,"statement":"Bytecode é um conjunto de instruções independente de plataforma principalmente, pois é interpretado e executado pela JVM.","answer":"C","source":{"slug":"DATAPREV_23","ano":2023},"explanation":{"verdict_reason":"O bytecode é destinado a uma máquina abstrata, não a um processador real, e por isso o mesmo arquivo .class serve a qualquer plataforma. A independência se realiza porque existe, em cada plataforma, uma JVM que interpreta — e, com o JIT, compila em tempo de execução — esse mesmo conjunto de instruções.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"Bytecode independente de plataforma executado pela JVM","citation":null,"trap_note":"A cadeia é .java, javac, .class com bytecode, JVM, instruções nativas. Quem compila é o javac, quem executa é a JVM — item que troque esses dois papéis é frequente."}},{"id":"6bdc8e5bd1ce","number":119,"stem":35,"statement":"JGroups é uma ferramenta do JBoss destinada a gerenciar grupos de usuários com as respectivas aplicações em seus bancos de dados.","answer":"E","source":{"slug":"DATAPREV_23","ano":2023},"explanation":{"verdict_reason":"O JGroups é uma biblioteca de comunicação em grupo: ele forma clusters de nós, detecta entrada e saída de membros e entrega mensagens confiáveis entre eles, sendo a base da replicação de sessão e do cache distribuído no JBoss. Gerenciar usuários e seus acessos é papel de subsistema de segurança, não dele.","distortion_type":"troca_de_termo","distorted_span":"destinada a gerenciar grupos de usuários com as respectivas aplicações em seus bancos de dados","corrected_statement":"JGroups é uma ferramenta do JBoss destinada a gerenciar a comunicação confiável em grupo entre os nós de um cluster.","concept":"JGroups faz comunicação em grupo entre nós, não gestão de usuários","citation":null,"trap_note":"Grupo de nós e grupo de usuários são coisas distintas. Quando o item usar uma palavra ambígua como grupo, sessão ou contexto, pergunte de quem se está falando — é ali que a troca de termo se esconde."}},{"id":"c6f2140ec792","number":120,"stem":35,"statement":"O arquivo .httpacess é utilizado de forma nativa no servidor NGINX para controle de acesso por usuários às páginas web hospedadas no servidor.","answer":"E","source":{"slug":"DATAPREV_23","ano":2023},"explanation":{"verdict_reason":"O arquivo .htaccess é recurso do servidor Apache HTTP, que permite sobrescrever configuração por diretório. O NGINX não o lê: sua configuração é centralizada no nginx.conf e nos arquivos incluídos, e o controle de acesso se declara em blocos location, com auth_basic, allow e deny.","distortion_type":"atribuicao_errada","distorted_span":"utilizado de forma nativa no servidor NGINX","corrected_statement":"O arquivo .htaccess é utilizado de forma nativa no servidor Apache para controle de acesso por usuários às páginas web hospedadas no servidor.","concept":".htaccess é do Apache, não do NGINX","citation":null,"trap_note":"Configuração por diretório é do Apache; configuração centralizada é do NGINX, e essa é uma das razões de desempenho do segundo, que não precisa procurar arquivo em cada pasta a cada requisição."}},{"id":"255d22a6ab61","number":83,"stem":36,"statement":"O encapsulamento em Java consiste no princípio pelo qual um conjunto de objetos derivados de uma mesma superclasse pode invocar métodos que tenham a mesma identificação (assinatura), mas apresentem comportamentos distintos.","answer":"E","source":{"slug":"FUB_22","ano":2022},"explanation":{"verdict_reason":"Objetos de uma mesma superclasse invocando métodos de assinatura idêntica com comportamentos distintos é a definição de polimorfismo, realizada por sobrescrita e ligação tardia. Encapsulamento é outra coisa: reunir dados e comportamento num objeto e ocultar os detalhes internos por trás de métodos de acesso.","distortion_type":"troca_de_termo","distorted_span":"O encapsulamento em Java consiste no princípio","corrected_statement":"O polimorfismo em Java consiste no princípio pelo qual um conjunto de objetos derivados de uma mesma superclasse pode invocar métodos que tenham a mesma identificação (assinatura), mas apresentem comportamentos distintos.","concept":"Encapsulamento × polimorfismo","citation":null,"trap_note":"Sempre que o enunciado mencionar mesma assinatura e comportamentos diferentes, a palavra certa é polimorfismo, venha o nome que vier no início da frase. É a troca de termo mais repetida do tópico."}},{"id":"c071597de8ab","number":86,"stem":37,"statement":"Na linguagem Java, o polimorfismo dinâmico caracteriza-se pela execução da mesma operação da classe com métodos de assinaturas diferentes, e a escolha do método ocorre em tempo de compilação.","answer":"E","source":{"slug":"BANRISUL_22","ano":2022},"explanation":{"verdict_reason":"O polimorfismo dinâmico pressupõe métodos de mesma assinatura, redefinidos na subclasse, e a escolha de qual executar ocorre em tempo de execução, por ligação tardia, conforme o tipo real do objeto. Assinaturas diferentes com resolução em tempo de compilação descrevem sobrecarga, que é o polimorfismo estático.","distortion_type":"inversao","distorted_span":"métodos de assinaturas diferentes, e a escolha do método ocorre em tempo de compilação","corrected_statement":"Na linguagem Java, o polimorfismo dinâmico caracteriza-se pela execução da mesma operação da classe com métodos de mesma assinatura, e a escolha do método ocorre em tempo de execução.","concept":"Polimorfismo dinâmico: mesma assinatura, ligação tardia","citation":null,"trap_note":"Assinatura diferente é sobrecarga e se resolve na compilação; assinatura igual redefinida na subclasse é sobrescrita e se resolve na execução. A banca cruza os dois pares de propósito — confira sempre os dois lados da frase, não apenas um."}},{"id":"5d6f6dd6f027","number":89,"stem":37,"statement":"Na programação orientada a objetos, as instâncias são criadas a partir de uma classe e compartilham os métodos e atributos dessa classe, assim como os conteúdos desses atributos.","answer":"E","source":{"slug":"BANRISUL_22","ano":2022},"explanation":{"verdict_reason":"As instâncias compartilham a estrutura definida pela classe — quais atributos existem e quais métodos podem ser chamados — mas cada objeto guarda seus próprios valores. Se o conteúdo dos atributos fosse compartilhado, dois objetos da mesma classe seriam indistinguíveis; conteúdo comum só existe em atributo declarado static.","distortion_type":"escopo_ampliado","distorted_span":"assim como os conteúdos desses atributos","corrected_statement":"Na programação orientada a objetos, as instâncias são criadas a partir de uma classe e compartilham os métodos e atributos dessa classe, mas cada uma mantém os seus próprios conteúdos desses atributos.","concept":"Estrutura é da classe; estado é da instância","citation":null,"trap_note":"Atributo de instância tem uma cópia por objeto; atributo static tem uma cópia por classe. Item que estenda o compartilhamento da definição ao conteúdo confundiu variável de classe com variável de instância."}},{"id":"d18935cfadb8","number":97,"stem":38,"statement":"Considere-se o seguinte código.\n\npublic class Fruta {\n  private double fvalor;\n  private String fnome;\n  Fruta(double fPreco, String fNome)\n  {\n     fvalor = fPreco;\n     fnome = fNome;\n  }\n  Fruta(Fruta fruta)\n  {\n     fvalor = fruta.fvalor;\n     fnome = fruta.fnome;\n  }\n  double showPreco()\n  {\n     return fvalor;\n  }\n  String showNome()\n  {\n     return fnome;\n  }\n  public static void main(String args[])\n  {\n     Fruta f1 = new Fruta(399, “Laranja\nLima”);\n     System.out.println(“Nome da fruta 1: “+\nf1.showNome());\n     System.out.println(“Preco da fruta 1: “+\nf1.showPreco());\n     Fruta f2 = new Fruta(f1);\n  System.out.println(“Nome da fruta 2: “+\nf2.showNome());\n     System.out.println(“Preço da fruta 2: “+\nf2.showPreco());\n  }\n}\n\nO código apresentado não será compilado, pois há dois métodos construtores.","answer":"E","source":{"slug":"BANCO_DO_NORDESTE_22","ano":2022},"explanation":{"verdict_reason":"Ter mais de um construtor é sobrecarga de construtor, prática perfeitamente válida em Java desde que as listas de parâmetros sejam diferentes — e aqui uma recebe double e String e a outra recebe um Fruta. O código compila, e a causa alegada para o erro não existe.","distortion_type":"relacao_causal","distorted_span":"não será compilado, pois há dois métodos construtores","corrected_statement":"O código apresentado será compilado normalmente, pois os dois construtores têm listas de parâmetros diferentes, o que caracteriza sobrecarga.","concept":"Sobrecarga de construtores é válida","citation":null,"trap_note":"Construtor obedece às mesmas regras de sobrecarga dos demais métodos: só há conflito se duas assinaturas forem idênticas. Item que declare erro de compilação sempre traz a causa junto — ataque a causa, que costuma ser inventada."}},{"id":"95ba7d84e464","number":75,"stem":39,"statement":"O garbage collector serve como um gerenciador de memória automático; um dos seus benefícios é a alocação eficiente dos objetos no heap nativo do sistema operacional.","answer":"E","source":{"slug":"PETROBRAS_21_NS","ano":2021},"explanation":{"verdict_reason":"O coletor de lixo gerencia o heap da própria JVM, uma área de memória que a máquina virtual reserva e administra internamente, e não o heap nativo do sistema operacional. Objetos Java nascem e morrem dentro desse espaço gerenciado, que é justamente o que permite ao coletor saber quem ainda é alcançável.","distortion_type":"troca_de_termo","distorted_span":"no heap nativo do sistema operacional","corrected_statement":"O garbage collector serve como um gerenciador de memória automático; um dos seus benefícios é a alocação eficiente dos objetos no heap da JVM.","concept":"Heap gerenciado da JVM × heap nativo do sistema operacional","citation":null,"trap_note":"Memória fora do heap da JVM existe (metaspace, buffers diretos, pilha nativa), mas não é onde o coletor atua. Item que misture as camadas de memória é troca de termo, não de conceito."}},{"id":"18f4db21ca0e","number":92,"stem":40,"statement":"Se a implementação do projeto for orientada a objetos, as classes de projeto devem colaborar e trocar mensagens com a maior parte das outras classes do mesmo sistema.","answer":"E","source":{"slug":"SERPRO_21","ano":2021},"explanation":{"verdict_reason":"O princípio de projeto orientado a objetos é o oposto: baixo acoplamento, isto é, cada classe deve colaborar com o menor número possível de outras, e alta coesão dentro de si. Uma classe que troca mensagens com a maior parte do sistema é precisamente o sintoma de acoplamento excessivo que o projeto procura evitar.","distortion_type":"inversao","distorted_span":"devem colaborar e trocar mensagens com a maior parte das outras classes do mesmo sistema","corrected_statement":"Se a implementação do projeto for orientada a objetos, as classes de projeto devem colaborar e trocar mensagens com o menor número possível de outras classes do mesmo sistema.","concept":"Baixo acoplamento e alta coesão","citation":null,"trap_note":"Coesão alta, acoplamento baixo: a regra vale para classe, módulo, componente e microsserviço. Item que peça colaboração ampla entre classes, ou que descreva acoplamento alto como qualidade, inverteu o princípio."}},{"id":"16533bc9c28d","number":55,"stem":41,"statement":"No Spring Framework, a anotação @RequestClass é usada para que a aplicação saiba a requisição que deve ser tratada pelo @Controller.","answer":"E","source":{"slug":"DPDF_20_ANALISTA","ano":2020},"explanation":{"verdict_reason":"A anotação que associa uma requisição HTTP ao método do controlador é @RequestMapping, com as variantes por verbo @GetMapping, @PostMapping, @PutMapping e @DeleteMapping. Não existe @RequestClass no Spring Framework.","distortion_type":"troca_de_termo","distorted_span":"@RequestClass","corrected_statement":"No Spring Framework, a anotação @RequestMapping é usada para que a aplicação saiba a requisição que deve ser tratada pelo @Controller.","concept":"@RequestMapping mapeia requisição para o método do controlador","citation":null,"trap_note":"Anotação inventada é um dos formatos favoritos da banca: @RequestClass, @Injectable, @TransactionalBean. Se você nunca escreveu aquela anotação, provavelmente ela não existe — confira contra a família real (@Controller, @RestController, @RequestMapping, @Autowired, @Service, @Repository)."}},{"id":"0f4ae2be3ed5","number":56,"stem":41,"statement":"O framework Apache CXF permite que a transmissão de dados binários seja feita por meio de mensagens MIME, o que traz eficiência à transmissão.","answer":"C","source":{"slug":"DPDF_20_ANALISTA","ano":2020},"explanation":{"verdict_reason":"O Apache CXF implementa MTOM e SOAP with Attachments, que transportam o conteúdo binário como parte separada de uma mensagem MIME multipart, em vez de codificá-lo em Base64 dentro do XML. Isso evita o acréscimo de cerca de um terço no tamanho que a codificação Base64 impõe, daí o ganho de eficiência.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"MTOM e anexos MIME para dados binários em web services","citation":null,"trap_note":"Binário dentro de XML só cabe em Base64, que infla o conteúdo; por isso os padrões de web service tiram o binário do corpo e o mandam como parte MIME. Vale para CXF, Axis e qualquer pilha SOAP."}},{"id":"af0073814869","number":57,"stem":41,"statement":"Em JDBC, o método executeUpdate() pode ser usado para realizar um update em banco de dados, caso em que esse método recebe uma expressão SQL cujos valores de retorno serão tratados por um ResultSet.","answer":"E","source":{"slug":"DPDF_20_ANALISTA","ano":2020},"explanation":{"verdict_reason":"Em JDBC, executeUpdate() devolve um int com a quantidade de linhas afetadas pelo comando — ou zero, no caso de comandos DDL. Quem devolve ResultSet é executeQuery(), usado em consultas SELECT; executeUpdate serve a INSERT, UPDATE e DELETE, que não produzem conjunto de resultados.","distortion_type":"troca_de_termo","distorted_span":"cujos valores de retorno serão tratados por um ResultSet","corrected_statement":"Em JDBC, o método executeUpdate() pode ser usado para realizar um update em banco de dados, caso em que esse método recebe uma expressão SQL e retorna um inteiro com a quantidade de linhas afetadas.","concept":"executeQuery devolve ResultSet; executeUpdate devolve inteiro","citation":null,"trap_note":"Três métodos, três retornos: executeQuery devolve ResultSet, executeUpdate devolve int, e execute devolve boolean indicando se há ResultSet disponível. A banca troca o retorno de um pelo do outro."}},{"id":"06f2e2cf8a3b","number":58,"stem":41,"statement":"Ao se usar o iText para criar um arquivo PDF a partir de um conjunto de dados extraídos de um banco de dados, novas páginas PDF serão criadas automaticamente, caso sejam necessárias.","answer":"C","source":{"slug":"DPDF_20_ANALISTA","ano":2020},"explanation":{"verdict_reason":"O iText trabalha com um modelo de documento em que o conteúdo é adicionado sequencialmente e a paginação é responsabilidade da biblioteca: quando o conteúdo excede o espaço útil da página corrente, uma nova página é aberta automaticamente. É o que torna viável gerar relatório a partir de consulta cujo número de linhas não se conhece de antemão.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"Paginação automática na geração de PDF","citation":null,"trap_note":"Bibliotecas de relatório (iText, JasperReports) assumem a quebra de página; o desenvolvedor controla só o que quer forçar. Item que exija o cálculo manual de páginas descreve manipulação de PDF em baixo nível, não geração de documento."}},{"id":"bae10f4eb1e3","number":59,"stem":41,"statement":"No Java 8, o uso do método map() permite aplicar uma função a todos os elementos de um stream.","answer":"C","source":{"slug":"DPDF_20_ANALISTA","ano":2020},"explanation":{"verdict_reason":"O map é a operação intermediária de transformação da Stream API: recebe uma função e a aplica a cada elemento do fluxo, produzindo um novo stream com os resultados. Ele não filtra nem reduz — quem seleciona é o filter e quem consolida é o reduce ou o collect.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"map transforma todos os elementos do stream","citation":null,"trap_note":"map transforma um a um, filter seleciona, flatMap achata streams aninhados, reduce e collect são terminais. Nada executa até chegar a operação terminal — a preguiça das intermediárias é o outro ponto que a banca cobra."}},{"id":"57bd53ed45ea","number":106,"stem":42,"statement":"Situação hipotética: Na utilização de JPA (Java Persistence API) para realizar o mapeamento objeto-relacional (ORM) em uma aplicação Java, surgiu a necessidade de criar uma propriedade idade não serializável em uma classe serializável. Assertiva: Uma maneira de informar que essa propriedade não deve ser persistida em banco de dados é utilizar a anotação @Transient em seu método getIdade().","answer":"C","source":{"slug":"SLU_DF_19","ano":2019},"explanation":{"verdict_reason":"A anotação @Transient é justamente a que marca um atributo ou propriedade como não persistente: o provedor de persistência a ignora ao mapear a classe para a tabela. Como o acesso desta entidade é por propriedade, anotar o método getIdade() é o lugar correto de colocá-la.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"@Transient exclui a propriedade da persistência","citation":null,"trap_note":"Não confunda o @Transient da JPA com a palavra reservada transient do Java, que exclui o campo da serialização. Uma é anotação de persistência, a outra é modificador de linguagem — e a banca gosta de sobrepor as duas."}},{"id":"ab71463731ba","number":63,"stem":43,"statement":"Por meio do mecanismo de sobrecarga, dois métodos de uma mesma classe podem ter o mesmo nome, desde que suas listas de parâmetros sejam diferentes.","answer":"C","source":{"slug":"EBSERH_18_ADMINISTRATIVO","ano":2018},"explanation":{"verdict_reason":"É a definição de sobrecarga: métodos de mesmo nome convivem na mesma classe desde que se distingam pela lista de parâmetros, em quantidade, tipo ou ordem. O compilador escolhe qual chamar a partir dos argumentos, ainda em tempo de compilação.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"Sobrecarga distingue métodos pela lista de parâmetros","citation":null,"trap_note":"O tipo de retorno não entra na assinatura: dois métodos que só diferem no retorno não compilam. É a pegadinha natural deste conceito."}},{"id":"43eadea61c6a","number":64,"stem":43,"statement":"Na herança por especificação, a subclasse especifica a superclasse, acrescentando a ela novos atributos ou métodos, mas mantendo inalterada sua constituição original.","answer":"E","source":{"slug":"EBSERH_18_ADMINISTRATIVO","ano":2018},"explanation":{"verdict_reason":"Acrescentar atributos ou métodos preservando intacta a superclasse é herança por extensão. Na herança por especificação, a superclasse funciona como contrato — define a especificação que a subclasse deve implementar, sem que a superclasse traga comportamento a ser apenas ampliado. O item descreve uma e nomeia a outra.","distortion_type":"troca_de_termo","distorted_span":"Na herança por especificação","corrected_statement":"Na herança por extensão, a subclasse estende a superclasse, acrescentando a ela novos atributos ou métodos, mas mantendo inalterada sua constituição original.","concept":"Herança por extensão × herança por especificação","citation":null,"trap_note":"Extensão acrescenta, especificação implementa um contrato, especialização refina comportamento herdado. Quando o item define um dos três corretamente, confira se o nome que ele assina é o mesmo que a definição pede."}},{"id":"970952d4f4b1","number":65,"stem":43,"statement":"O suporte para a implementação de diversas interfaces em uma única classe é considerado uma solução alternativa para contornar a restrição de herança única própria da linguagem Java.","answer":"C","source":{"slug":"EBSERH_18_ADMINISTRATIVO","ano":2018},"explanation":{"verdict_reason":"Java restringe a herança de classes a uma superclasse direta para evitar a ambiguidade do diamante, mas não limita o número de interfaces implementadas. Implementar várias interfaces dá à classe múltiplos tipos e múltiplos contratos, o que cobre boa parte do que a herança múltipla ofereceria.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"Múltiplas interfaces como alternativa à herança múltipla","citation":null,"trap_note":"Interface dá herança múltipla de tipo, não de estado: não há atributos de instância a herdar, e por isso não há conflito de dados. Guardada essa distinção, itens sobre o diamante em Java se resolvem sozinhos."}},{"id":"b46fb69b5097","number":71,"stem":44,"statement":"O resultado da execução do código seguinte será 500 4 30 40 50.\n\npublic class Array01\n{\n  static void Faca( int[] z )\n  {\n   int[] A z ;\n   A[0] z[4]*10;\n   A[1] z[3]/10;\n  }\n}\nclass Teste\n{\n  public static void main ( String[] args )\n  {\n   int meuArray[] {10, 20, 30, 40, 50} ;\n   Array01.Faca( meuArray );\n   for (int j 0; j < meuArray.length; j++ )\n     System.out.print( meuArray[j] + \" \" ) ;\n  }\n}","answer":"C","source":{"slug":"EBSERH_18_ADMINISTRATIVO","ano":2018},"explanation":{"verdict_reason":"Ao passar o array ao método, passa-se uma cópia da referência, e não do conteúdo: dentro de Faca, A e z apontam para o mesmo objeto do chamador. Assim A[0] recebe z[4]*10, que é 500, e A[1] recebe z[3]/10, que é 4, alterando o próprio meuArray. As três posições restantes não são tocadas, e a impressão é 500 4 30 40 50.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"Passagem de array a método compartilha a referência","citation":null,"trap_note":"Java sempre passa por valor, mas o valor de uma variável de objeto é a referência: reatribuir o parâmetro dentro do método não afeta o chamador, enquanto alterar o conteúdo apontado afeta. Metade dos itens com array explora essa diferença."}},{"id":"be4d372c9337","number":72,"stem":44,"statement":"Após executado o código a seguir, o resultado será 11.\n\npublic class Static {\n  static {\n   int a 2;\n  } static int a, y;\n  public static void main(String args[]) {\n   a--;\n   minhaFuncao();\n   System.out.println(a + y + ++a);\n  }\n  public static void minhaFuncao() {\n   y a++ + ++a;\n  }\n}","answer":"E","source":{"slug":"EBSERH_18_ADMINISTRATIVO","ano":2018},"explanation":{"verdict_reason":"A variável declarada dentro do bloco static é local a ele e não altera o campo estático a, que começa em zero, assim como y. Depois de a-- o campo vale menos um; em minhaFuncao, a++ entrega menos um e ++a entrega um, de modo que y fica zero e a fica um. Na impressão, a mais y mais ++a resulta em 1 mais 0 mais 2, ou seja, 3.","distortion_type":"numero_errado","distorted_span":"o resultado será 11","corrected_statement":"Após executado o código a seguir, o resultado será 3.","concept":"Pré-incremento × pós-incremento e escopo do bloco static","citation":null,"trap_note":"Duas regras resolvem esses itens: variável declarada dentro de um bloco não sai dele, e a++ devolve o valor antigo enquanto ++a devolve o novo. Avalie a expressão da esquerda para a direita, anotando o valor da variável após cada termo."}},{"id":"924f28900a71","number":75,"stem":45,"statement":"No desenvolvimento de uma aplicação em que ocorram persistências a dados usando Hibernate, é necessário criar uma sessão para fazer a conexão com o banco de dados por meio de um objeto session; este objeto, que é instanciado apenas uma vez na aplicação, deve se manter instanciado durante todo o tempo de execução.","answer":"E","source":{"slug":"FUB_18","ano":2018},"explanation":{"verdict_reason":"O objeto criado uma única vez e mantido durante toda a execução da aplicação é a SessionFactory, que é cara de construir e é thread-safe. A Session é o oposto: leve, não thread-safe e de vida curta, criada e fechada a cada unidade de trabalho. O item descreve a SessionFactory e assina Session.","distortion_type":"troca_de_termo","distorted_span":"este objeto, que é instanciado apenas uma vez na aplicação, deve se manter instanciado durante todo o tempo de execução","corrected_statement":"No desenvolvimento de uma aplicação em que ocorram persistências a dados usando Hibernate, é necessário criar uma sessão para fazer a conexão com o banco de dados por meio de um objeto session; este objeto deve ser criado e fechado a cada unidade de trabalho, enquanto a SessionFactory é instanciada apenas uma vez na aplicação.","concept":"SessionFactory é única e longa; Session é curta","citation":null,"trap_note":"Fábrica única e thread-safe, sessão curta e de uso exclusivo de uma thread — o mesmo par aparece como EntityManagerFactory e EntityManager na JPA. Item que mantenha a sessão aberta por toda a aplicação trocou um pelo outro."}},{"id":"2bb1c0bb6dd6","number":98,"stem":46,"statement":"Arquivo JAR contém recursos relacionados ao Java, como bibliotecas e classes, e pode conter qualquer arquivo que não seja relacionado a aplicação Java, como .txt, .doc, .gif.","answer":"C","source":{"slug":"EMAP_18","ano":2018},"explanation":{"verdict_reason":"O JAR é, na estrutura, um arquivo ZIP com um diretório META-INF e um manifesto. Além de classes compiladas e bibliotecas, ele empacota quaisquer recursos que a aplicação precise distribuir — imagens, textos, arquivos de configuração — sem restrição quanto ao tipo.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"JAR como empacotamento ZIP com manifesto","citation":null,"trap_note":"JAR empacota bibliotecas e aplicações, WAR empacota aplicação web com WEB-INF, EAR empacota a aplicação corporativa inteira com módulos EJB. Os três são ZIP por dentro."}},{"id":"a8ab7d1c2c25","number":102,"stem":47,"statement":"A execução do código Java seguinte retornará o resultado numérico 20.\n\npublic class Prova {\n    public static int prova(int num) {\n        if (num <= 1) {\n            return 1;\n        } else {\n            return prova(num - 1) * num;\n   }\n    public static void main(String[] args) {\n        int numero;\n        numero = 5;\n        System.out.println(\"O resultado é \" +\nprova(numero));\n}","answer":"E","source":{"slug":"MP_PI_18","ano":2018},"explanation":{"verdict_reason":"O método é o fatorial: devolve 1 quando o argumento é menor ou igual a um e, caso contrário, multiplica o argumento pelo resultado da chamada anterior. Com numero igual a 5, o produto é 5 vezes 4 vezes 3 vezes 2 vezes 1, ou seja, 120, e não 20.","distortion_type":"numero_errado","distorted_span":"retornará o resultado numérico 20","corrected_statement":"A execução do código Java seguinte retornará o resultado numérico 120.","concept":"Recursão multiplicativa: fatorial","citation":null,"trap_note":"Reconheça o padrão pela operação do retorno: n mais a chamada anterior é somatório, n vezes a chamada anterior é fatorial. Identificado o padrão, o cálculo é imediato e o valor plausível que o item oferece deixa de enganar."}},{"id":"a8fc61f427cf","number":104,"stem":48,"statement":"Em virtude do polimorfismo implementado na linguagem Java, um método da forma empregado.calculasalario(), tem sua invocação resolvida em tempo de compilação do código.","answer":"E","source":{"slug":"STJ_18","ano":2018},"explanation":{"verdict_reason":"O polimorfismo por sobrescrita se resolve por ligação tardia: o compilador apenas verifica se o método existe no tipo declarado da referência, e a escolha da implementação executada depende do tipo real do objeto, conhecido só em tempo de execução. Resolução em tempo de compilação é característica da sobrecarga.","distortion_type":"inversao","distorted_span":"tem sua invocação resolvida em tempo de compilação do código","corrected_statement":"Em virtude do polimorfismo implementado na linguagem Java, um método da forma empregado.calculasalario(), tem sua invocação resolvida em tempo de execução do código.","concept":"Ligação tardia resolve a chamada polimórfica em execução","citation":null,"trap_note":"Ligação estática é da sobrecarga e dos métodos static, private e final; ligação dinâmica é da sobrescrita. Se o item fala em polimorfismo e em tempo de compilação na mesma frase, um dos dois está fora do lugar."}},{"id":"a7703ce9f180","number":61,"stem":49,"statement":"De acordo com a definição das variáveis, o trecho de código a seguir permite uma conexão ao banco de dados em questão, sem gerar nenhum tipo de erro. . . .\n\ntry {\n   Class.forName(VAR1);\n   conn = DriverManager.getConnection(VAR1,\nVAR3, VAR4);\n\n. . .","answer":"E","source":{"slug":"TRF1_17_SERVIDOR","ano":2017},"explanation":{"verdict_reason":"VAR1 guarda o nome da classe do driver, e é esse o argumento correto de Class.forName, que apenas carrega e registra o driver. A URL de conexão está em VAR2, e é ela que DriverManager.getConnection espera no primeiro parâmetro, seguida de usuário e senha. Como o código repassa VAR1 no lugar de VAR2, nenhum driver registrado reconhece aquela cadeia como URL e a chamada lança SQLException informando que não há driver adequado. VAR2, a única variável que serviria ali, não é usada em lugar nenhum do trecho.","distortion_type":"troca_de_termo","distorted_span":"DriverManager.getConnection(VAR1,","corrected_statement":"conn = DriverManager.getConnection(VAR2, VAR3, VAR4);","concept":"getConnection recebe a URL JDBC, não a classe do driver","citation":"Java SE API: java.sql.DriverManager.getConnection(String url, String user, String password)","trap_note":"Em listagem JDBC, confira a correspondência entre variável declarada e parâmetro usado antes de julgar a lógica: Class.forName recebe a classe do driver; getConnection recebe a URL, o usuário e a senha. Variável declarada no enunciado e nunca utilizada no código é o sinal mais barato de que a banca trocou um argumento de lugar."}},{"id":"b1dba100b7e9","number":69,"stem":50,"statement":"A JSE é bastante utilizada no desenvolvimento web, especialmente em aplicações que utilizam HTTP; a JEE, por sua vez, é voltada para a criação de interface desktop com o uso de Swing e similares.","answer":"E","source":{"slug":"PREF_JP_17_CGM","ano":2017},"explanation":{"verdict_reason":"As duas edições estão trocadas. A Java SE é a plataforma padrão, base da linguagem e das bibliotecas, e é nela que vivem Swing e AWT para interface desktop. A Java EE é a extensão corporativa, com servlets, JSP, EJB e JPA, voltada a aplicações web e distribuídas sobre HTTP.","distortion_type":"inversao","distorted_span":"A JSE é bastante utilizada no desenvolvimento web, especialmente em aplicações que utilizam HTTP","corrected_statement":"A JEE é bastante utilizada no desenvolvimento web, especialmente em aplicações que utilizam HTTP; a JSE, por sua vez, contém a base da linguagem e a criação de interface desktop com o uso de Swing e similares.","concept":"Java SE × Java EE × Java ME","citation":null,"trap_note":"SE é a base e o desktop, EE é o servidor e a web, ME é o dispositivo limitado. Itens que descrevam corretamente duas edições e as assinem trocadas são o formato padrão da banca neste assunto."}},{"id":"d9f27bb96693","number":70,"stem":50,"statement":"A JME oferece um ambiente robusto e flexível para aplicativos executados em dispositivos móveis e integrados cuja capacidade de memória, de vídeo e de processamento são limitados, tais como set-top boxes e reprodutores de discos blu-ray.","answer":"C","source":{"slug":"PREF_JP_17_CGM","ano":2017},"explanation":{"verdict_reason":"A Java ME é a edição dirigida a dispositivos com restrição de memória, vídeo e processamento, e seu alcance vai além do telefone celular: set-top boxes, leitores de blu-ray, impressoras e sensores embarcados estão entre os alvos declarados da plataforma.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"Java ME para dispositivos móveis e embarcados","citation":null,"trap_note":"Embarcado não quer dizer apenas celular. A banca cita set-top box e blu-ray justamente porque parecem fora do escopo, mas são exemplos oficiais da Java ME."}},{"id":"83d884535f34","number":98,"stem":51,"statement":"Em orientação a objetos, os membros de dados de uma classe devem ser acessados por um método específico do objeto, e não diretamente.","answer":"C","source":{"slug":"STM_17_ANALISTA_TECNICO","ano":2017},"explanation":{"verdict_reason":"É a aplicação direta do encapsulamento: os atributos ficam protegidos do acesso externo e o contato com eles se dá por métodos do próprio objeto, o que permite validar, converter ou registrar a alteração e mudar a representação interna sem afetar quem usa a classe.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"Acesso a atributos por métodos, não diretamente","citation":null,"trap_note":"Atributo private com acesso por método é a forma concreta do encapsulamento em Java. Item que descreva acesso direto ao dado como boa prática orientada a objetos está errado, por mais que a linguagem permita."}},{"id":"d9c00d79da96","number":100,"stem":51,"statement":"Em sistemas desenvolvidos em Java, o objetivo do framework Hibernate é a transformação das classes para tabelas de dados, com a geração dos comandos SQL.","answer":"C","source":{"slug":"STM_17_ANALISTA_TECNICO","ano":2017},"explanation":{"verdict_reason":"Esse é exatamente o papel de um framework de mapeamento objeto-relacional: o Hibernate associa classes a tabelas e atributos a colunas, e a partir desse mapeamento gera os comandos SQL de leitura e escrita, poupando o desenvolvedor de escrevê-los.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"Hibernate como implementação de ORM","citation":null,"trap_note":"ORM resolve a incompatibilidade entre o modelo de objetos e o modelo relacional. Hibernate é a implementação mais conhecida da JPA, que é a especificação — item que chame a JPA de framework concreto, ou o Hibernate de especificação, inverteu os papéis."}},{"id":"cf800b5f1c45","number":69,"stem":52,"statement":"No framework Spring, o gerenciamento de transações por meio de programação apresenta como vantagem a flexibilidade e como desvantagem a dificuldade de manutenção.","answer":"C","source":{"slug":"FUNPRESP_16_JUD","ano":2016},"explanation":{"verdict_reason":"O Spring oferece duas formas de controlar transação. A programática, com TransactionTemplate ou PlatformTransactionManager, dá controle fino sobre onde a transação começa e termina, mas espalha código de infraestrutura pela lógica de negócio, o que dificulta a manutenção. A declarativa, com @Transactional, inverte esse par de características.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"Transação programática × declarativa no Spring","citation":null,"trap_note":"Programático é flexível e invasivo; declarativo é limpo e menos granular. A mesma oposição reaparece em segurança, cache e validação — flexibilidade de um lado, manutenibilidade do outro."}},{"id":"45d56d43bb13","number":70,"stem":53,"statement":"O fato de as expressões lambda terem sido excluídas do Java 8 possibilitou que a linguagem Java ficasse mais flexível e que a implementação de seu código se tornasse mais precisa.","answer":"E","source":{"slug":"TCE_PA_16","ano":2016},"explanation":{"verdict_reason":"As expressões lambda foram introduzidas justamente no Java 8, e não excluídas dele. Foi essa inclusão, ao lado das interfaces funcionais e da Stream API, que permitiu escrever comportamento como argumento e tornou o código mais conciso.","distortion_type":"inversao","distorted_span":"as expressões lambda terem sido excluídas do Java 8","corrected_statement":"O fato de as expressões lambda terem sido incluídas no Java 8 possibilitou que a linguagem Java ficasse mais flexível e que a implementação de seu código se tornasse mais precisa.","concept":"Lambdas foram introduzidas no Java 8","citation":null,"trap_note":"Marcos de versão que caem com frequência: Java 8 trouxe lambda, stream e método default; Java 11 trouxe var em lambda e o cliente HTTP; Java 17 trouxe sealed e record consolidados; Java 21 trouxe virtual threads. Item que negue a origem de um recurso costuma ser inversão pura."}},{"id":"1a686c708057","number":71,"stem":53,"statement":"Diferentemente do que ocorre com o JavaScript, as aplicações Java são executadas em uma máquina virtual ou em um browser.","answer":"C","source":{"slug":"TCE_PA_16","ano":2016},"explanation":{"verdict_reason":"O código Java é compilado em bytecode e precisa de uma máquina virtual para executar — a JVM instalada no sistema ou, no caso dos applets, a JVM acionada pelo navegador. O JavaScript não passa por essa etapa: é entregue como texto e executado diretamente pelo motor do próprio navegador, sem máquina virtual Java envolvida.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"Java executa sobre a JVM; JavaScript executa no motor do navegador","citation":null,"trap_note":"Java e JavaScript só compartilham quatro letras. Java é compilada para bytecode e fortemente tipada; JavaScript é interpretada pelo navegador e de tipagem dinâmica. Item que as trate como variantes uma da outra está errado."}},{"id":"9ba337e77ec7","number":73,"stem":53,"statement":"Empresa de desenvolvimento que opte pela utilização do Hibernate em seus sistemas enfrentará dificuldades à medida que seus projetos forem crescendo, devido ao fato de o Hibernate ser considerado inapropriado para a execução de trabalhos em uma arquitetura altamente escalável.","answer":"E","source":{"slug":"TCE_PA_16","ano":2016},"explanation":{"verdict_reason":"A premissa da qual o item deduz a dificuldade é falsa: o Hibernate é largamente empregado em sistemas de grande porte e oferece justamente os recursos que sustentam escala — cache de primeiro e segundo nível, carregamento preguiçoso, lote de operações e integração com pools de conexão. Não há a inadequação alegada.","distortion_type":"relacao_causal","distorted_span":"devido ao fato de o Hibernate ser considerado inapropriado para a execução de trabalhos em uma arquitetura altamente escalável","corrected_statement":"Empresa de desenvolvimento que opte pela utilização do Hibernate em seus sistemas contará com recursos de cache, carregamento preguiçoso e processamento em lote que sustentam arquiteturas altamente escaláveis.","concept":"Hibernate e escalabilidade","citation":null,"trap_note":"Itens no formato enfrentará dificuldades devido ao fato de constroem uma causa para justificar um julgamento negativo. Ataque a premissa antes da conclusão: se o produto não tem o defeito alegado, o item cai inteiro."}},{"id":"43f4b7f4f5ba","number":117,"stem":54,"statement":"Denomina-se polimorfismo o fato de duas ou mais classes de superclasses diferentes possuírem um método com a mesma assinatura, mas com comportamentos diferentes.","answer":"E","source":{"slug":"FUB_16_1","ano":2016},"explanation":{"verdict_reason":"O polimorfismo exige um tipo comum: as classes precisam derivar da mesma superclasse ou implementar a mesma interface, e é esse tipo compartilhado que permite tratá-las uniformemente e despachar a chamada para a implementação de cada uma. Classes de superclasses diferentes com métodos homônimos não são polimórficas — são apenas coincidentes no nome.","distortion_type":"troca_de_termo","distorted_span":"de superclasses diferentes","corrected_statement":"Denomina-se polimorfismo o fato de duas ou mais classes de uma mesma superclasse possuírem um método com a mesma assinatura, mas com comportamentos diferentes.","concept":"Polimorfismo exige tipo comum","citation":null,"trap_note":"Sem supertipo comum não há como escrever a referência que aceita ambas, e sem essa referência não há polimorfismo. Item que dispense a hierarquia comum descreve mera homonímia de métodos."}},{"id":"7abad19251df","number":119,"stem":54,"statement":"Quando uma classe é subclasse de várias superclasses, mas somente herda características de uma classe, a herança é do tipo simples.","answer":"E","source":{"slug":"FUB_16_1","ano":2016},"explanation":{"verdict_reason":"O que define herança simples ou múltipla é a quantidade de superclasses das quais a classe deriva, não a quantidade de características efetivamente aproveitadas. Ser subclasse de várias superclasses já caracteriza herança múltipla, ainda que só uma delas contribua com membros.","distortion_type":"troca_de_termo","distorted_span":"a herança é do tipo simples","corrected_statement":"Quando uma classe é subclasse de várias superclasses, mas somente herda características de uma classe, a herança é do tipo múltipla.","concept":"Herança simples × múltipla se define pelo número de superclasses","citation":null,"trap_note":"Conte as superclasses diretas, não os membros herdados: uma é simples, duas ou mais é múltipla. Java só admite a primeira entre classes; a múltipla aparece em C++ e Python."}},{"id":"6a4e58410d89","number":55,"stem":55,"statement":"A combinação de dados com o código que os manipula em um único objeto é denominada encapsulamento.","answer":"C","source":{"slug":"TJDFT_15_SERVIDOR","ano":2015},"explanation":{"verdict_reason":"Encapsulamento é exatamente a união entre estado e comportamento numa mesma unidade, com os detalhes internos protegidos do acesso externo. É por isso que, em Java, ele se materializa em atributos private acompanhados dos métodos que os manipulam.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"Encapsulamento reúne dado e código num mesmo objeto","citation":null,"trap_note":"Encapsulamento tem duas faces que a banca usa alternadamente: reunir dado e comportamento, e ocultar a implementação atrás de uma interface. Ambas as formulações são corretas e descrevem a mesma propriedade."}},{"id":"513939db9781","number":76,"stem":56,"statement":"À plataforma Java EE (Java Enterprise Edition), que é uma extensão da plataforma Java SE (Java Standard Edition), foram adicionadas, entre outras funcionalidades, bibliotecas para implementação de software Java distribuído, tolerante a falhas e multicamada. , nessa linguagem, é o mostrado a seguir.","answer":"C","source":{"slug":"TJDFT_15_SERVIDOR","ano":2015},"explanation":{"verdict_reason":"A Java EE é construída sobre a Java SE e a estende: mantém a linguagem, a JVM e as bibliotecas básicas e acrescenta as APIs corporativas — servlets, EJB, JMS, JTA, JPA — que dão suporte a aplicações distribuídas, tolerantes a falhas e organizadas em camadas.","distortion_type":"correto","distorted_span":null,"corrected_statement":null,"concept":"Java EE como extensão da Java SE","citation":null,"trap_note":"EE é superconjunto de SE, não substituto: toda aplicação Java EE roda sobre uma JVM padrão. Item que apresente as duas como plataformas paralelas e independentes erra a relação."}},{"id":"026435321de2","number":108,"stem":57,"statement":"GlassFish e TomCat são exemplos de servidores de aplicação JEE que suportam a tecnologia EJB.","answer":"E","source":{"slug":"TJDFT_15_SERVIDOR","ano":2015},"explanation":{"verdict_reason":"O Tomcat é contêiner de servlets e JSP, não servidor de aplicação JEE completo: ele não implementa o contêiner EJB nem os demais serviços corporativos da especificação. Servidor de aplicação com suporte a EJB é o GlassFish, o WildFly, o JBoss EAP ou o WebLogic.","distortion_type":"atribuicao_errada","distorted_span":"GlassFish e TomCat são exemplos de servidores de aplicação JEE que suportam a tecnologia EJB","corrected_statement":"GlassFish e WildFly são exemplos de servidores de aplicação JEE que suportam a tecnologia EJB.","concept":"Contêiner de servlets × servidor de aplicação JEE","citation":null,"trap_note":"Tomcat e Jetty são contêineres web: servlet, JSP e nada de EJB. GlassFish, WildFly, JBoss EAP e WebLogic são perfis completos. A banca insere o Tomcat numa lista de servidores de aplicação e espera que você não note."}}]}