![\"Resultado](\"https:\/\/dhg1h5j42swfq.cloudfront.net\/2016\/08\/30132807\/concurso-tre-sp.jpg\")
\n<\/p>\n\n\t\n<\/p>\n
\n\t \n<\/p>\n
\n\tTRE-SP, provas e gabaritos no ar! Vamos aos comentários de desenvolvimento? Galerinha, fiquem à vontade para indicar outras questões e possíveis divergências ou erros (a essa altura da madruga, é bem possível que escape algo :)).\n<\/p>\n
\n\tA prova de técnico caiu bastante coisa de desenvolvimento! Como tinha dito pra vocês no aulão, muita coisa de Java. Vamos às questões!\n<\/p>\n
\n\t34. Considere a lógica do algoritmo, abaixo, expressa em pseudocódigo.\n<\/p>\n
\n\tVar
\n\ttipo V = vetor [0..4] inteiro
\n\tvar j, voto: inteiro
\n\tvotos: V
\n\tInício
\n\tpara (j <- 0 até 4 passo 1) faça
\n\tvotos[j] <- 0
\n\tfim para\n<\/p>\n
\n\tenquanto (verdadeiro)
\n\timprima ("Digite o voto (1,2,3 ou 0 (branco) -1 finaliza): ")
\n\tleia (voto)
\n\tse (voto = -1)
\n\tentão vá para RESULT
\n\tfim se
\n\tse (voto 3)
\n\tentão votos[4] <- votos[4] + 1
\n\tsenão votos[voto] <- votos[voto] + 1
\n\tfim se
\n\tfim enquanto\n<\/p>\n
\n\tRESULT:
\n\tpara (j <- 1 até 3 passo 1) faça
\n\timprima ("O candidato ", j," obteve ", votos[j], " votos")
\n\tfim para\n<\/p>\n
\n\timprima ("Número de votos em branco= ", ..I..)
\n\timprima ("..II..", votos[4])
\n\tFim\n<\/p>\n
\n\tDe acordo com a lógica apresentada,
\n\t(A) logo após RESULT:, a instrução para deveria se iniciar em 0 e ir até 4.
\n\t(B) a instrução se (voto 3) deveria utilizar o operador lógico E ao invés do OU.
\n\t(C) a lacuna I deve ser preenchida com votos[1]
\n\t(D) a lacuna II deve ser preenchida com Número de votos nulos =
\n\t(E) para saber o número total de eleitores basta percorrer o vetor e somar todas as posições de 1 a 3.\n<\/p>\n
\n\tA – Não, pois na verdade esse "para" é justamente para imprimir os votos várlidos, ou seja, os candidatos de 1 a 3. Item incorreto.
\n\tB – Como algo vai ser menor que zero e maior que 3 ao mesmo tempo? Viajandão! Item incorreto.
\n\tC – Votos em branco são aqueles com valor 0 e também estão sendo contabilizados na posição 0 do vetor (isso está na instrução votos[voto] <- votos[voto] + 1). Ou seja, votos[1] não contabilizam os votos em branco, mas sim os do candidato de número 1. Item incorreto
\n\tD – Boa! A 5a posição do vetos, ou seja, votos[4] está armazenando os valores inválidos de voto, ou seja, os valores nulos. Item correto.
\n\tE – Não! E os votos em branco? E os votos nulos? Deve-se somar de 0 a 4 para ter a quantidade de eleitores. Item incorreto.\n<\/p>\n
\n\tGABARITO D\n<\/p>\n
\n\t35. Considere as duas funções, abaixo, escritas em pseudocódigo, que implementam uma lógica.\n<\/p>\n
\n\tfunção f1 (N: inteiro): real
\n\tInício
\n\tse (N<=1)
\n\tentão retorna 1
\n\tsenão retorna (N * f1 (N – 1))
\n\tfim se\n<\/p>\n
\n\tFim\n<\/p>\n
\n\tfunção f2 (N: inteiro): real
\n\tVar i: inteiro
\n\tresult: real
\n\tInício
\n\tresult <- 1
\n\tpara (i <- 2 até N passo 1) faça
\n\tresult <- result * i
\n\tfim para
\n\tretorna result
\n\tFim\n<\/p>\n
\n\tA função
\n\t(A) iterativa e a função recursiva retornam 1 para valores de N=0 e N=1.
\n\t(B) f1 e a função f2 recebem uma variável real e retornam um valor inteiro.
\n\t(C) f1 é executada apenas uma vez, já que em seu corpo existe apenas um comando condicional.
\n\t(D) f2 é executada N-2 vezes.
\n\t(E) recursiva faz cálculos e apresenta resultados totalmente diferentes da função iterativa.\n<\/p>\n
\n\tA – Certo de primeira, que sem graça. Tanto f1 quanto f2 retornam valor 1 nos casos de n = 0 ou n = 1
\n\tB – Recebem inteiro e retornam real. Item incorreto.
\n\tC – Meio tosco esse item. Tinha que dar um exemplo de chamada da função, pois dependendo do parâmetro somente chamaria f1 uma vez (n = 0, por exemplo). Mas, de qualquer forma, a quantidade de vezes em que uma função é chamada não tem nada a ver com a quantidade de estruturas de decisão (condicional). Item incorreto.
\n\tD – Mais um item tosco. Onde estão as chamadas à função f2? De qualquer forma, a função pode ser chamada quantas vezes o código principal (que não está presente na questão) quiser. Item incorreto.
\n\tE – As funções são equivalentes, sendo uma recursiva e outra iterativa. Item incorreto.\n<\/p>\n
\n\tGABARITO A\n<\/p>\n
\n\t36. Considere, hipoteticamente, que um Técnico do TRE-SP tem, em seu computador, a seguinte organização de um diretório:
\n\tPrincipal: Dados
\n\tDentro de Dados: Técnicos Práticos
\n\tDentro de Técnicos: Árvores Hash Recursão Filas Pilhas
\n\tDentro de Práticos: Programas AFazer Prontos
\n\tDentro de Prontos: Eleições Urnas
\n\tDentro de Programas: Corretos ComErro
\n\tDentro de ComErro: Urgentes Pendentes Antigos
\n\tA estrutura de dados
\n\t(A) hashing, ao armazenar este diretório, não terá colisões na tabela de dispersão.
\n\t(B) fila é a mais adequada para representar este diretório.
\n\t(C) pilha é a mais adequada para representar este diretório.
\n\t(D) árvore binária, ao armazenar este diretório, terá Dados na raiz e nós com grau 2, 3, 5 e folhas.
\n\t(E) árvore, que consegue armazenar este diretório, é de ordem 5.\n<\/p>\n
\n\tA – Qual a função de hashing?? Só sabemos se tem ou não colisão com a função e, a partir daí, se os resultados colidem ou não. Item incorreto
\n\tB – Estrutura linear para armazenar algo hierárquico não é o mais adequado. É possível, mas não mais adequado. Item incorreto.
\n\tC – Vide B. Item incorreto.
\n\tD – Árvore binária com grau 5? Hello??? Item incorreto.
\n\tE – Massa! Vejam na árvore que montei (não ficou linda??), temos que a ordem é 5. Item correto.\n<\/p>\n
\n\t![\"\"](\"https:\/\/dhg1h5j42swfq.cloudfront.net\/2017\/02\/15030938\/questao36.png\")
\n<\/p>\n
\n\t \n<\/p>\n
\n\tGABARITO E\n<\/p>\n
\n\t38. Considere o trecho de código Java, abaixo, que implementa um método de ordenação de vetores.\n<\/p>\n
\n\tpublic class Ordena {
\n\tpublic static void main(String[] args) {
\n\tint[] vet = {8, 19, 31, 25, 1};
\n\tint aux = 0, i = 0;
\n\tfor (i = 0; i < 5; i++) {
\n\tfor (int j = 0; j vet[j + 1]) {
\n\taux = vet[j];
\n\tvet[j] = vet[j + 1];
\n\tvet[j + 1] = aux;
\n\t}
\n\t}
\n\t}\n<\/p>\n
\n\tfor (i = 0; i < 5; i++) {
\n\tSystem.out.println(" " + vet[i]);
\n\t}
\n\t}
\n\t}\n<\/p>\n
\n\tConsidere que n se refere à quantidade de valores a serem ordenados. O método de ordenação implementado, com os devidos ajustes, é adequado para ser utilizado por um Técnico do TRE-SP para ordenar um conjunto formado por
\n\t(A) 1 milhão de valores numéricos em ordem aleatória, pois neste caso o método é O (n).
\n\t(B) 1 milhão de valores numéricos em ordem decrescente, por ser este o melhor caso do método.
\n\t(C) quantidades pequenas de dados, por se tratar de um método O (n2) e que realiza muitas trocas.
\n\t(D) qualquer quantidade de valores numéricos em ordem aleatória, por ser este o melhor caso do método.
\n\t(E) grandes quantidades de dados, por se tratar de um método O (log2n), portanto, muito eficiente.\n<\/p>\n
\n\tA – Galera, temos um for aninhado, ou seja, vai executar na ordem de O(n * n) = O(n^2). Item incorreto.
\n\tB – Na verdade o método sempre realiza as comparações, mesmo que não haja trocas. Normalmente é o que contamos para saber a complexidade do algoritmo. Desse modo, não há melhor caso ou pior caso, pois o número de comparações é sempre o mesmo. Item incorreto.
\n\tC – Legal, item correto. Esse método é O(n^2) por ter dois for aninhados, ou seja, vai executar n * (n-1) vezes. Assintoticamente esse método é, portanto, O(n * n) = O(n^2). Item correto.
\n\tD – Qualquer quantidade num algoritmo O(n^2) vai levar um bom tempo. Existem outros algoritmos melhores para ordenação de grandes quantidades de valores. Item incorreto.
\n\tE – Como vimos, o método é O(n^2) e não O(log2n). Item incorreto\n<\/p>\n
\n\tGABARITO C\n<\/p>\n
\n\t39. Considere que a eleição para prefeito de um município paulista produziu o seguinte resultado:
\n\tCandidatoA-1504 votos, CandidatoB-7520 votos, CandidatoC-345551 votos, CandidatoD-517440 votos, CandidatoE-2329 votos,
\n\tCandidatoF-11731 votos e CandidatoG-152 votos.
\n\tAo armazenar estes dados em uma árvore
\n\t(A) binária de busca, tendo como chave de inserção a quantidade de votos nesta ordem, o candidato vencedor será localizado
\n\tcom 3 comparações.
\n\t(B) binária de busca, tendo como chave de inserção os nomes dos candidatos nesta ordem, resultará em uma árvore de altura
\n\tmínima.
\n\t(C) binária de busca, tendo como chave de inserção a quantidade de votos nesta ordem, o candidato vencedor ficará na raiz.
\n\t(D) binária de busca perfeitamente balanceada, tendo como chave de inserção o nome do candidato, o candidato vencedor
\n\tficará na raiz.
\n\t(E) perfeitamente balanceada, resultará em uma árvore de altura 4.\n<\/p>\n
\n\tA – Construindo a árvore de busca binária, com o número de votos como chave, e inserindo na ordem de A a G, teremos a estrutura abaixo:\n<\/p>\n
\n\t![\"\"](\"https:\/\/dhg1h5j42swfq.cloudfront.net\/2017\/02\/15031033\/questao39.png\")
\n<\/p>\n
\n\tOu seja, para encontrarmos o ganhador, teríamos que realizar mais de 3 comparações. Item incorreto\n<\/p>\n
\n\tB – Utilizando como chave os nomes, temos que (por ordem alfabética) CandidatoA < CandidatoB < Candidato C <…. Desse modo, teríamos uma árvore de busca binária sempre com elementos à direita (o sucessor sempre maior que o antecessor), ou seja, a árvore na verdade teria tamanho máximo! Item incorreto.
\n\tC – Como vimos, o ganhador, na verdade, será uma folha. Item incorreta.
\n\tD – Uma árvore perfeitamente balanceada tem o elemento central como raiz. No nosso caso temos 7 elementos, ou seja, nosso elemento central é o 4o, o CandidatoD, ganhador da eleição. Item correto.
\n\tE – Utilizando qualquer uma das chaves, quantidade de votos, ou nome do candidato, a árvore totalmente balanceada tem altura menor que 4. Item incorreto.\n<\/p>\n
\n\t![\"\"](\"https:\/\/dhg1h5j42swfq.cloudfront.net\/2017\/02\/15031106\/questao39_itemE.png\")
\n<\/p>\n
\n\t \n<\/p>\n
\n\tGABARITO D\n<\/p>\n
\n\t40. Considere o trecho de código em Java, abaixo.\n<\/p>\n
\n\tclass Gerente extends Funcionario {
\n\tint senha;
\n\tpublic boolean autentica(int senha) {
\n\tif (this.senha == senha) {
\n\tSystem.out.println("Acesso Permitido!");
\n\treturn true;
\n\t} else {
\n\tSystem.out.println("Acesso Negado!");
\n\treturn false;
\n\t}
\n\t}
\n\t\/\/ setter da senha omitido
\n\t}\n<\/p>\n
\n\tObservando-se os conceitos de orientação a objetos, expostos no trecho em Java,
\n\t(A) todo Funcionario é um Gerente, ou seja, Gerente é classe mãe de Funcionario e Funcionario é classe filha
\n\tde Gerente.
\n\t(B) a classe Gerente herda todos os atributos e métodos da classe Funcionario. Isso é expresso pelo uso da palavra
\n\tchave extends.
\n\t(C) sempre que um objeto do tipo Funcionario for criado, este objeto possuirá também os atributos definidos na classe
\n\tGerente, pois um Funcionario é um Gerente.
\n\t(D) a classe Funcionario também herda os atributos e métodos privados de Gerente, porém não consegue acessá-los
\n\tdiretamente.
\n\t(E) Gerente é a superclasse de Funcionario e Funcionario é a subclasse de Gerente.\n<\/p>\n
\n\tA – Não é verdade. Funcionario é a superclasse e Gerente a subclasse. Dessa forma, todo Gerente é um Funcionario, mas o contrário não é verdadeiro, pois podem existir outras subclasses de Funcionario. Item incorreto
\n\tB – Gerente é subclasse de Funcionario. Em Java a palavra-chave que determina essa hierarquia é extends. Item correto.
\n\tC – Como vimos, é o oposto, ou seja, o Gerente terá todos os atributos de Funcionario, mas não o contrário. Item incorreto
\n\tD – A especificação Java é clara:\n<\/p>\n
\n\tMembers of a class that are declared private are not inherited by subclasses of that class. Only members of a class that are declared protected or public are inherited by subclasses declared in a package other than the one in which the class is declared.\n<\/p>\n
\n\tOu seja, a subclasse não herda os membros privados. Item incorreto. OPA, OPA, professor!! Mas o item B fala que a subclasse herda TODOS os atributos e métodos. Padawan, eu entraria com recurso, fácil fácil :)\n<\/p>\n
\n\tE – É o contrário, na verdade. Item incorreto.\n<\/p>\n
\n\tGABARITO B\n<\/p>\n
\n\t47. Considere o programa Java, abaixo.
\n\tpublic class Arquivo {
\n\tpublic static void main(String[] args) {
\n\tint mat[][] = {{ 1, 2, -1, 2, 3}, { 1, -3, 4, 2, 0}, { -3, 5, 2, 3, 4}};
\n\tint sl[] = {0, 0, 0};
\n\tint x;
\n\tx=0;
\n\tfor (int i=0;i<3;i++){
\n\tfor (int j=0;j<5;j++){
\n\tsl[i]=sl[i] + mat[i][j];
\n\t}
\n\tx=x+sl[i];
\n\t}
\n\tSystem.out.print(x);
\n\t}
\n\t}\n<\/p>\n
\n\tAo compilar e executar o programa será exibido o valor
\n\t(A) 22.
\n\t(B) 7.
\n\t(C) 4.
\n\t(D) 11.
\n\t(E) 30.\n<\/p>\n
\n\tQuestãozinha chatinha, fácil, mas trabalhosa na hora da prova porque temos que seguir iteração por iteração. E ainda colocam for aninhado, mas vamos nessa!\n<\/p>\n
\n\ti = 0, j = 0, sl[i] = 1
\n\ti = 0, j = 1, sl[i] = 3
\n\ti = 0, j = 2, sl[i] = 2
\n\ti = 0, j = 3, sl[i] = 4
\n\ti = 0, j = 4, sl[i] = 7\n<\/p>\n
\n\tx = 0 + 7 = 7\n<\/p>\n
\n\ti = 1, j = 0, sl[i] = 1
\n\ti = 1, j = 1, sl[i] = -2
\n\ti = 1, j = 2, sl[i] = 2
\n\ti = 1, j = 3, sl[i] = 4
\n\ti = 1, j = 4, sl[i] = 4\n<\/p>\n
\n\tx = 7 + 4 = 11\n<\/p>\n
\n\ti = 2, j = 0, sl[i] = -3
\n\ti = 2, j = 1, sl[i] = 2
\n\ti = 2, j = 2, sl[i] = 4
\n\ti = 2, j = 3, sl[i] = 7
\n\ti = 2, j = 4, sl[i] = 11\n<\/p>\n
\n\tx = 11 + 11 = 22\n<\/p>\n
\n\tGABARITO A\n<\/p>\n
\n\t48. Considere o programa Python, abaixo.
\n\timport ..I.. as b
\n\timport matplotlib.pyplot as a
\n\tx = b.linspace(0, 3, 20)
\n\ty = b.linspace(0, 9, 20)
\n\ta.plot(x, y)
\n\ta.plot(x, y, 'o')
\n\ta.show()
\n\tA lacuna I deve ser preenchida corretamente com
\n\t(A) array.
\n\t(B) numpy.
\n\t(C) matrix.
\n\t(D) mathlab.
\n\t(E) numberplot.\n<\/p>\n
\n\tGalera, questão muito específica de Python, bem chata de acertar para quem não tem experiência. A biblioteca numpy é utilizara para cálculos científicos, a galera de mineração de dados gosta muito por ela conter muitas funções úteis para estatística e matemática. A função linspace cria um conjunto de números igualmente espaçados. b.linspace(0, 3, 20) retorna 20 números entre 0 e 3, e b.linspace(0, 9, 20) retorna 20 números entre 0 e 9. Essa função é útil para criar gráficos, como é o caso da questão.\n<\/p>\n
\n\tGABARITO B\n<\/p>\n
\n\t49. Considere o tipo de collection Java, abaixo.\n<\/p>\n
\n\tSet c = new HashSet();
\n\tc.add("TRE");
\n\tc.add("TRT");
\n\tc.add("TRF");\n<\/p>\n
\n\tPara percorrer e exibir cada elemento contido em c utiliza-se
\n\t(A) for (int i=0;i<=c.size();i++) {System.out.println(c.get(i));}
\n\t(B) while(c.hasNext()) {System.out.println(c.get());}
\n\t(C) while (Iterator.hasNext()){String p = i.next(); System.out.println(p);}
\n\t(D) for (String p : c) {System.out.println(p);}
\n\t(E) Iterator i = c.iterator(); while (i.next()){String p = i.hasNext(); System.out.println(p);}\n<\/p>\n
\n\tA – Set não possui método get! Item incorreto
\n\tB – Vida A :)
\n\tC – Maluquice! Chamando hasNext() como método estático de Iterator, que é uma interface, tá doidão! Item errado.
\n\tD – Ah, o nosso querido for each. Item correto, iterando sobre o Set c, onde cada elemento será atribuído a p.
\n\tE – Estava indo bem, tem como iterar sobre os valores de conjunto chamando seu método iterator(). O problema está na atribuição String p = i.hasNext(), pois esse método retorna um booleano (tem ou não tem mais elementos?), e não o valor contido no conjunto.\n<\/p>\n
\n\tGABARITO D\n<\/p>\n
\n\t50. Um programador criou uma aplicação Java em camadas, utilizando o NetBeans 8.1 em português. Ao concluir a aplicação, foi
\n\tsolicitado a gerar a documentação a partir dos códigos-fonte, expressando o resultado em formato HTML. Para isso, ele
\n\t(A) clicou no menu Executar e na opção Gerar Javadoc.
\n\t(B) usou uma ferramenta JDocument, pois o NetBeans não possui recursos para gerar a documentação no formato solicitado.
\n\t(C) clicou no menu Ferramentas, em Opções, selecionou a guia Documentação, selecionou a opção Javadoc e clicou no
\n\tbotão Gerar.
\n\t(D) compilou a aplicação através da opção Executar e Documentar do menu Executar.
\n\t(E) abriu o projeto no Eclipse e gerou a documentação pelo Javadoc, pois este recurso não vem integrado ao NetBeans.\n<\/p>\n
\n\tMuito bem, FCC! Pleno 2017 e vocês cobrando decoreda de ferramenta específica. Não sabem medir conhecimento, impressionante. Decoreba, galera, não fiquem tristes de perder uma questão dessas.\n<\/p>\n
\n\tGABARITO A\n<\/p>\n
\n\t50. Considere a imagem abaixo, que mostra o ciclo de vida de um objeto na JPA.\n<\/p>\n
\n\tQuando se cria um objeto pela primeira vez e ele ainda não passou pela JPA, o objeto está no estado new (novo). Para que ele
\n\tse torne um objeto persistente, é necessário passá-lo para o estado managed (gerenciado) e para isso é necessário chamar o
\n\tmétodo
\n\t(A) persist da interface EntityTransaction.
\n\t(B) persist da interface EntityManager.
\n\t(C) save da interface EntityTransaction.
\n\t(D) managed da interface EntityManager.
\n\t(E) save da interface EntityManager.\n<\/p>\n
\n\tGalera, a classe EntityManager gerencia o ciclo de vida dos objetos persistentes do JPA. Para tornar um objeto como persisted, o médoto persist deve ser invocado.\n<\/p>\n
\n\tGABARITO B\n<\/p>\n
\n\t52. Considere que em uma servlet de uma aplicação Java EE existem as linhas abaixo:\n<\/p>\n
\n\tArrayList lista = dao.consultar(nome);
\n\trequest.setAttribute("lista_req", lista);
\n\tRequestDispatcher disp = request.getRequestDispatcher("dadosTRE.jsp");
\n\tdisp.forward(request, response);\n<\/p>\n
\n\tNa página dadosTRE.jsp, para receber a variável de requisição definida pelo método setAttribute utiliza-se a instrução:
\n\t(A) ArrayList lis = (ArrayList) request.getAttribute("lista_req");
\n\t(B) ArrayList lista = request.getParameter("lista");
\n\t(C) ArrayList lis = request.getAttribute("lista_req");
\n\t(D) ArrayList lista = (ArrayList) request.getParameter("lista_req");
\n\t(E) ArrayList lista = (ArrayList) request.getAttribute("lista");\n<\/p>\n
\n\tA – Certinho. Se a variável foi incluída como atributo, o método correto é getAttribute passando o nome lista_req como parâmetro. Como esse método retorna um Object, o cast explícito é obrigatório. Item correto.
\n\tB – O método não é o getParameter, e o nome da variável incluída no request é lista_req. Item incorreto.
\n\tC – Quaaase certo, faltou o cast. Item incorreto.
\n\tD – Vide B. Item incorreto.
\n\tE – Quaaase certo também, mas o parâmetro de getAttribute deveria ser lista_req. Item incorreto.\n<\/p>\n
\n\tGABARITO A\n<\/p>\n
\n\t53. Considere a classe Java, abaixo.
\n\timport java.awt.*;
\n\timport javax.swing.*;
\n\tpublic class Tela extends ..I..{
\n\tpublic Tela() {
\n\t..II.. ;
\n\tsetSize(500, 300);
\n\tsetLocation(300, 200);
\n\t}
\n\tpublic static void main(String[] args) {
\n\tTela t = new Tela();
\n\tt.setVisible(true);
\n\t}
\n\t}
\n\tA instrução da lacuna I indica herança de componentes de uma classe que adiciona suporte à arquitetura de componentes JFC\/Swing. A instrução da lacuna II define um layout com 3 linhas e duas colunas. As lacunas I e II são, correta e respectivamente, preenchidas com
\n\t(A) JPanel − setLayout(new GridBagLayout(3, 2))
\n\t(B) JPanel − setLayout(new FlowLayout(3, 2))
\n\t(C) JFrame − setLayout(new GridLayout(3, 2))
\n\t(D) JFrame − setLayout(new BorderLayout(3, 2))
\n\t(E) JFrame − setLayout(new GridBagLayout(3, 2))\n<\/p>\n
\n\tQuestão decoreba, infelizmente. Eu sabia de cor porque trabalhei muito com Swing, mas, honestamente, não mede conhecimento. Deu ruim, FCC.\n<\/p>\n
\n\tA – JPanel tem que estar dentro de um contêiner pai, como um JFrame. Item incorreto.
\n\tB – JPanel tem que estar dentro de um contêiner pai, como um JFrame. Item incorreto.
\n\tC – Certinho! JFrame é uma janela que funciona sozinha, e o GridLayout, que funciona como uma matriz, é criado com esses parâmetros (linhas, colunas). Item correto.
\n\tD – BorderLayout possui construtor com com dois parâmetros inteiros, mas não definem número de linhas e colunas. Item incorreto.
\n\tE – GridBagLayout não possui outro construtor que não o vazio (não recebe parâmetros). Item incorreto\n<\/p>\n
\n\tGABARITO C\n<\/p>\n
\n\t54. Considere as linhas abaixo, presentes em um método de uma aplicação Java SE que acessa um banco de dados MySQL.\n<\/p>\n
\n\tClass.forName("com.mysql.jdbc.Driver");
\n\tConnection con=DriverManager.getConnection("jdbc:mysql:\/\/localhost:3307\/b","r", "p");\n<\/p>\n
\n\tAo executar estas linhas podem ocorrer, respectivamente, as seguintes exceções:
\n\t(A) DriverException e SQLException.
\n\t(B) IOException e IllegalArgumentException.
\n\t(C) ClassNotFoundException e SQLException.
\n\t(D) InterruptedException e NullPointerException.
\n\t(E) ClassNotFoundException e DataBaseException.\n<\/p>\n
\n\tO método forName da classe Class pode lançar a exceção ClassNotFoundException. O método getConnection da classe java.sql.DriverManager pode lançar a exceção SQLException\n<\/p>\n
\n\t55. Considere a imagem de um servidor de aplicação Java EE abaixo.
\n\tAs lacunas I, II e III são, correta e respectivamente, preenchidas com
\n\t(A) servlets − páginas JSP − classes de acesso a dados.
\n\t(B) páginas JSP e HTML − classes de entidade − beans de entidade.
\n\t(C) páginas HTML − classes de acesso a dados − beans de sessão.
\n\t(D) servlets − classes de entidade − classes de acesso a dados.
\n\t(E) páginas JSP − beans de sessão − classes de entidade.\n<\/p>\n
\n\tA – paginas JSP são tratadas por web container. Item incorreto.
\n\tB – classes de entidade são tratadas pelo persistence provider. Item incorreto
\n\tC – beans de sessão são tratados pelo EJB Container. Intem incorreto.
\n\tD – Vide B. Item incorreto.
\n\tE – Opa, certinho. JSP e Servlets são tratados pelo Web Container. Session Beans pelo EJB Container e entidades pelo Persistence Provider. Item correto.\n<\/p>\n
\n\t \n<\/p>\n
\n\tIsso aí, galera! Espero que tenham ido bem. Hora de fazer os recursos! Abraços!<\/p>\n","protected":false},"excerpt":{"rendered":"
TRE-SP, provas e gabaritos no ar! Vamos aos comentários de desenvolvimento? Galerinha, fiquem à vontade para indicar outras questões e possíveis divergências ou erros (a essa altura da madruga, é bem possível que escape algo :)). A prova de técnico caiu bastante coisa de desenvolvimento! Como tinha dito pra vocês no aulão, muita coisa de […]<\/p>\n","protected":false},"author":383,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"post_tipo":"article","footnotes":""},"categories":[1],"tags":[],"tax_estado":[],"class_list":["post-64929","post","type-post","status-publish","format-standard","hentry","category-cursos-e-concursos"],"acf":[],"yoast_head":"\n