Dadas as classes abaixo, descritas cada qual em seu respectivo arquivo e todas estando no mesmo pacote, com classpath e JDK versão 1.7 devidamente configurados, e todos os imports corretamente feitos.

Foo1.java

abstract class Foo1 {
  int x=0;
  abstract int foo1();
  abstract void foo2(int foo);
}

Foo2.java

public class Foo2 extends Foo1{
  int foo1() {
  return super.x;
}

void foo2(int foo) {
  super.x=foo; }
}

Foo3.java

public class Foo3 extends Foo2 implements Foo4{
  int x=0;
  public int foo2() {
    return x;
  }

  public void foo1(int foo) {
    x=foo;
  }
}

Foo4.java

public interface Foo4 {
  void foo1(int foo);
  int foo2();
}

Foo5.java

public class Foo5 implements Foo4{
  int x = 0;
  public int foo2() {
    return x;
  }
  public void foo1(int foo) {
    x=foo;
  }
}

Com base nas classes apresentadas, no mesmo pacote foi criada a seguinte classe:

Test.java

public class Test {
  public static void main(String[] args) {
    Foo4 f4 = new Foo3();
    f4.foo1(1);
    f4 = new Foo5();
    System.out.println(f4.foo2());
   }
}

Ao executarmos a classe Test.java, obteremos o seguinte resultado no console:

Considerando o seguinte código PHP:

<?php
$a = 1;
function Teste(){
 $a=10;
 echo $a. ' '; }

Teste();
echo $a .' ';
$b = 12;

function Soma() {
 global $a, $b;
 $b = $a + $b;}

Soma();
echo $b.' ';

?>

Marque a opção que indica a saída do script:

Considerando o trecho de código C abaixo:

int main () {
  int A, B, I, J;
  scanf("%d", &A);
  do{
    for (I = 1; I <= A; I++) {
      J=I;
      while (J <= A)
      {
        printf("%d ", J );
        J++;
      }
    }
    B = A;
    scanf("%d", &A);
  }
  while ((A == B) || (A >= 1));
} 

Ao executar o código, o que será mostrado se forem usados os valores 4, 2 e 0 como entrada?

Com base nas classes apresentadas na questão anterior, no mesmo pacote foi criada a seguinte classe:

Test1.java

public class Test1 {
  public static void main(String[] args) {
    Foo1
    f = new Foo2();
    f.foo2(3);
    f = new Foo5();
    f.foo1(2);
    f = new Foo3();
    f.foo2(1);
    System.out.println(f.foo1());
  }
}

Ao executarmos a classe Test1.java, obteremos o seguinte resultado no console:

Leia as afirmativas a seguir sobre Sistemas de Entrada/Saída:

I. Quando as operações de Entrada/Saída são controladas inteiramente pela CPU (unidade central de processamento), diz-se que o computador está empregando Entrada/Saída Programada.

II. DMA (acesso direto à memória) é definido por operações que NÃO necessitam de barramento com a memória principal para a transferência de dados.

III. O padrão USB 2.0 (Universal Serial Bus) utiliza comunicação paralela para aumento da taxa de transmissão de dados.

IV. Diferente do DMA (acesso direto à memória), uma interrupção faz a CPU parar temporariamente a execução do programa em curso.

Assinale a alternativa em que todas as afirmativas estão CORRETAS.

Leia as afirmativas a seguir sobre Memória Cache:

I. A técnica conhecida como divisão (split) de cache consiste em introduzir caches separadas para instrução e para dados.

II. Memórias cache de nível 2 devem ficar posicionadas entre a memória principal e memória secundária.

III. O princípio da localidade temporal estabelece que os endereços de memórias acessados recentemente voltarão a ser requisitados em um futuro próximo.

IV. A memória principal é aglutinada em um único bloco de tamanho variável, conhecido como linha de cache.

Assinale a alternativa em que todas as afirmativas estão CORRETAS.

Leia as afirmativas a seguir sobre as arquiteturas de processadores:

I. A partir da família de processadores 486, a Intel começou a projetar seus processadores com um núcleo RISC, apesar de executar instruções mais complexas com a filosofia CISC.

II. Registradores vetoriais devem ser carregados por múltiplas instruções e serem executados em paralelo por diferentes processadores, em um barramento paralelo de altíssima velocidade.

II. Arquiteturas Superescalares são constituídas de múltiplos processadores, com execução de instruções em pipelines sequenciais, com memória cache independentes.

IV. Um processador matricial é composto por muitos processadores idênticos, que executam a mesma sequência de instruções sobre diferentes conjuntos de dados.

Assinale a alternativa que (todas) a(s) afirmativa(s) está(ão) CORRETA(S).