Questões de Java (Programação)

Limpar Busca

Considere a classe Main abaixo.
import java.util.*;
public class Main {
    public static void main(String[] args) {
          Stack<Integer> pp=new Stack<Integer>();           Stack<Integer> pi=new Stack<Integer>();           Stack<Integer> tc=new Stack<Integer>();           Scanner s=new Scanner(System.in);           Integer var;
           var=s.nextInt();            while( var > 0 ) {                tc.push(var);                 var=s.nextInt();
            }             s.close();
           while( !tc.empty() ) {                 var=tc.pop();
                if( var%2 == 0 )                       pp.push(var);                 else                        pi.push(var);
              }               while( !(pi.empty() || pp.empty()) ) {                   if( !pi.empty() )                           System.out.printf("%d ", pi.pop());                   if( !pp.empty() )                           System.out.printf("%d ", pp.pop());               }        } }
Suponha que a seguinte sequência de números inteiros tenha sido digitada por um usuário quando da execução do método main acima:
4 16 8 12 7 14 9 15 -1
O que foi exibido no console pelo método main?

  • A 7 4 9 16 15 8 12 14
  • B 7 4 9 16 15 8
  • C 15 14 9 12 7 8
  • D 15 14 9 12 7 8 16 4
  • E 4 7 16 9 8 15

Considere a classe Java abaixo.
public abstract class VendaIngresso {      public void encerraVenda(String espetaculo, String assento) {               double valor = calculaValorIngresso();               confirmaPagamento(valor);                imprimeIngresso();       }       protected void imprimeIngresso() {                 // implementação irrelevante para resolver a questão        }        protected void confirmaPagamento(double valor) {                 // implementação irrelevante para resolver a questão        }        protected abstract double calculaValorIngresso(); }
Ela contém métodos que implementam o processo de venda de ingressos para espetáculos culturais. Entre eles está o método de encerramento de uma venda, que é composto de três etapas. São elas:
• o cálculo do valor do ingresso; • a confirmação do pagamento; • a impressão do ingresso.
As duas últimas etapas independem da natureza de quem está comprando um ingresso, por isso foram implementadas diretamente na classe VendaIngresso. A 1ª etapa, entretanto, não pôde ser implementada nessa classe, pois o valor de um ingresso pode variar de acordo com o tipo de comprador (estudante, idoso, pessoa com deficiência, dentre outros). Por isso, o método calculaValorIngresso é abstrato. 

Uma 2ª classe, que implementa a venda de ingressos para estudantes, é mostrada a seguir.
public class VendaIngressoEstudante extends VendaIngresso {        protected double calculaValorIngresso() {             // implementação irrelevante para resolver a questão        } }
Ela é uma subclasse de VendaIngresso que implementa o cálculo do valor de um ingresso de estudante. Dessa forma, um programa Java que implemente a venda de ingressos para estudantes, baseada nas classes acima, irá conter os seguintes comandos:
VendaIngresso v = new VendaIngressoEstudante(); v.encerraVenda("Máquina Mortífera 20", "L8");
Qual padrão de projeto foi empregado na solução descrita acima?

  • A Prototype
  • B Adapter
  • C Composite
  • D Mediator
  • E Template Method

O método main, a seguir, ordena um array de empregados em ordem crescente de salários.
import java.util.Arrays; public class Main {     public static void main(String[] args) {
               Empregado vet[];
               // Comandos entre estes comentários e a chamada                // do método sort() irão instanciar um array de Empregado,                // carregá-lo com instâncias de Empregado e atribuí-lo à                // variável vet                //                // Esses comandos são irrelevantes para a questão                Arrays.sort(vet);        } }
Quais implementações das classes Pessoa e Empregado complementam o código Java acima, de modo que a ordenação do array de empregados seja executada com sucesso?

  • A import java.util.*; public class Pessoa implements Comparable<Empregado>  {         String nome;         int matricula;         public int compareTo(Empregado e) {                if (this.salario > e.salario)                      return 1;                 else                      if (e.salario > this.salario)                             return -1;                     else                             return 0;            } } import java.util.*; public class Empregado extends Pessoa {          double salario; }
  • B import java.util.*; public class Pessoa implements Comparable<Empregado>  {      String nome;       int matricula;       public int compareTo(Empregado e) {               if (this.salario > e.salario)                      return 1;               else                      if (e.salario > this.salario)                                      return -1;                       else                                      return 0;         } } import java.util.*;
    public class Empregado extends Pessoa implements Comparator {       double salario;        public int compare(Empregado e1, Empregado e2) {            if (e1.salario > e2.salario)                  return 1;            else                 if (e1.salario > e2.salario)                        return -1;                 else                        return 0;         } }
  • C import java.util.*; public class Pessoa implements Comparatorr <Empregado>  {           String nome;          int matricula;           public int compare(Empregado e1, Empregado e2) {               if (e1.salario > e2.salario)                         return 1;                 else                         if (e1.salario > e2.salario)                                       return -1;                          else                                        return 0;            } } import java.util.*; public class Empregado extends Pessoa {          double salario; }
  • D import java.util.*; public class Pessoa {         String nome;         int matricula; } import java.util.*; public class Empregado extends Pessoa implements Comparator <Empregado> {       double salario;       public int compare(Empregado e1, Empregado e2) {           if (e1.salario > e2.salario)                     return 1;            else                     if (e1.salario > e2.salario)                               return -1;                       else                             return 0;        } }
  • E import java.util.*; public class Pessoa {          String nome;           int matricula; } import java.util.*; public class Empregado extends Pessoa implements Comparable <Empregado> {           double salario;          public int compareTo(Empregado e) {                   if (this.salario > e.salario)                             return 1;                     else                              if (e.salario > this.salario)                                     return -1;                                else                                     return 0;               } }

Kotlin é uma linguagem de programação usada no desenvolvimento Android.
Entre suas características, está um grau de compatibilidade com Java, que permite

  • A chamar funções feitas em Java, apenas, mas não permite que suas funções Kotlin sejam chamadas por Java.
  • B ler dados que foram salvos por apps Java, apenas.
  • C ler e escrever dados que podem ser lidos e escritos por apps Java, apenas.
  • D ter suas funções chamadas por Java, apenas, mas não consegue chamar funções feitas em Java.
  • E construir apps com código parcialmente em Java e parcialmente em Kotlin, sem restrições.

Um programador foi instruído pelo seu gerente a implementar, em Java, uma classe MemoriaCalculoVenda que implementasse a interface MemoriaCalculo, já criada pela organização e que representa as exigências da organização para classes que implementam memórias de cálculo.
Nesse cenário, com que fragmento de código o programador deve começar, de forma correta, a implementação da classe?

  • A class MemoriaCalculoVenda extends MemoriaCalculo
  • B class MemoriaCalculoVenda implements MemoriaCalculo
  • C class MemoriaCalculoVenda imports MemoriaCalculo
  • D class MemoriaCalculoVenda inherits MemoriaCalculo
  • E class MemoriaCalculoVenda uses MemoriaCalculo