Questões de Concurso Público DPE-SP 2013 para Agente de Defensoria - Programador
Foram encontradas 15 questões
I. Em muitas linguagens de programação, os programadores são responsáveis por alocar e liberar memória e por manipular o tempo de vida do objeto. Em aplicativos do .NET Framework, o CLR fornece esses serviços.
II. Em muitas linguagens de programação tradicionais, os tipos básicos são definidos pelo compilador, o que complica a interoperabilidade entre linguagens. No .NET Framework, os tipos básicos são definidos pelo .NET Framework Type System e são comuns a todas as linguagens que o utilizam.
III. O .NET Framework inclui bibliotecas para áreas específicas de desenvolvimento de aplicativos, como o ASP.NET para aplicativos da web, o ADO.NET para acesso a dados e o Windows Communication Foundation para aplicativos orientados a serviços.
IV. Compiladores de linguagens direcionadas ao .NET Framework geram um código intermediário chamado de Common Intermediate Language (CIL), que, por sua vez, é compilado em tempo de execução pelo CLR. Com esse recurso, as ro- tinas escritas em uma linguagem tornam-se acessíveis a outras linguagens da plataforma .NET.
Está correto o que se afirma em
A especificação definida no texto é conhecida pela sigla
I. var a = new Object(); a.nome="Ana"; a.idade=40;
II. var c = {nome:"Ana", idade:40};
III. var b = new Array(); b[0] = "Ana"; b[1] = 40;
IV. var d = ["Ana",40];
Sobre esses fragmentos de código é correto afirmar que
Baseado nessas informações, analise o fragmento de código a seguir:
<.p>
<.label>
Telefone: <.input type=" ..I.... " .I...I.. ="^\(?\d{2}\)\d{4}[-\s]\d{4}.*?$" placeholder="(XX)XXXX-XXXX" name="telefone">
<./label>
<./p>
Considere que o bloco de código apresentado objetiva permitir a entrada de um tipo telefone no formato indicado pela expressão regular "^\(?\d{2}\)\d{4}[-\s]\d{4}.*?$".
Para isso, as lacunas I e II devem ser preenchidas correta e, respectivamente, com
Analise o código XML a seguir:
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE dados[
<!ELEMENT dados (empregado+)>
<!ELEMENT empregado (nome,telefone*,estado?)>
<!ELEMENT nome (#PCDATA)>
<!ATTLIST nome codigo CDATA #REQUIRED>
<!ATTLIST nome sexo CDATA "Masculino">
<!ELEMENT telefone (#PCDATA)>
<!ATTLIST telefone ramal CDATA #IMPLIED>
<!ELEMENT estado (#PCDATA)>
<!ATTLIST estado cidade CDATA #FIXED "Bauru">
]>
<dados>
<empregado>
<nome codigo="1" sexo="Feminino">Maria Clara</nome>
<telefone>3221-5647</telefone>
<telefone>4567-4589</telefone>
<estado cidade="Votuporanga">São Paulo</estado>
</empregado>
<empregado>
<nome codigo="2">Ana Luiza</nome>
<estado cidade="Bauru">São Paulo</estado>
</empregado>
</dados>
Sobre esse código é correto afirmar que
index.html
< !DOCTYPE html>
<html>
<head>
<title>Teste</title>
</head>
<body>
<form method ="post" action="Controle">
<p>Interesses:< br />
<label><input type="checkbox" value="Livros" name="interesses"/>Livros</label>
<label><input type="checkbox" value="Revistas" name="interesses"/>Revistas</label>
<label><input type="checkbox" value="Teatro" name="interesses"/>Teatro</label>
</p>
<p> <input type="submit" value="Enviar"/></p>
</form>
</body>
</html>
Controle.java
import java.io.*;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.*;
@WebServlet(name = "Controle", urlPatterns = {"/Controle"})
public class Controle extends HttpServlet {
protected void processRequest(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
}
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
processRequest(request, response);
}
@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
processRequest(request, response);
}
}
Com base nessa aplicação e na plataforma Java EE 6 é correto afirmar que
interface IDimensions
{
float Length();
float Width();
}
class Box : IDimensions
{
float lengthInches;
float widthInches;
public Box(float length, float width)
{
lengthInches = length;
widthInches = width;
}
float IDimensions.Length()
{
return lengthInches;
}
float IDimensions.Width()
{
return widthInches;
}
public static void Main()
{
Box myBox = new Box(30.0f, 20.0f);
IDimensions myDimensions = (IDimensions) myBox;
System.Console.WriteLine("Length: {0}", myBox.Length());
System.Console.WriteLine("Width: {0}", myDimensions.Width());
}
}
Sobre o código apresentado é correto afirmar que a instrução
package geral;
public class Diarista extends Empregado{
private int diasTrabalhados;
public Diarista(int diasTrabalhados, int id, String nome, double valorReferencia) {
super(id, nome, valorReferencia);
this.diasTrabalhados = diasTrabalhados;
}
public int getDiasTrabalhados() {
return diasTrabalhados;
}
public void setDiasTrabalhados(int diasTrabalhados) {
this.diasTrabalhados = diasTrabalhados;
}
@Override
public double obterSalario(){
return super.getValorReferencia() * diasTrabalhados;
}
public double obterSalario(double percentualAcrescimo){
double salario= this.obterSalario();
double salarioReajustado = salario + salario * percentualAcrescimo /100;
return salarioReajustado;
}
public double obterSalario(double adicional, double desconto){
return this.obterSalario() + adicional - desconto;
}
}
Analisando o código apresentado é possível concluir que
public class ClasseB {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
System.out.print("Entre com o valor de n:");
int n = in.nextInt();
for (int i = 1; i <= n; i++) {
long f = teste(i);
System.out.println(f);
}
}
public static long teste(int n) {
if (n <= 2) {
return 1;
} else {
return teste(n - 1) + teste(n - 2);
}
}
}
import java.util.Scanner;
public class ClasseA {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
System.out.print("Entre com o valor de n:");
int n = in.nextInt();
for (int i = 1; i <= n; i++) {
long f = teste(i);
System.out.println(f);
}
}
public static long teste(int n) {
if (n <= 2)
return 1;
long a=1;
long b=1;
long c = 1;
for (int i=3; i<=n; i++){
c=a+b;
b=a;
a=c;
}
return c;
}
}
Analisando as duas classes e refletindo sobre o uso de recursão é possível concluir que
public class PrincipalTeste {
public static void main(String[] args) {
int a, b, c, d;
a=2; b=3; c=4; d=10;
System.out.print((a+b)-(-c*d)>(d-a)*(-a+b) && (b*c/a)<(d-c+a/c)?"a":"b");
System.out.print(!((a+b)-(-c*d)>(d-a)*(-a+b) || (b*c/a)<(d-c+a/c))?"c":"d");
System.out.print(((a+b)-(-c*d)>((d-a)*(-a+b)) & !((b*c/a)<(d-c+a/c)))?"e":"f");
System.out.print(((a+b)-(c*d)!=((d-a)*(-a+b)) & !((b*c/a)<(d-c+a/c)))?"g":"h");
}
}
Após compilar e executar o código será impresso na tela os valores
I. A requisição HTTP recebida pelo servidor é encaminhada ao Servlet Contêiner que mapeia esse pedido para uma servlet específica.
II. O Servlet Contêiner invoca o método init da servlet. Esse método é chamado em toda requisição do usuário à servlet não sendo possível passar parâmetros de inicialização.
III. O Servlet Contêiner invoca o método service da servlet para processar a requisição HTTP, passando os objetos request e response. O método service não é chamado a cada requisição, mas apenas uma vez, na primeira requisição do usuário à servlet.
IV. Para descarregar a servlet da memória, o Servlet Contêiner chama o método unload, que faz com que o garbage collector retire a instância da servlet da memória.
Está correto o que se afirma em