Java + Devops (TCU) Flashcards

Question

28. (CESPE – MPU – 2013) O tratamento de exceção em Java consiste no bloco try-catch-finally. O bloco finally sempre executa ao término do bloco try.

Answer 1

Aqui está um resumo sobre os blocos **try**, **catch** e **finally** em Java: - **try**: O bloco `try` contém o código que pode lançar exceções. É usado para "tentar" executar um conjunto de instruções que podem gerar erros em tempo de execução. - **catch**: O bloco `catch` é usado para capturar e tratar as exceções que foram lançadas no bloco `try`. Ele especifica o tipo de exceção que pode ser tratada e define o que deve ser feito se essa exceção ocorrer. - **finally**: O bloco `finally` é opcional e contém código que será executado **sempre**, independentemente de uma exceção ter sido lançada ou não. Ele é geralmente usado para liberar recursos, como fechar arquivos ou conexões de banco de dados. Exemplo: ```java try { // Código que pode lançar uma exceção } catch (ExceptionType e) { // Tratamento da exceção } finally { // Código que sempre será executado } ``` A afirmação está **parcialmente correta**, mas precisa de uma ressalva. O bloco `finally` em Java **geralmente** sempre é executado ao final do bloco `try`, **independentemente** de uma exceção ter sido lançada ou não, exceto em alguns casos específicos, como quando o programa é encerrado abruptamente (por exemplo, com um `System.exit()`), ou se ocorrer uma falha no ambiente da JVM. Portanto, a parte correta da afirmação é que o `finally` tende a ser sempre executado, mas há situações excepcionais em que ele pode não ser executado. Gabarito: Errado

Answer 2

Aqui está um resumo sobre os blocos **try**, **catch** e **finally** em Java: - **try**: O bloco `try` contém o código que pode lançar exceções. É usado para "tentar" executar um conjunto de instruções que podem gerar erros em tempo de execução. - **catch**: O bloco `catch` é usado para capturar e tratar as exceções que foram lançadas no bloco `try`. Ele especifica o tipo de exceção que pode ser tratada e define o que deve ser feito se essa exceção ocorrer. - **finally**: O bloco `finally` é opcional e contém código que será executado **sempre**, independentemente de uma exceção ter sido lançada ou não. Ele é geralmente usado para liberar recursos, como fechar arquivos ou conexões de banco de dados. Exemplo: ```java try { // Código que pode lançar uma exceção } catch (ExceptionType e) { // Tratamento da exceção } finally { // Código que sempre será executado } ``` A instrução try permite que você defina um bloco de código para ser testado quanto a erros enquanto está sendo executado. A instrução catch permite definir um bloco de código a ser executado, caso ocorra um erro no bloco try. Por fim, a instrução finally permite que você execute código, depois do try...catch, independentemente do resultado. Mas há casos em que o finally não é executado. Questão correta! Gabarito: Correto

Answer 3

Pessoal, o correto é Try e catch. Gabarito: Letra A

Answer 4

A afirmação está **correta**. A linguagem Java é orientada a objetos e tem como uma de suas principais características a compilação do código-fonte em **bytecode**. Esse bytecode não é executado diretamente pelo sistema operacional ou processador, mas sim pela **Máquina Virtual Java (JVM)**. Isso permite que o mesmo código Java seja executado em diferentes plataformas, desde que haja uma JVM adequada, garantindo a portabilidade do código (o famoso conceito de "escreva uma vez, execute em qualquer lugar"). Gabarito: Correto

Answer 5

A afirmação está **correta**. A instrução `import java.awt.*;` em Java indica que o programa utilizará classes do pacote **AWT (Abstract Window Toolkit)**, que contém componentes gráficos e ferramentas para construção de interfaces gráficas de usuário (GUI), como janelas, botões, e outros elementos gráficos. Portanto, a instrução permite o uso de componentes gráficos, como o próprio texto afirma. Gabarito: Correto

Answer 6

Pessoal, esses Modificadores de Acesso determinam quão acessíveis são esses elementos. Vamos vê-los agora em mais detalhes:: essa instrução indica que a classe, método ou atributo assim declaradas podem ser acessadas em qualquer lugar e a qualquer momento da execução do programa – é o modificador menos restritivo. Perfeito, são públicos para toda e qualquer classe. Gabarito: Correto

Answer 7

A resposta correta é a **letra C) Segunda!** Aqui está a explicação: 1. A classe `Sexta` estende `Quinta` e implementa a interface `Quarta`, que por sua vez estende as interfaces `Segunda` e `Terca`. Isso significa que `Sexta` deve implementar os métodos das três interfaces, o que ela faz. 2. Na linha 21, o código cria uma instância da classe `Sexta`, mas o objeto é referenciado como `Quinta`, ou seja, ele é tratado como um objeto da superclasse `Quinta` (polimorfismo). 3. Ao chamar `dia.segunda()` na linha 22, o método `segunda()` da **classe `Sexta`** é executado, porque em Java, mesmo que a referência seja de uma classe pai (`Quinta`), a versão do método da classe filha (`Sexta`) será chamada devido ao **polimorfismo**. 4. A versão de `segunda()` em `Sexta` imprime `"Segunda!"`. Portanto, a saída do programa será **"Segunda!"**. Gabarito: C

Answer 8

A questão trata de conceitos de orientação a objetos, como encapsulamento, herança e polimorfismo, no contexto da linguagem Java. Vamos analisar cada uma das opções: **a) os atributos private de DocumentoProcesso são acessíveis por Oficio;** Essa afirmação está incorreta. Em Java, os atributos marcados como `private` em uma classe não são diretamente acessíveis por suas subclasses. No caso, `Oficio` não pode acessar diretamente os atributos `private` de `DocumentoProcesso`. **b) a anotação @Override indica que o método promove() é abstrato e polimórfico;** Essa afirmação também está incorreta. A anotação `@Override` não indica que um método é abstrato. Ela indica que um método da classe filha está sobrescrevendo um método da classe pai. No caso, o método `promove()` na classe `Oficio` está sobrescrevendo o método `promove()` da classe `DocumentoProcesso`, mas nenhum deles é abstrato. **c) a classe Oficio representa uma herança múltipla das classes DocumentoProcesso e Object;** Essa afirmação está incorreta. Java não suporta herança múltipla de classes, ou seja, uma classe não pode herdar diretamente de mais de uma classe. A classe `Oficio` herda apenas de `DocumentoProcesso`, e `DocumentoProcesso` herda implicitamente de `Object`, pois todas as classes em Java herdam de `Object`. **d) a classe Oficio é composta pela classe DocumentoProcesso, permitindo que uma instância da classe Oficio faça referências a instâncias da classe DocumentoProcesso;** Essa afirmação está incorreta. A relação entre `Oficio` e `DocumentoProcesso` é de herança (a classe `Oficio` herda de `DocumentoProcesso`), e não de composição. Composição envolve uma classe conter instâncias de outra classe como atributos, o que não é o caso aqui. **e) os métodos getDocNumero() e setDocNumero() da classe DocumentoProcesso encapsulam o atributo docNumero e asseguram que os objetos da classe mantenham estados consistentes;** Essa afirmação está correta. Os métodos `getDocNumero()` e `setDocNumero()` fornecem acesso ao atributo `docNumero` da classe `DocumentoProcesso`, e esse mecanismo é uma forma de **encapsulamento**. O encapsulamento permite proteger os atributos e garantir que eles sejam acessados e modificados de maneira controlada, o que ajuda a manter a consistência do estado do objeto. Portanto, a resposta correta é **letra e**. Gabarito: E

Answer 9

Vamos analisar o código da classe **Calcular** e as afirmações: ```java public class Calcular { public double reajuste(double salario, double percentual) { return salario + salario * percentual / 100; } public double reajuste(double salario) { return salario * 1.30; } public static double reajuste(float salario) { return salario * 0.20; } } ``` Agora, analisemos cada opção: **a) o código mostra um exemplo de sobrescrita de métodos, pois há vários métodos com o mesmo nome, porém, com parâmetros diferentes.** Essa afirmação está incorreta. O que ocorre aqui é **sobrecarga de métodos** (overloading), não sobrescrita (overriding). A sobrecarga ocorre quando há métodos com o mesmo nome, mas com assinaturas diferentes (diferentes tipos ou quantidades de parâmetros). Sobrescrita ocorre quando uma classe filha redefine um método da classe pai. **b) ocorrerá um erro no último método reajuste, pois este não pode ser estático.** Essa afirmação está incorreta. O método estático é permitido e não causará erro. Métodos estáticos podem coexistir com métodos não estáticos, desde que suas assinaturas sejam diferentes, o que é o caso aqui (o método estático recebe um `float`, enquanto os outros recebem `double`). **c) uma chamada correta ao método reajuste, em condições ideais, é:** ```java double sal = 1000.5; double c = Calcular.reajuste(sal); ``` Essa afirmação está incorreta. O método `reajuste` que recebe `double` e tem apenas um parâmetro não é estático. Portanto, para chamá-lo, seria necessário criar uma instância da classe `Calcular`, como: ```java Calcular calc = new Calcular(); double c = calc.reajuste(sal); ``` **d) ocorrerá um erro na classe Calcular, pois não é permitido criar vários métodos com o mesmo nome, como ocorre com o método reajuste.** Essa afirmação está incorreta. Em Java, é perfeitamente permitido ter vários métodos com o mesmo nome, desde que suas assinaturas sejam diferentes (sobrecarga de métodos). **e) uma chamada correta ao método reajuste, em condições ideais, é:** ```java float sal = (float) 1000.5; double c = Calcular.reajuste(sal); ``` Essa afirmação está **correta**. O método `reajuste` que recebe `float` é estático, então pode ser chamado diretamente pela classe `Calcular`, sem precisar de uma instância. Portanto, a resposta correta é **letra e**. Gabarito: E

Answer 10

Um **class constructor** em Java é um método especial usado para inicializar objetos de uma classe. Ele tem o mesmo nome da classe, não possui tipo de retorno (nem mesmo `void`) e é executado automaticamente quando um objeto é criado com o operador `new`. O construtor é utilizado principalmente para definir valores iniciais dos atributos da classe e garantir a correta criação do objeto. ------------------- Vamos analisar cada uma das afirmativas sobre **construtores (class constructor)** em Java: **I. Deve receber o mesmo nome da classe a ele associada.** Essa afirmativa é **correta**. Em Java, o construtor deve ter exatamente o mesmo nome da classe. Caso contrário, o compilador não o reconhecerá como um construtor. **II. Não deve ser especificado um tipo de retorno na sua declaração.** Essa afirmativa é **correta**. Construtores em Java não têm tipo de retorno, nem mesmo `void`. Se for especificado algum tipo de retorno, ele será tratado como um método regular, e não como um construtor. **III. É útil para a definição de valores iniciais para os atributos da classe.** Essa afirmativa é **correta**. O principal propósito de um construtor é inicializar os atributos de uma classe quando um objeto é criado. **IV. É sempre declarado como public.** Essa afirmativa é **incorreta**. Construtores podem ter qualquer modificador de acesso, como `public`, `protected`, `private`, ou mesmo o modificador padrão (sem especificar), dependendo do controle que se deseja sobre a criação de objetos. Construtores privados, por exemplo, são comuns em padrões de projeto como o **Singleton**. Agora, analisando as opções: - **a) I e II;** Correta, mas incompleta, já que a afirmativa III também é correta. - **b) II e III;** Correta, mas incompleta, já que a afirmativa I também é correta. - **c) III e IV;** Incorreta, pois a afirmativa IV está errada. - **d) I, II e III;** **Correta**, pois as três afirmativas são verdadeiras. - **e) I, III e IV;** Incorreta, pois a afirmativa IV está errada. Portanto, a resposta correta é **letra d**. Gabarito: D

Answer 11

Em Java, tanto a classe **`Error`** quanto a classe **`Exception`** derivam da classe **`Throwable`**. A classe `Throwable` é a superclasse de todas as classes que podem ser usadas com a palavra-chave **`throw`** ou capturadas por um **`try-catch`**. Ela tem duas subclasses principais: - **`Error`**: Representa erros graves no ambiente de execução que normalmente não podem ser recuperados, como `OutOfMemoryError`. - **`Exception`**: Representa exceções que podem ser tratadas durante a execução normal do programa. Portanto, a resposta correta é: **e) Throwable.**

Answer 12

Em Java, variáveis e métodos declarados como **`private`**: - São acessíveis apenas pela própria classe. - Não podem ser acessados por classes no mesmo pacote ou por subclasses. Portanto, a única afirmativa correta é a I. **Resposta:** a) I, apenas. Gabarito: A

Answer 13

Para compilar um ou mais arquivos Java na linha de comando, o comando correto utiliza o compilador Java, que é o **`javac`**. - O comando **`javac`** é usado para compilar arquivos `.java`, gerando arquivos `.class` que podem ser executados pela JVM. - No caso de compilar todos os arquivos `.java` no diretório, você pode usar o comando **`javac *.java`**. Agora, vamos analisar as opções: - **a) compile teste.java –type java** Incorreto. Não existe o comando `compile` em Java. - **b) java teste.java** Incorreto. O comando `java` é usado para **executar** programas já compilados (arquivos `.class`), não para compilá-los. - **c) javac *.java** **Correto**. Esse comando compila todos os arquivos `.java` no diretório atual. - **d) jvm Teste1.java teste2.java** Incorreto. Não existe o comando `jvm` para compilar ou executar programas Java. - **e) parse java teste.java** Incorreto. O comando `parse` não é um comando Java. Resposta correta: **c) javac *.java** Gabarito: C

Answer 14

Vamos analisar o código e as opções fornecidas para exibir corretamente um elemento de cada linha do array bidimensional **`multi`** definido como: ```java int[][] multi = new int[5][10]; ``` Esse array possui 5 linhas e 10 colunas. Para exibir um elemento de cada linha, o índice da coluna deve ser um valor válido (de 0 a 9), e o índice da linha deve ser de 0 a 4. Agora, vamos analisar as opções: **a) `for (int i = 0; i < 5; i++) { System.out.println(multi[i][0]); };`** - **Correta.** Este código percorre as 5 linhas do array e imprime o primeiro elemento de cada linha (`multi[i][0]`). **b) `for (int i = 0; i < 10; i++) { System.out.println(multi[i,1]); };`** - **Incorreta.** A sintaxe de acesso ao array está errada. Deve ser `multi[i][1]` em vez de `multi[i,1]`. **c) `for (int i = 0; i <= 5; i++) { System.out.println(multi[i,0]); };`** - **Incorreta.** O índice `i` vai de 0 a 5, mas o último índice válido para as linhas é 4. Isso causará um **ArrayIndexOutOfBoundsException**. **d) `for (int i = 0; i <= multi.length; i++) { System.out.println(multi[1,i]); };`** - **Incorreta.** O índice `i` também vai de 0 a 5, o que causará uma exceção, além de estar usando a sintaxe errada (`multi[1,i]` deve ser `multi[1][i]`). **e) `for (int i = 1; i < multi[0].length; i++) { System.out.println(multi[i,1]); };`** - **Incorreta.** A sintaxe de acesso ao array está errada (`multi[i,1]` deve ser `multi[i][1]`) e `i` começa em 1, o que não acessará a primeira linha. Resumo da Resposta: A única opção correta que exibe um elemento de cada linha do array **`multi`** é: **a) `for (int i = 0; i < 5; i++) { System.out.println(multi[i][0]); };`** Gabarito: A

Answer 15

No contexto da linguagem Java, o modificador que se refere ao nível de acesso é **`protected`**. Esse modificador permite que membros (atributos e métodos) de uma classe sejam acessados por: - A própria classe. - Subclasses (mesmo que estejam em pacotes diferentes). - Outras classes no mesmo pacote. Vamos revisar brevemente as opções: - **a) abstract**: Indica que uma classe ou método é abstrato, ou seja, não pode ser instanciado e deve ser implementado em subclasses. - **b) final**: Indica que uma classe não pode ser estendida, um método não pode ser sobrescrito, ou uma variável não pode ser alterada após a inicialização. - **c) protected**: **Correto**. Refere-se ao nível de acesso dos membros da classe. - **d) static**: Indica que um membro pertence à classe em si, e não a instâncias específicas da classe. - **e) volatile**: É usado para indicar que uma variável pode ser alterada de forma inesperada, principalmente em ambientes multithreading, mas não se refere ao nível de acesso. Resposta correta: **c) protected.**

Answer 16

Vamos analisar cada uma das afirmativas sobre construtores em Java: **I. Os construtores devem ser declarados como private.** - **Incorreta.** Construtores podem ter qualquer modificador de acesso (como `public`, `protected`, `private`, ou padrão), dependendo do controle que se deseja sobre a criação de objetos. Um construtor `private` é usado, por exemplo, em padrões de projeto como o Singleton, mas não é uma obrigação. **II. Uma interface não pode ter um construtor.** - **Correta.** Interfaces não podem ter construtores, pois não podem ser instanciadas diretamente. Uma interface pode declarar métodos, mas não pode criar objetos. **III. Uma classe abstrata pode ter um construtor.** - **Correta.** Classes abstratas podem ter construtores, que podem ser usados por subclasses para inicializar os atributos herdados. Conclusão: - A afirmativa II e a afirmativa III estão corretas. Resposta correta: **e) II e III, somente.** Gabarito: E

Answer 17

O pacote **`java.util.regex`** em Java oferece classes para manipulação de expressões regulares, e as três classes mais importantes desse pacote são: - **`Pattern`**: Representa uma expressão regular compilada. - **`Matcher`**: Realiza a correspondência de padrões em uma sequência de caracteres. - **`PatternSyntaxException`**: Indica um erro de sintaxe em uma expressão regular. Portanto, a resposta correta é: **c) Pattern, Matcher e PatternSyntaxException.** Gabarito: C

Answer 18

A API utilizada para fornecer acesso ao servidor de nomes e diretórios em servidores de aplicação baseados em Java Platform Enterprise Edition é a **JNDI** (Java Naming and Directory Interface). Aqui está um breve resumo das opções: - **a) JNDI**: **Correta.** Fornece uma interface para localizar e acessar recursos e serviços em um servidor de nomes e diretórios. - **b) RMI**: (Remote Method Invocation) permite que um objeto Java invoque métodos em objetos em outra máquina. - **c) JMS**: (Java Message Service) fornece uma interface para comunicação assíncrona entre componentes de aplicativos. - **d) JTS**: (Java Transaction Service) fornece suporte para transações distribuídas. - **e) JDBC**: (Java Database Connectivity) permite a conexão e a execução de consultas em bancos de dados relacionais. Resposta correta: **a) JNDI.** Gabarito: A

Answer 19

Vamos analisar as afirmativas sobre os servidores de aplicação da plataforma Java EE: **I. GlassFish e Apache Geronimo são servidores de aplicação open source compatível com a especificação J2EE.** - **Correta.** Tanto o GlassFish quanto o Apache Geronimo são servidores de aplicação de código aberto que implementam a especificação J2EE (Java 2 Platform, Enterprise Edition). **II. O Apache Tomcat não dispõe de um container EJB.** - **Correta.** O Apache Tomcat é um servidor de servlet que implementa as especificações de servlets e JSP, mas não suporta EJB (Enterprise JavaBeans) nativamente. **III. JBoss é programado em Java, portanto, pode ser usado em qualquer sistema operacional que suporte essa linguagem de programação.** - **Correta.** O JBoss (atualmente conhecido como WildFly) é um servidor de aplicação que é escrito em Java e, portanto, pode ser executado em qualquer sistema operacional que tenha uma JVM (Java Virtual Machine) instalada. Conclusão: Todas as afirmativas estão corretas. Resposta correta: **e) I, II e III.** Gabarito: E

Answer 20

Para que um método possa ser invocado independentemente da criação de uma instância da classe, ele deve ser declarado como **`static`**. Métodos estáticos pertencem à classe em si, e não a instâncias específicas da classe. Assim, eles podem ser chamados sem que uma instância da classe seja criada. Vamos revisar as opções: - **a) abstract**: Indica que o método não tem uma implementação na classe, mas deve ser implementado em subclasses. Não é relevante para a invocação sem instância. - **b) static**: **Correta.** Permite que o método seja chamado sem uma instância da classe. - **c) public**: Indica que o método pode ser acessado de qualquer lugar, mas não garante que ele possa ser chamado sem uma instância. - **d) protected**: Permite que o método seja acessado apenas por subclasses e classes no mesmo pacote, mas não permite a chamada sem instância. - **e) final**: Indica que o método não pode ser sobrescrito em subclasses, mas não está relacionado com a criação de instâncias. Resposta correta: **b) static.** Gabarito: B

Answer 21

A forma correta para a assinatura do método é conforme a sintaxe: [Palavras-Chave] TipoRetorno NomeMetodo ([Lista de Parâmetros]). Assim, temos um método public, daí eliminamos a letra B. É definido como static porque os métodos static tem um relacionamento com uma classe como um todo, enquanto os métodos que não são static são associados a uma instância de classe específica (objeto) e podem manipular as variáveis de instância do objeto. Portanto eliminamos as alternativas a, b e d. O retorno é um vetor de inteiros, portanto int[], daí eliminamos as alternativas c e d. Ficamos então com a alternativa E que é o nosso gabarito: public static int[] verificar(int vet[]) Gabarito: Letra E

Answer 22

Um PreparedStatement é um objeto que representa uma instrução SQL pré-compilada. Uma instrução SQL é pré-compilada e armazenada em um objeto PreparedStatement. Esse objeto pode ser usado para executar com eficiência essa instrução várias vezes. Às vezes, é mais conveniente usar um objeto PreparedStatement para enviar instruções SQL ao banco de dados. Esse tipo especial de instrução é derivado da classe mais geral, Statement, que você já conhece. Se você deseja executar um objeto Statement muitas vezes, geralmente reduz o tempo de execução para usar um objeto PreparedStatement. A principal característica de um objeto PreparedStatement é que, diferentemente de um objeto Statement, ele recebe uma instrução SQL quando é criado. A vantagem disso é que, na maioria dos casos, essa instrução SQL é enviada imediatamente ao DBMS, onde é compilada. Como resultado, o objeto PreparedStatement contém não apenas uma instrução SQL, mas uma instrução SQL que foi pré-compilada. Isso significa que quando o PreparedStatement é executado, o DBMS pode apenas executar a instrução SQL PreparedStatement sem ter que compilá-lo primeiro. A ideia é preparar as querys do SQL para armazenamento no banco de dados. O tutorial da Oracle diz que nós devemos usar a interrogação para inserir na tabela cliente (?,?,?,?,?,?,?). Portanto o gabarito é a letra B. Gabarito: Letra B

Answer 23

A opção correta para receber e converter um parâmetro "renda" de um formulário HTML em um número real no método `doPost` de uma servlet Java é: **d) `double renda = Double.parseDouble(request.getParameter("renda"));`** Análise das opções: - **a)** Incorreta: Converte para `long`, não para número real. - **b)** Incorreta: Falta o prefixo da classe `Double`. - **c)** Incorreta: `toDouble()` não é um método válido em Java. - **d)** Correta: Converte a string recebida em um número real (double). - **e)** Incorreta: `number` não é um tipo em Java; `parseNumber` não é um método padrão. **Conclusão:** A opção **d** é a única correta. Gabarito: D

Answer 24

Pessoal, caso o driver JDBC não esteja disponível na aplicação, irá acusar um erro chamado ClassNotFoundException. Os comandos não irão conseguir encontrar a classe informada, pois não há o driver disponível. Por fim, como não existe o BD, o JDBC informa que é um erro chamado SQLException, ele acusa algum erro no banco de dados, como a questão nos informou que ele não existe não precisamos ficar procurando esse erro na aplicação. Gabarito: Letra D

Answer 25

Pessoal, a resposta correta é a letra E. Não existe o método add para array no Java, mas sim no ArrayList. Ademais, a letra a erra porque não é necessário especificar o tamanho. O erro da letra B está em dizer que deve haver apenas um par de colchetes. E a letra C está errada pois é possível sim declarar e incluir valores no array. Por fim, os colchetes podem ficar antes ou depois da variável. Gabarito: Letra E

Answer 26

Para implementar corretamente o algoritmo de ordenação por inserção no método `ordena`, precisamos preencher as lacunas **I** e **II**. Vamos analisar o funcionamento do algoritmo e as opções dadas. Algoritmo de Ordenação por Inserção No algoritmo de ordenação por inserção: 1. O loop externo percorre o vetor a partir do segundo elemento (`j = 1`). 2. A variável `x` armazena o valor a ser inserido na posição correta. 3. O loop interno deve deslocar os elementos maiores que `x` para a direita, para criar espaço para `x`. 4. Após o deslocamento, `x` deve ser colocado na posição correta. Lacuna I Para a lacuna **I**, precisamos inicializar `i` para o índice do elemento anterior ao que estamos tentando inserir (`j - 1`). O loop interno deve continuar enquanto `i` for maior ou igual a zero e enquanto o valor em `v[i]` for maior que `x`. Lacuna II Na lacuna **II**, precisamos inserir `x` na posição correta, que será `v[i + 1]`, após o deslocamento dos elementos. Análise das opções Agora, vamos analisar cada uma das opções: - **a)** `i=j-1; i >=0 && v[i]>x; − −i e v[i-1]=x` - **Incorreta.** O deslocamento está errado, e a inserção não está na posição correta. - **b)** `i=j-1; i >=0; i++ e v[i+1]=x` - **Incorreta.** O loop não é definido corretamente, e o deslocamento não funcionará. - **c)** `i=j-1; i >=0 && v[i]>x; − −i e v[i+1]=x` - **Correta.** O loop interno é configurado corretamente, e `x` é inserido na posição `v[i+1]`. - **d)** `i=j-1; i >=0 && v[i]>x; ++i e v[i]=x` - **Incorreta.** A inserção de `x` não está na posição correta. - **e)** `i=j-1; i >=0 || v[i]>x; − −i e v[i+1]=x` - **Incorreta.** O uso de `||` é inadequado aqui e causaria comportamento inesperado. Conclusão As lacunas **I** e **II** devem ser preenchidas como segue: - **Lacuna I:** `i=j-1; i >=0 && v[i]>x; --i` - **Lacuna II:** `v[i + 1] = x` Portanto, a resposta correta é: **c) i=j-1; i >=0 && v[i]>x; − −i e v[i+1]=x** Gabarito: C

Answer 27

Para responder a questão devemos ter em mente que é necessário fazer o método cadastraDados passar algo por parâmetro. Para isso, devemos utilizar a alternativa A: public static double[] cadastraDados(double[] d) Gabarito: Letra A

Answer 28

Pessoal, analisando as alternativas, podemos observar na letra A a criação de um método "private abstract". Porém, em Java, não é permitido declarar um método como "private abstract"! daí já sabemos que a alternativa errada (gabarito da questão) é a letra A. Já, a letra B está correta, veja é a declaração de um método abstrato sem implementação. As demais alternativas também estão plenamente corretas. Gabarito: Letra A.

Answer 29

O comando para imprimir a segunda posição de um vetor de três posições deverá pegar a posição n[1] já que, em Java, o vetor inicia na posição 0. Portanto ficamos apenas com as alternativas b e d. A letra d apresenta um erro porque System.out.Println não possui o parâmetro null como é apresentado na questão. Portanto nosso gabarito é a letra B. Gabarito: Letra B

Answer 30

Para permitir que exceções sejam tratadas fora do método `conectar` na classe `ClienteDados`, o método deve declarar as exceções que pode lançar. No caso apresentado, as exceções relevantes são `ClassNotFoundException` e `SQLException`. Análise das opções a) **`try` na linha abaixo da declaração do método e `catch (DataBaseException, SQLQueryException)` abaixo do comando `return 1`.** - **Incorreta**: Usar `try` e `catch` dentro do método não atende ao requisito de lançar as exceções para serem tratadas fora dele. b) **`throws ClassNotFoundException, SQLException` na linha de declaração do método.** - **Correta**: Essa é a forma correta de indicar que o método pode lançar essas exceções, permitindo que quem chamar o método trate essas exceções. c) **`Exception ClassNotFoundException, SQLException` na linha de declaração do método.** - **Incorreta**: Essa sintaxe é inválida em Java. Não se pode declarar exceções desta forma. d) **`try` na linha abaixo da declaração do método e `catch (ClassNotFoundException, SQLException)` abaixo do comando `return 1`.** - **Incorreta**: Novamente, usar `try` e `catch` dentro do método não atende ao requisito de lançar as exceções. e) **`throws DataBaseException, SQLQueryException` na linha de declaração do método.** - **Incorreta**: `DataBaseException` e `SQLQueryException` não são exceções padrão da biblioteca Java. As exceções corretas são `ClassNotFoundException` e `SQLException`. Conclusão A opção correta para permitir que as exceções sejam tratadas fora do método `conectar` é: **b) `throws ClassNotFoundException, SQLException` na linha de declaração do método.** Gabarito: B

Answer 31

A alternativa correta para instanciar um objeto da classe `Colaborador` e armazenar o nome "Pedro" no atributo `nome` é: **d)** `Colaborador c = new Colaborador(); c.setNome("Pedro");` Resumo das alternativas: - **a)** Incorreto — Método de instância não pode ser chamado diretamente na classe. - **b)** Incorreto — Sintaxe errada e acesso direto a atributo privado. - **c)** Incorreto — `setNome` não retorna um objeto. - **e)** Incorreto — `setNome` não retorna a instância. A única alternativa correta é a **d**. Gabarito: D

Answer 32

A alternativa correta sobre as interfaces em Java é: **a)** os métodos não podem ter os modificadores protected ou private. Justificativas para as outras alternativas: - **b)** Incorreto — Em uma interface, pode haver métodos com retorno do tipo `void`. - **c)** Incorreto — Interfaces não têm construtores, pois não podem ser instanciadas. - **d)** Incorreto — Em uma interface, pode haver métodos com o mesmo nome, desde que tenham parâmetros diferentes (sobrecarga). - **e)** Incorreto — Um método em uma interface deve ser implementado pelas classes que a implementam, mas não necessariamente por todas as subclasses; se uma subclasse não implementar o método, ela deve ser declarada como abstrata. Portanto, a alternativa **a** é a única correta. Gabarito: A

Answer 33

A alternativa correta sobre o que uma interface pode fazer em Java é: **a)** herdar de mais de uma interface. Justificativas para as outras alternativas: - **b)** Incorreto — Interfaces não podem ser instanciadas diretamente. Elas precisam ser implementadas por classes. - **c)** Incorreto — Uma interface pode possuir apenas assinaturas de métodos públicos, pois todos os métodos em uma interface são implicitamente públicos (não podem ser protegidos ou privados). - **d)** Incorreto — Interfaces podem ter apenas métodos abstratos (a partir do Java 8, métodos default e estáticos são permitidos, mas a afirmação não é completamente correta). - **e)** Incorreto — Interfaces podem conter declarações de constantes (variáveis `static final`), mas não podem ter variáveis não inicializadas. Portanto, a alternativa **a** é a única correta. Gabarito: A

Answer 34

A alternativa **INCORRETA** sobre o Java Standard Edition (Java SE) é: **b)** Ambiente indicado para o desenvolvimento de aplicativos para dispositivos móveis ou portáteis. Justificativas para as outras alternativas: - **a)** Correto — Java SE possui gerenciamento de memória embutido por meio do coletor de lixo. - **c)** Correto — Permite o desenvolvimento de aplicações desktop, tanto de linha de comando quanto com interfaces gráficas usando Swing. - **d)** Correto — A portabilidade dos programas compilados é uma das principais características do Java, permitindo que sejam executados em diversos sistemas operacionais sem necessidade de recompilação. - **e)** Correto — Java utiliza conceitos de orientação a objetos e multithreading. Assim, a alternativa **b** é a única que não se aplica ao Java SE, pois ele não é especificamente voltado para o desenvolvimento de aplicativos móveis, que é mais associado ao Java Micro Edition (Java ME). Gabarito: B

Answer 35

O bytecode é um código intermediário, que é posteriormente interpretado e executado por uma Java Virtual Machine (JVM). Gabarito: Letra A

Answer 36

Java é também uma linguagem portável e multiplataforma! O Compilador é capaz de gerar um código intermediário (bytecode), que permite que o mesmo programa possa ser executado em qualquer máquina ou sistema operacional que possua uma JVM. Ademais, busca que todos os aspectos da linguagem sejam independentes de plataforma (Ex: ela especifica o tamanho e comportamento de cada tipo de dado). Conforme vimos em aula, trata-se da linguagem Java. Gabarito: Letra D

Answer 37

O bytecode é um código intermediário, que é posteriormente interpretado e executado por uma Java Virtual Machine (JVM). Gabarito: Letra C

Answer 38

Pessoal, é necessário saber os conceitos de herança e polimorfismo. Primeiramente, devemos ter em mente que não existe Herança múltipla em Java. Daí a assertiva I está incorreta. Vejamos o que diz a assertiva II: Polimorfismo em Java é a capacidade de duas ou mais classes derivadas de uma mesma superclasse possuírem a mesma assinatura de um método, porém com comportamento diferente. Está perfeita a definição. Gabarito: Letra A

Answer 39

Pessoal, para criar uma classe que não poderá ser instanciada, mas ainda poderá ser reutilizada devemos utilizar public abstract class NomeDaClasse. Porque a classe abstrata é sempre uma superclasse que não possui instâncias. Gabarito: Letra A

Answer 40

A resposta correta é a **letra a) polimorfismo de sobrecarga**. O polimorfismo na programação orientada a objetos pode ser classificado em dois tipos principais: **polimorfismo de sobrecarga** (ou ad-hoc) e **polimorfismo de subtipo** (ou de inclusão). No caso da sobrecarga, o polimorfismo ocorre quando diferentes funções ou métodos com o mesmo nome podem ser chamados com diferentes tipos ou números de parâmetros, respondendo de maneira distinta conforme a assinatura. Gabarito: Letra A

Answer 41

A alternativa correta é a **letra b) interface Futebol extends Esporte, Coletivo{}**. No Java, uma interface pode **estender** (extends) outras interfaces, mas não pode implementar (implements) outra interface. A palavra-chave **extends** é utilizada para herdar de interfaces, enquanto **implements** é usada por classes que implementam interfaces. Além disso, uma classe não pode estender (extends) uma interface, como apresentado na letra "d". Gabarito: Letra B

Answer 42

(a) Na verdade, podem ter outros comandos – não é só atribuição; (b) Perfeito, enquanto for verdadeira, continua a iteração; (c) Não, enquanto ela for verdadeira; (d) Não, esse comando não existe; (e) Não, esse comando entra no bloco e só depois avalia a condição. Gabarito: Letra B

Answer 43

A resposta correta é a **letra b) class MemoriaCalculoVenda implements MemoriaCalculo**. No Java, uma classe usa a palavra-chave **implements** para declarar que está implementando uma interface. Nesse caso, como a interface **MemoriaCalculo** já foi criada pela organização e a classe **MemoriaCalculoVenda** deve implementar essa interface, a sintaxe correta é utilizar **implements** para indicar essa relação entre a classe e a interface. A palavra **extends** seria usada apenas no caso de herança entre classes, não entre uma classe e uma interface. Gabarito: B

Answer 44

A resposta correta é a **letra d) polimorfismo**. A linguagem Java **suporta polimorfismo**, que é a capacidade de uma classe utilizar métodos de uma superclasse ou interface de maneira que comportamentos diferentes possam ser implementados, dependendo do tipo real do objeto. Analisando as outras alternativas: - **a) passagem de parâmetros de tipos primitivos por referência**: Java utiliza **passagem por valor** para tipos primitivos, não por referência. - **b) sobrecarga de operadores**: Java **não suporta sobrecarga de operadores** (diferente de linguagens como C++). - **c) herança múltipla**: Java **não permite herança múltipla** de classes, mas permite herança múltipla através de **interfaces**. - **e) ponteiros**: Java **não utiliza ponteiros** diretamente, ao contrário de linguagens como C/C++. Portanto, a característica correta que Java suporta é **polimorfismo**. Gabarito: D

Answer 45

❌ **Gabarito: ERRADO (Falso)** A afirmativa está **incorreta**. Justificativa técnica (padrão CESPE/Cebraspe): No contexto de **Servlets Java**, há uma **diferença fundamental** entre **parâmetros** e **atributos** da requisição. --- 🔹 `getParameter("nome")` ✅ * Recupera **dados enviados pelo cliente** na requisição HTTP: * formulário HTML (``) * query string * corpo do `POST` * É exatamente o caso do código apresentado, que trata dados submetidos por um formulário. ```java String nome = request.getParameter("nome"); ``` --- 🔹 `getAttribute("nome")` ❌ * Recupera **objetos previamente armazenados no servidor** na requisição: * via `request.setAttribute("nome", valor)` * geralmente usados para comunicação entre servlets ou JSPs * **Não acessa dados do formulário** automaticamente. ```java String nome = (String) request.getAttribute("nome"); ``` --- ❌ Por que há perda de funcionalidade? * O código **não define nenhum atributo** chamado `"nome"` usando `setAttribute`. * Ao substituir `getParameter` por `getAttribute`, a variável `nome` passaria a ser **`null`**, quebrando a lógica de exibição da resposta. 📌 Em provas do **CESPE/Cebraspe**, trocar **parâmetro** por **atributo** **não é equivalente** e caracteriza erro conceitual clássico. --- ✅ Conclusão A linha **não pode ser alterada sem perda de funcionalidade**. 👉 **Resposta final: ERRADO.**

Answer 46

✅ **Gabarito: letra A) hotspot** **Justificativa:** A **JVM (Java Virtual Machine)** utiliza a tecnologia chamada **HotSpot** para **aumentar o desempenho da aplicação**. 📌 **HotSpot** funciona da seguinte forma: * Identifica **trechos de código executados com muita frequência** (*hot spots*), normalmente: * dentro de **loops**, * métodos chamados repetidamente; * Esses trechos são então **compilados dinamicamente (JIT – Just-In-Time)** para código nativo otimizado; * O resultado é **execução mais rápida** em tempo de execução. Análise das alternativas: * **a) hotspot** ✅ ✔ Tecnologia da JVM voltada à **otimização dinâmica de desempenho**. * **b) bytecode** ❌ Código intermediário executado pela JVM, não uma tecnologia de otimização. * **c) compilação estática** ❌ Java utiliza majoritariamente **compilação dinâmica (JIT)**, não estática. * **d) JRE (Java Runtime Environment)** ❌ Ambiente de execução, não uma tecnologia específica de otimização. * **e) JDK (Java Development Kit)** ❌ Kit de desenvolvimento, não relacionado à execução otimizada. 👉 **Resposta correta:** **A) hotspot**.

Answer 47

✅ **Gabarito: letra E** **Justificativa (padrão CESPE/Cebraspe):** A alternativa **E** é a **única correta**, pois descreve adequadamente os **princípios e práticas do DevOps**. --- ✅ **e) Correta** > *Atividades típicas em DevOps compreendem teste do código automatizado, automação de fluxos de trabalho e da infraestrutura e requerem ambientes de desenvolvimento e produção idênticos.* ✔ DevOps enfatiza: * **Automação de testes** (CI – Continuous Integration); * **Automação de pipelines, fluxos e infraestrutura** (CI/CD, Infrastructure as Code); * **Paridade entre ambientes** (desenvolvimento, homologação e produção), reduzindo erros do tipo *“funciona na minha máquina”*. --- ❌ Análise das demais alternativas: * **a) Incorreta** ❌ DevOps **aumenta** a colaboração entre equipes (Dev + Ops), não reduz. * **b) Incorreta** ❌ DevOps prioriza **pequenas mudanças frequentes**, pouca documentação excessiva e **valor contínuo ao usuário**, aproximando-se de métodos ágeis — não do cascata. * **c) Incorreta** ❌ A **nuvem favorece** DevOps, pois facilita automação, escalabilidade e provisionamento rápido. * **d) Incorreta** ❌ DevOps prega **equipes integradas, alta interação e forte automação**, exatamente o oposto do que foi afirmado. --- 🎯 **Conclusão** A alternativa que reflete corretamente os fundamentos do **DevOps** é: 👉 **E** ✅

Answer 48

✅ **Gabarito: letra D** **Justificativa (padrão CESPE/Cebraspe):** A alternativa **D** é a **correta**, pois define adequadamente o conceito de **DevOps**. --- ✅ **d) Correta** > *um processo de promoção de métodos que objetivam aprimorar a comunicação, tornando a colaboração eficaz especialmente entre os departamentos de desenvolvimento e teste e entre os departamentos de operações e serviço para o negócio.* ✔ **DevOps** é um **conjunto de práticas, cultura e métodos** que: * promovem **integração e colaboração**; * reduzem silos entre **desenvolvimento (Dev)** e **operações (Ops)**; * visam **entrega contínua de valor ao negócio**; * enfatizam **automação, comunicação e feedback contínuo**. --- ❌ Análise das demais alternativas: * **a) Incorreta** ❌ DevOps **não é um processo estruturado em fases** como o RUP/IRUP. * **b) Incorreta** ❌ DevOps **não é uma plataforma** nem substitui containers ou virtualização. * **c) Incorreta** ❌ Descreve ferramentas como **Git**, **SVN** ou **CI/CD**, não o conceito de DevOps. * **e) Incorreta** ❌ DevOps **não é uma metodologia ágil**, embora se relacione e complemente práticas ágeis. --- 🎯 **Conclusão** A definição que melhor representa **DevOps** é: 👉 **D** ✅

Answer 49

✅ **Gabarito: letra D** **Justificativa (padrão CESPE/Cebraspe):** A alternativa **D** é a **única correta**, pois descreve com precisão o conceito de **TDD (Test Driven Development)** no contexto de **DevOps/DevSecOps**. --- ✅ **d) Correta** > *O TDD (Test Driven Development) eleva o nível dos testes unitários e tem como característica criar a classe de testes antes da classe de produção, de forma que os testes guiem o código a ser implementado.* ✔ No **TDD**: * primeiro escreve-se o **teste** (que falha); * depois escreve-se o **código mínimo** para o teste passar; * em seguida, ocorre a **refatoração**; * os **testes unitários guiam o desenvolvimento** do código. Esse ciclo está totalmente alinhado com práticas modernas de **DevOps e DevSecOps**. --- ❌ Análise das demais alternativas: * **a) Incorreta** ❌ Testes unitários **não devem depender de recursos externos** (banco, rede, arquivos). Dependências externas devem ser **mockadas**. * **b) Incorreta** ❌ Em DevOps/DevSecOps, busca-se detectar bugs **o mais cedo possível** (*shift left*), e não no final do ciclo. * **c) Incorreta** ❌ Testes unitários são **tipicamente testes de caixa branca**, pois conhecem a implementação interna. * **e) Incorreta** ❌ Testes de integração verificam a **integração entre componentes**, mas **não são definidos pelos clientes** (isso é mais associado a testes de aceitação). --- 🎯 **Conclusão** A opção correta é: 👉 **D** ✅

Answer 50

✅ **Gabarito: letra C** **Justificativa (padrão CESPE/Cebraspe):** A alternativa **C** é a **única em que todas as ferramentas estão diretamente associadas a práticas de DevOps e DevSecOps**, cobrindo automação, versionamento, CI/CD, conteinerização, orquestração e monitoramento. --- ✅ **C) Correta — GitHub, Docker, Vagrant, Jenkins, Kubernetes e Nagios** Essas ferramentas se encaixam claramente no ecossistema DevOps/DevSecOps: * **GitHub** → versionamento de código e colaboração * **Docker** → conteinerização de aplicações * **Vagrant** → provisionamento de ambientes reprodutíveis * **Jenkins** → CI/CD (integração e entrega contínuas) * **Kubernetes** → orquestração de containers * **Nagios** → monitoramento de infraestrutura e serviços 📌 Conjunto **coerente, técnico e alinhado** ao ciclo DevOps de ponta a ponta. --- ❌ Análise das demais alternativas: * **A) Incorreta** ❌ Apesar de conter ferramentas DevOps (Terraform, GitLab, Zabbix), inclui **Teams**, que é ferramenta de comunicação corporativa, **não DevOps**. * **B) Incorreta** ❌ Ferramentas majoritariamente de **gestão e comunicação** (Jira, Trello, Confluence, WhatsApp), **não DevOps técnico**. * **D) Incorreta** ❌ Mistura ferramentas DevOps (Ansible, Puppet, Gradle) com: * **Lync** (comunicação), * **Flutter** (framework de desenvolvimento), * **Eclipse** (IDE), que **não são ferramentas DevOps**. --- 🎯 **Conclusão** A única opção em que **todas as ferramentas são efetivamente usadas em DevOps/DevSecOps** é: 👉 **C** ✅

Answer 51

✅ **Gabarito: letra D — Todos os itens estão certos** **Justificativa (padrão CESPE/Cebraspe):** O **DevOps** é entendido como um **conjunto integrado de práticas ao longo de todo o ciclo de vida do software**, e não apenas como automação de deploy ou operações. Os itens apresentados correspondem a **etapas clássicas do ciclo DevOps**, frequentemente representadas pelo *DevOps Infinity Loop*: * **I. Monitoramento (monitor)** ✅ Parte essencial do DevOps, envolvendo: * monitoramento de aplicações, * infraestrutura, * logs, * métricas e feedback contínuo. * **II. Planejamento (plan)** ✅ Inclui: * definição de requisitos, * priorização, * backlog, * alinhamento com o negócio. É uma etapa fundamental do ciclo contínuo. * **III. Codificação (code)** ✅ Relaciona-se diretamente às atividades de: * desenvolvimento, * versionamento de código, * integração contínua (CI). 📌 Em DevOps, **planejar, codificar e monitorar** fazem parte do mesmo fluxo contínuo, integrando **desenvolvimento e operações**. --- 🎯 **Conclusão** Como **todos os itens listados são tarefas do DevOps**, a alternativa correta é: 👉 **D) Todos os itens estão certos.**

Answer 52

❌ **Falsa.** Em **Java**, o operador **`==`** **não compara o conteúdo** de dois objetos `String`. 🔹 O **`==`** verifica se **as duas variáveis apontam para o mesmo objeto na memória** (comparação de referência). 🔹 Para comparar o **conteúdo textual** das `String`, deve-se usar o método **`equals()`**. 📌 Exemplo correto: ```java String a = new String("Java"); String b = new String("Java"); a == b // false (referências diferentes) a.equals(b) // true (conteúdo igual) ``` ✔ Portanto, para comparar o conteúdo de `String`, **use sempre `equals()`**, e não `==`.

Answer 53

❌ **Falsa.** Em **Java**, um bloco `try` **pode ter múltiplos blocos `catch`**, mas **o bloco `finally` não é obrigatório**. 🔹 As formas válidas incluem: * `try` + `catch` * `try` + `finally` * `try` + múltiplos `catch` * `try` + múltiplos `catch` + `finally` 🔹 O **`finally`** é usado para código que deve ser executado **independentemente de ocorrer exceção**, mas sua presença é **opcional**. 📌 Portanto, a afirmação está incorreta ao dizer que o `finally` é obrigatório.

Answer 54

✅ **Verdadeira.** Em **Java**, uma **classe pode implementar várias interfaces** simultaneamente. 🔹 Isso permite que a classe herde **múltiplos comportamentos**, já que Java **não permite herança múltipla de classes**, mas **permite múltiplas interfaces**. 📌 Exemplo: ```java class MinhaClasse implements InterfaceA, InterfaceB { // implementação dos métodos } ``` ✔ Portanto, a afirmação está correta.

Answer 55

✅ **Verdadeira.** O **operador ternário** em **Java** (também chamado de **operador condicional**) serve exatamente para **simplificar estruturas `if-else` simples**. 🔹 Ele avalia uma **expressão booleana** e retorna **um de dois valores possíveis**, conforme o resultado da condição. 📌 Sintaxe: ```java condicao ? valorSeVerdadeiro : valorSeFalso; ``` ✔ Portanto, a afirmação está correta.

Answer 56

❌ **Falsa.** Em **Java**, variáveis declaradas **dentro de um bloco `try`** possuem **escopo limitado** a esse bloco (e, em alguns casos, aos blocos `catch` e `finally` associados, dependendo da declaração). 🔹 Em regra geral: * uma variável declarada **dentro do `try`** **não é acessível fora** da estrutura `try-catch-finally`. 📌 Exemplo: ```java try { int x = 10; } // x não é visível aqui ``` ✔ Portanto, a afirmação está incorreta.

Answer 57

✅ **Verdadeira.** Desde o **Java 8**, **interfaces podem conter métodos com implementação**: 🔹 **Métodos padrão (*default*)**: * possuem corpo; * permitem adicionar novos métodos a interfaces **sem quebrar** classes que já as implementam. 🔹 **Métodos estáticos**: * também podem ter corpo; * pertencem à **interface**, não às classes que a implementam. 📌 Exemplo: ```java interface Exemplo { default void metodoPadrao() { System.out.println("Método default"); } static void metodoEstatico() { System.out.println("Método estático"); } } ``` ✔ Portanto, a afirmação está correta.

Answer 58

❌ **Falsa.** Quando uma **classe é declarada como `final` em Java**, ela **não pode ser estendida** por nenhuma outra classe. 🔹 Se a classe **não pode ter subclasses**, então **não existe possibilidade de sobrescrita de métodos**, pois **não há subclasses** para fazer isso. 🔹 A sobrescrita de métodos só ocorre quando uma classe **herda** de outra — o que é proibido no caso de classes `final`. 📌 Portanto, a afirmação está incorreta ao dizer que os métodos podem ser sobrescritos por subclasses.

Answer 59

❌ **Falsa.** Um método **`synchronized`** em Java **não garante exclusão mútua em todas as instâncias da classe** — isso depende do **tipo de sincronização**. 🔹 **Método `synchronized` de instância**: * o bloqueio é feito no **objeto (`this`)**; * **uma thread por vez por instância**, **não por classe**; * duas threads podem executar o mesmo método simultaneamente **em instâncias diferentes**. 🔹 **Método `static synchronized`**: * o bloqueio é feito no **objeto `Class`**; * nesse caso, **apenas uma thread por vez em toda a classe**, independentemente da instância. 📌 A afirmação erra ao generalizar que isso vale para **qualquer instância**. Isso só é verdadeiro para **métodos `static synchronized`**, não para métodos de instância.

Answer 60

❌ **Falsa.** Em **Java**, a chamada **`System.gc()` não é garantida** como uma execução imediata do **Garbage Collector**. 🔹 Ela funciona apenas como uma **sugestão (hint)** para a JVM, indicando que seria um bom momento para executar a coleta de lixo. 🔹 A **JVM decide** se, quando e como o Garbage Collector será executado, com base em suas próprias heurísticas. 📌 Portanto, a afirmação está incorreta ao dizer que `System.gc()` é uma chamada **direta e garantida**.

Answer 61

✅ **Verdadeira.** Em **Java**, é **possível sobrecarregar o método `main`**, ou seja, definir **múltiplos métodos `main`** com assinaturas diferentes na mesma classe. 🔹 Exemplo válido: ```java public class Exemplo { public static void main(String[] args) { main(10); } public static void main(int x) { System.out.println("Main sobrecarregado: " + x); } } ``` 🔹 **Importante**: * A JVM **só reconhece como ponto de entrada** o método: ```java public static void main(String[] args) ``` * Os outros `main` sobrecarregados **não são chamados automaticamente**, apenas se forem invocados explicitamente no código. 📌 Portanto, a sobrecarga do método `main` é permitida, embora **apenas uma assinatura seja usada para iniciar o programa**.

Answer 62

✅ **Verdadeira.** O **Jenkins** é amplamente conhecido como uma ferramenta de **Integração Contínua (CI)** e também **suporta Entrega Contínua (CD)**. 🔹 Com o uso de **pipelines** (especialmente o **Jenkins Pipeline**, definido em *Jenkinsfile*), é possível: * automatizar **build**, **testes** e **deploy**; * implementar fluxos completos de **CI/CD**; * integrar com diversas ferramentas (Git, Docker, Kubernetes, etc.). 📌 Portanto, a afirmação está correta: o Jenkins vai além de CI e é amplamente usado em **pipelines de entrega contínua**.

Answer 63

❌ **Falsa.** O conceito de **Shift Left** no **DevSecOps** significa exatamente o **oposto** do que a afirmação descreve. 🔹 **Shift Left** implica em **antecipar** as práticas de **segurança** para as **primeiras etapas** do ciclo de desenvolvimento, como: * levantamento de requisitos, * design, * codificação, * integração contínua. 🔹 A ideia é **detectar e corrigir vulnerabilidades o mais cedo possível**, reduzindo custos, retrabalho e riscos em produção. 📌 Portanto, a afirmação está incorreta ao dizer que o Shift Left introduz segurança **nas últimas etapas** do ciclo de desenvolvimento.

Answer 64

❌ **Falsa.** O **Jenkins** é uma ferramenta de **automação e CI/CD**, **não** uma solução especializada em **orquestração de contêineres**. 🔹 O Jenkins pode: * **construir imagens Docker**, * **executar testes** em contêineres, * **acionar deploys** em ambientes conteinerizados. 🔹 Porém, a **orquestração**, o **escalonamento** e o **gerenciamento de contêineres em produção** são funções de ferramentas como: * **Kubernetes**, * Docker Swarm, * OpenShift. 📌 Portanto, a afirmação está incorreta ao atribuir ao Jenkins o papel de orquestrador de contêineres.

Answer 65

❌ **Falsa.** O **Test-Driven Development (TDD)** segue exatamente o **fluxo oposto** ao descrito. 🔹 No TDD, o ciclo clássico é: 1. **Escrever o teste primeiro** (que inicialmente falha), 2. **Escrever o código mínimo** para fazer o teste passar, 3. **Refatorar** o código mantendo os testes verdes. 🔹 O objetivo é **guiar o desenvolvimento pelo teste**, melhorar o **design**, aumentar a **qualidade** e reduzir defeitos. 📌 Portanto, a afirmação está incorreta ao dizer que os testes são escritos **após** o código de produção estar completo.

Answer 66

❌ **Falsa.** O **GitLab CI/CD** **não é apenas uma ferramenta de controle de versão**. 🔹 Embora o **GitLab** inclua **controle de versão Git**, ele também oferece **CI/CD nativo**, permitindo: * automação de **build**, **testes** e **deploy**; * definição de pipelines por meio do arquivo **`.gitlab-ci.yml`**; * implementação completa de **Integração Contínua e Entrega/Implantação Contínua**. 📌 Portanto, a afirmação está incorreta: o GitLab vai muito além do versionamento e é uma **plataforma completa de DevOps com CI/CD integrado**.

Answer 67

✅ **Verdadeira.** A **Infraestrutura como Código (IaC)** **pode ser aplicada em praticamente qualquer ambiente**, incluindo: 🔹 **Nuvem pública** (AWS, Azure, GCP), 🔹 **Nuvem privada**, 🔹 **Data centers on-premises**. Ferramentas de IaC como **Terraform**, **Ansible**, **CloudFormation** e **Pulumi** permitem **provisionar, configurar e gerenciar infraestrutura de forma automatizada**, reproduzível e versionada, independentemente do local onde os recursos estão hospedados. 📌 Portanto, a afirmação está correta.

Answer 68

✅ **Verdadeira.** O **Kubernetes** é exatamente uma plataforma voltada para a **orquestração de contêineres** em ambientes distribuídos. 🔹 Ele automatiza: * **implantação (deploy)** de aplicações, * **escalonamento** automático, * **gerenciamento do ciclo de vida** dos contêineres, * **auto-recuperação** (*self-healing*), * balanceamento de carga. 📌 Portanto, a afirmação descreve corretamente as funcionalidades e o propósito do Kubernetes.

Answer 69

❌ **Falsa.** **Terraform** e **Ansible** **não são ferramentas de orquestração de contêineres** como o **Kubernetes**. 🔹 **Terraform**: * é uma ferramenta de **Infraestrutura como Código (IaC)**; * usada para **provisionar recursos** (VMs, redes, clusters, serviços de nuvem). 🔹 **Ansible**: * é uma ferramenta de **automação e gerenciamento de configuração**; * usada para **configurar servidores, instalar software e automatizar tarefas**. 🔹 **Kubernetes**: * é especializado em **orquestração de contêineres** (deploy, escalonamento, self-healing). 📌 Portanto, a afirmação está incorreta ao equiparar Terraform e Ansible ao Kubernetes.

Answer 70

❌ **Falsa.** No **DevSecOps**, o conceito de **Shift Left** significa **antecipar** as práticas de **segurança** para as **etapas iniciais** do ciclo de desenvolvimento, **não para o final**. 🔹 Isso inclui incorporar segurança já em: * requisitos, * design, * codificação, * pipelines de CI. 🔹 O objetivo é **detectar vulnerabilidades mais cedo**, reduzir custos e aumentar a qualidade do software. 📌 Portanto, a afirmação está incorreta.

Answer 71

❌ **Falsa.** O **Kubernetes** **não é uma ferramenta de configuração e provisionamento de servidores**, como o **Ansible**. 🔹 **Kubernetes**: * é uma plataforma de **orquestração de contêineres**; * gerencia **deploy**, **escalonamento**, **auto-recuperação** e **balanceamento de carga** de aplicações conteinerizadas. 🔹 **Ansible**: * é voltado para **automação de TI e gerenciamento de configuração**; * usado para **provisionar e configurar servidores e serviços**. 📌 Portanto, a afirmação está incorreta ao comparar Kubernetes a uma ferramenta como o Ansible.

Java + Devops (TCU) Flashcards

(95 cards)