Para as aplicações orientadas a evento desenvolvidas em Java, utilizando Swing, são feitas as seguintes afirmativas:

I – um “JTextField” pode disparar um evento do tipo “ActionEvent”;

II – a implementação do tratamento dos eventos para um programa pode ser colocada em sua própria classe, em vez de ser incluída no código que cria a interface, separando o design da interface de seu código de tratamento de eventos;

III – uma classe que estende “JFrame” e implementa a interface “ActionListener” pode tratar eventos de janela por meio de métodos como o “windowOpened”, definido na interface “ActionListener”.

Está(ão) correta(s) a(s) afirmativa(s):

Quantos números naturais, de 4 algarismos (na base 10), menores que 4000 e divisíveis por 5, podem ser formados usando-se apenas os algarismos 1, 2, 3, 4, e 5?

Considere a seguinte classe, incompleta, que está sendo escrita em Java (ainda não foi definido se esta classe será instanciável ou não).

public class TPClass extends TP implements P
{
abstract public float processar (int pr);
public final int conectar (String odbc)
{
return 0; // código sendo implementado
}
}

Para esta classe são feitas as seguintes afirmativas:

I - “P” é uma interface e define os métodos que “TPClass” deve implementar ou declarar como abstratos. “P” pode estender uma classe, mas não pode estender uma interface;

II - se a classe “TP” for abstrata, ela não poderá ser instanciada e “TPClass” deverá implementar todos os métodos de “TP” declarados como abstratos, caso “TPClass” esteja sendo construída para ser uma classe instanciável.

III - o identificador “final” utilizado na definição do método “conectar” indica que as subclasses de “TPClass” não podem anular o método;

IV - como o método “processar” de “TPClass” é abstrato, “TPClass” também deveria ser definida como abstrata. Umas das condições para que “TPClass” seja uma classe instanciável é que seus métodos não sejam abstratos.

Estão corretas as afirmativas:

Considere a seguinte classe escrita em Java.

import java.awt.*;
import java.awt.event.*;
public class FrameEvento extends Frame implements
ActionListener {
Label la = new Label(“”);
Button bu = new Button( “button”);
int count;
public FrameEvento() {
super();
setSize(new Dimension(400, 300));
setLocation(100, 100);
setTitle(“Teste”);
setLayout(new FlowLayout());
addWindowListener(new java.awt.event.WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
add(bu);
la.setText(“Clique número 0”);
add(la);
show();
}
public void actionPerformed(ActionEvent ae) {
if (ae.getSource() == bu) {
count = count + 1;
la.setText(“Clique número “ + count);
}
}
public static void main (String[] args) {
new FrameEvento();
}
}

Dentre as modificações propostas, qual deve ser feita no código acima para que a classe exiba, no rótulo “la”, o número de cliques dados no botão “bu”?

Sejam as classes “mc”, “mcP” e “mcS” escritas em Java e mostradas abaixo.

public class mcP {
int a = 0;
mcP () {
}
mcP (int arg) {
a = arg;
}
int getA () {
return a + a;
}
}
public class mcS extends mcP {
int b = 0;
mcS (int arg) {
b = arg;
}
int getA () {
a = super.getA();
return a;
}
int getB () {
return b + b;
}
int getBA () {
a = b;
return b - a;
}
}
public class mc {
public static void main (String arguments[]) {
int valor;
mcP x = new mcP (2);
mcS y = new mcS (x.getA() - 1);
valor = x.getA() + y.getA() + y.getB() + y.getBA();
x = y;
valor = valor + x.getA() + y.getA() + y.getB() + y.getBA();
y = (mcS)x;
valor = valor + x.getA() + y.getA() + y.getB() + y.getBA();
System.out.println(valor);
}
}

Supondo que a classe “mc” possa ser executada com sucesso, é correto afirmar que o valor apresentado como saída pelo comando “System.out.println(valor);”, quando a classe “mc” é executada sem receber nenhum parâmetro, é:

Seja o seguinte algoritmo escrito em Java.

public class pass {
protected int vl;
int ms (int arg[]) {
int c = 0;
for (int i = 0; i < arg.length; i++) {
if (arg[i] == i) {
c++;
arg[i] = 0;
} else if (arg[i] == c) {
arg[i] = vl;
}
}
return c;
}
pass (int pvl) {
vl = pvl;
}
public static void main (String arguments[]) {
int arr[] = { 3, 1, 6, 3, 2, 5, 7, 7, 9, 0};
int i, n, valor;
pass ps = new pass(1);
n = ps.ms (arr);
i = 0;
valor = 0;
do {
switch (i) {
case 2: arr[i] = arr[i] + 4; break;
case 3: arr[i] = arr[i] - 3; break;
case 5: arr[i] = arr[i] + 2; break;
case 6: arr[i] = arr[i] - 1; break;
default: arr[i] = 0;
}
valor = valor + arr[i];
i = i + 1;
} while (i < n);
System.out.println(valor);
}
}

Com base no algoritmo acima, é correto afirmar que o valor apresentado como saída pelo comando “System.out.println(valor);”, quando a classe “pass” é executada sem receber nenhum parâmetro, é:

Uma questão importante na implementação do armazenamento de arquivos é a manutenção do controle do relacionamento entre os blocos de disco e os arquivos. Neste sentido, sobre os métodos de controle utilizados pelos sistemas operacionais para gerenciar este relacionamento, é INCORRETO afirmar que:

Em um sistema escrito em Java, o estado de um objeto da classe “Faturas” somente pode ser acessado por intermédio dos métodos da própria classe. Em orientação a objetos, este tipo de acesso está diretamente relacionado ao conceito de:

Sobre declaração e escopo de variáveis no Java, são feitas as afirmativas abaixo.

I - Em uma mesma classe é possível declarar dois atributos de classe com o nome VrPendente, desde que eles apresentem níveis de visibilidade diferentes.

II - Atributos de uma classe declarados com o especificador “static final” apresentam valor constante.

III - Atributos de uma classe declarados como protegidos somente podem ser acessados pelos construtores da classe, não podendo ser acessados por outros métodos da classe.

Está(ão) correta(s) a(s) afirmativa(s):

Class Celular {
static String Operadora = “999”;
String cel;
Celular (String cel) {}
private int desligar (String cel) {}
public void verificarNumero (String cel) {}
}

Tomando como base a classe “Celular” incompleta acima, escrita em Java, e as definições utilizadas no Diagrama de Classes da UML, está correto afirmar que: