Boa noite pessoal alguém pode me ajudar com este teste?
Questão 1 (1,5 pt)
Dadas as classes Automóvel, AutomovelBasico e DemoAutomoveis abaixo:
class Automóvel {
public static final byte MOVIDOAGASOLINA = 1;
public static final byte MOVIDOAALCOOL = 2;
public static final byte MOVIDOADIESEL = 3;
public static final byte MOVIDOAGAS = 4;
private String modelo; // o modelo do automóvel
private String cor; // a cor do automóvel
private byte combustível; // o tipo de combustível do automóvel,
// veja lista
// declarada anteriormente nesta classe
...
/* O método toString retorna uma string contendo os campos desta
* classe com uma formatação simples. */
public String toString() {
String resultado;
resultado = modelo+" "+cor+"\n";
switch(combustível) // adicionamos a descrição do combustível
{
case MOVIDOAGASOLINA: resultado += "Movido a Gasolina\n"; break;
case MOVIDOAALCOOL: resultado += "Movido a Álcool\n"; break;
case MOVIDOADIESEL: resultado += "Movido a Diesel\n"; break;
case MOVIDOAGAS: resultado += "Movido a Gás\n"; break;
}
return resultado; // retorna o resultado da concatenação
}
} // fim da classe Automovel
class AutomovelBasico extends Automóvel {
/**
* Declaração dos campos da classe (acessórios que um automóvel básico pode ter)
*/
private boolean retrovisorDoLadoDoPassageiro;
private boolean limpadorDoVidroTraseiro;
private boolean rádioAMFM;
....
} // fim da classe AutomovelBasico
class DemoAutomoveis {
public static void main(String[] argumentos){
Automovel a [] = new Automovel [2];
a [0] = new Automovel("Fusca","verde",Automovel.MOVIDOAALCOOL);
a [1] = new AutomovelBasico("Corsa","cinza",
Automovel.MOVIDOAGASOLINA, true,true,false);
System.out.println(a[0].toString());
System.out.println(a[1].toString());
}
} // fim da classe DemoAutomoveis
- Faça a sobreposição do método toString da classe Automóvel na classe AutomóvelBasico.
- Acontece polimorfismo no método main da classe DemoAutomoveis? Em que momento?
Por quê?
Questão 2 (1,5 pts)
O método abaixo implementa o algoritmo de classificação de dados BubbleSort dado em aula.
Responda as questões abaixo:
public static void bubbleSort(int a[]) {
for (int i = a.length - 1; i > 0; i--) {
boolean flipped = false;
for (int j = 0; j < i; j++) {
if (a[j] > a[j + 1]) {
int T = a[j];
a[j] = a[j + 1];
a[j + 1] = T;
flipped = true;
} // if
exibeVetor(a);
} // for
if (!flipped) return;
} // for
}
a) Considerando que o método exibeVetor exibe o conteúdo do vetor passado como parâmetro,
qual seria a saída da execução do método abaixo, caso o vetor tivesse o seguinte conteúdo: [3,
19, 25, 24, 1, 8, 6].
b) Modifique o algoritmo para que ele chame o método swap para realizar a troca de chaves de
posição (reflita em quais linhas de código você deve remover para inserir a chamada do swap).
A assinatura do método swap é a seguinte:
“public void swap (int a[], int pos1, int pos2)”.
c) Qual seria a consequência de remover a linha “if (!flipped) return;” do código do
algoritmo? Ele executaria mais vezes? Menos vezes? Por quê?
Questão 3 (2 ptos)
Seja a classe StaticList vista em aula, que implementa uma lista linear com alocação estática, crie
um novo método chamado tranferirMenor() que transfere o nó de menor valor para o início da
lista, mantendo os demais na mesma ordem original. Se não for possível fazer a movimentação,
imprimir mensagem com o motivo específico, ou seja: Lista vazia, Lista com um só nó, Maior valor
já está no início da lista.
Questão 4 (1 pt)
Mostre os passos realizados pela pesquisa seqüencial e pela pesquisa binária no vetor abaixo
para encontrar o valor 87. Para tanto, exiba os valores de med, inf e sup a cada iteração.
2 5 9 12 15 20 22 26 30 45 87 92 100
0 1 2 3 4 5 6 7 8 9 10 11 12
Questão 5 (2 ptos)
No método main de uma classe qualquer, escreva o código necessário para criar uma lista
sequencial de String (usando a implementação StaticLista dada em aula) de capacidade de 10
elementos. Usando um laço for, insira as chaves 0, 5, 10, 15, 20, 25, 30, 35, 40. Remova a chave
15, e exiba as chaves na primeira e última posição da lista sequencial.
Questão 6 (2 pts)
Considere os código abaixo:
interface ContaBancaria {
public void retirada(int valor);
public void deposito(int valor);
public int getSaldo();
}
class ContaPoupanca implements ContaBancaria {
private int saldo;
public ContaPoupanca(int saldoinicial) { saldo = saldoinicial;}
public void somaJuros(int juros) {
saldo = saldo + (saldo * (juros) / 100);
}
public void retirada (int valor) { saldo = saldo - valor; }
public void deposito(int valor) { saldo = saldo + valor;}
public int getSaldo() { return saldo;}
}
public class Questao2 {
public static void main(String[] args) {
Object o1 = new ContaBancaria();
Object o2 = new ContaPoupanca(10);
ContaBancaria c1 = new ContaPoupanca(10);
c1.deposito(100);
}
}
Quais das alternativas abaixo estão corretas após a execução do código acima.
a Os métodos da interface ContaBancaria não são abstratos, pois não foram declarados abstract.
b A linha 19 apresenta erro de compilação porque uma variável o1 não pode referenciar um objeto ContaBancaria.
c A linha 19 apresenta erro de compilação porque não é possível criar um objeto ContaBancaria, uma vez que ContaBancaria é uma interface.
d Acontece polimorfismo na linha 21.
e Acontece polimorfismo na linha 22.
f Se o método getSaldo não fosse declarado na interface ContaBancaria, o código da classe ContaPoupanca não compilaria corretamente.
g Se o método getSaldo não fosse implementado na classe ContaPoupanca, essa classe não compilaria sem erros.