1
Q
O que acontece ao tentar rodar um código sem o método main?
A
Quando um programa é executado, a JVM procura por um método main.
Se não encontra, ela lança um erro na execução.
2
Q
O código abaixo compila?
public class TestClass{
public static long main(String[] args){
System.out.println("Hello");
return 10L;
}
}
A
Sim
Mas só será executado se chamado através de outra classe.
3
Q
O que acontece ao chamar o método main através de outra classe?
A
O código executa normalmente.
4
Q
O código abaixo executa?
public class Gato {
public static void main(String[] args){
System.out.println("GATO");
}
}public class Principal{
public static void main(String[] args){
Gato gato = new Gato();
String[] argss = {};
gato.main(argss);
}
}
A
Sim
Compila normalmente!
5
Q
O código abaixo executa?
public class Gato {
public static void main(String[] args){
System.out.println("GATO");
}
}public class Principal{
public static void main(String[] args){
Gato gato = new Gato();
String[] argss;
gato.main(argss);
}
}
A
Não! O código não compila!
A variável argss não foi inicializada.
6
Q
O código abaixo executa?
public class Gato {
public void main(){
System.out.println("GATO");
}
}
public class Principal{
public static void main(String[] args){
Gato gato = new Gato();
gato.main();
}
}
A
Sim, o código compila normalmente.
7
Q
Quais dos pacotes abaixo são importados automaticamente pela linguagem java?
java. util.*
java. lang.*
java. io.
java. awt.
A
java.lang.*
8
Q
O código abaixo compila?
String mStr = "123"; long m = new Long(mStr);
A
Sim compila!
A classe long possui um construtor que recebe uma String.
Todas as classes wrapers possuem um construtor que recebe uma String.
Integer num = new Integer(“123”);
9
Q
O que o código abaixo retorna?
String mStr = “123”;
Long.parseLong(mStr);
A
Retorna um tipo long (primitivo)
O método parse sempre recebe uma string.
O método valueOf recebe um objeto e retorna um wrapper.
10
Q
O que o código abaixo imprime?
int i,j,k;
i = j = k = 20;
System.out.println(i+” “+j+” “+k);
A
20 20 20
11
Q
O que o código abaixo imprime?
int i,j,k;
int b = i = j = k = 20;
System.out.println(b+ “ “ +i+” “+j+” “+k);
A
20 20 20 20
12
Q
O que o código abaixo imprime?
int i;
int b = i = j = k = 20;
System.out.println(b+ “ “ +i+” “+j+” “+k);
A
Não compila
As variáveis j e k não foram declaradas antes.
13
Q
O que o código abaixo imprime?
int i,j,k;
int l = 10;
int b= i= j=k = l =20;
System.out.println(b+” “+i+” “+j+” “+k+” “+l);
A
20 20 20 20 20
14
Q
O código abaixo compila?
float f2 = 123__345_______667F;
A
Sim compila!
Pode ocorrer mais de um underline na operação. Contato que estejam entre números o código compila.
15
Q
O código abaixo compila?
String s = ‘a’;
A
Não
Char não pode ser convertido para String.
16
Q
O código abaixo compila?
char a = ‘a’;
String s = (String)a;
A
Não
Char não pode ser convertido para String.
17
Q
Posso converter char para String?
A
Não
Char não pode ser convertido para String.
char a = ‘a’;
String s = (String)a; //Não Compila
18
Q
Quanto imprime o código abaixo? Integer var = new Integer(5); var++;
A
6
Classes Wrappers são imutáveis.
Mas neste caso o código é iterado e depois reatribuído para a variável.
var = new Integer( var.intValue()+ 1);
19
Q
Qual a saída do programa abaixo?
public static void main(String[] args){
Integer val1 = new Integer(5);
testInts(val1++);
System.out.println(val1);
}public static void testInts(Integer obj){
obj++;
System.out.println(obj);
}
A
6 6
Ao usar o obj++ no método testInts é criada uma nova referência para variável. Não alterando o valor externo.
20
Q
Qual a saída do programa abaixo?
public static void main(String[] args){
Integer val1 = new Integer(5);
testInts(val1++);
System.out.println(val1);
}public static void testInts(Integer obj){
obj++;
obj++;
System.out.println(obj);
}
A
7 6
Ao usar o obj++ no método testInts é criada uma nova referência para variável. Não alterando o valor externo.
21
Q
O que imprime o código abaixo?
int i = 0;
switch(i){
case 0 : System.out.print("Saulo ");
case 1 : System.out.print("Java "); break;
default : System.out.print("Good Bye");
}
A
Saulo Java
O método default só é executado quando nenhum dos outros cases são aceitos.
22
Q
O que imprime o código abaixo?
int i = 0;
switch(i){
case 0 : System.out.print("Saulo ");
case 1 : System.out.print("Java ");
default : System.out.print("Good Bye");
}
A
Saulo Java Good Bye
O método default só é executado quando nenhum dos outros cases são aceitos. Mas na ausência de um break, todos os outros cases são executados.
23
Q
O que imprime o código abaixo?
int i = 0;
switch(i){
default : System.out.print("Good Bye");
case 0 : System.out.print("Saulo ");
case 1 : System.out.print("Java ");}
A
Saulo Java
O método default não precisa ser obrigatoriamente o último.
Mas prevalece a obrigação de usar um break.
24
Q
O que imprime o código abaixo?
int i = 5;
switch(i){
default : System.out.print("Good Bye");
case 0 : System.out.print("Saulo ");
case 1 : System.out.print("Java ");}
A
Good ByeSaulo Java
O método default não precisa ser obrigatoriamente o último.
Mas prevalece a obrigação de usar um break.
25
O código abaixo compila?
Boolean bool = false;
Sim
| Apesar de ser um Wrapper, a atribuição sofre um autobox.
26
O que o código abaixo imprime?
String V1 = "Um";
String V2 = "Dois";
System.out.println( V1.equals(V1=V2) );
False
```
Primeiro o valor de V1 é avaliado.
V1.equals(V1=V2)
"Um".equals(V1=V2)
Em seguida a operação é executada.
"Um".equals("Dois")
```
27
Qual o resultado da operação abaixo?
double x = 39.21;
float y = 2.1;
double z = x + y;
Não compila!
2.1 é um double, e não pode ser convertido diretamente para float.
float y = 2.1f;
28
O código abaixo compila?
int x = !5;
Não
29
O código abaixo compila?
boolean x = !true;
Sim
30
Qual o resultado de x e y?
int x = 3;
int y = ++x * 5 / x-- + --x;
```
x is 2
y is 7
Primeiro resolve todos os operadores de incremento e decremento.
int y = 4 * 5 / 4 + 2;
Só então se executa a operação
```
31
O que imprime a operação abaixo?
System.out.println((1>2==4>45)?("True"):("False"));
True
32
O que imprime a operação abaixo?
System.out.println((1>2=4>45)?("True"):("False"));
Não compila!
33
O que o código abaixo imprime?
int x = 0;
if(true||x++>0)
System.out.println(x);
0
| A segunda parte da operação não será executada pois a primeira já valida a operação.
34
O que o código abaixo imprime?
int x = 0;
if(true|x++>0)
System.out.println(x);
1
| Mesmo que a primeira parte da operação seja true, será executada a segunda verificação.
35
O que o código abaixo imprime?
int x = 0;
if(true&&x++>0)
System.out.println(x);
1
| A segunda operação será executada.
36
O que o código abaixo imprime?
int x = 0;
if(false&x++>0)
System.out.println(x);
O valor de X será 1, mas nada será impresso!
| Mesmo que a primeira condição já invalide a operação, a segunda condição será executada.
37
O que o codigo abaixo imprime?
```
public class Value{
public static void main(String[] args){
for(String val:args){
System.out.println(val);
}
}
}
```
>> java Value 1 2 3
1
2
3
38
O que o código abaixo imprime?
```
public class Switcher{
public static void main(String[] args){
switch(Integer.parseInt(args[1]))
{
case 0 :
boolean b = false;
break;
```
```
case 1 :
b = true;
break;
}
if(b) System.out.println(args[2]);
}
}
```
>>java Switcher 1 2 3
Não compila
A variável b foi instanciada dentro do switch. Portanto não pode ser acessada por um membro externo.
39
O código abaixo compila?
String[] arr = new String[2];
for(String str:arr){
System.out.println(str);
}
Sim! Imprime:
null
null
40
O que imprime o código abaixo?
String[] vet = new String[2];
for(int i = 0; i < vet.length ; i++){
vet[i].concat("Num");
}
for(String ar:vet){
System.out.println(ar);
}
Compila mas lança exceção!
Ele lança uma NullPointerException!
Pois se está tentando concatenar um valor a uma posição null.
Todo vetor de String recebe null a seus valores não atribuídos.
41
O que imprime o código abaixo?
String[] arr = new String[2];
for(int i = 0; i < arr.length; i++){
arr[i]=i;
}
for(String ar:arr){
System.out.println(ar);
}
Não compila!
int não pode ser convertido para String.
```
Para funcionar, converta int para String:
arr[i]=(new Integer(i).toString());
```
42
O que imprime o código abaixo?
```
String[] arr = new String[2];
for(int i = 0; i < arr.length; i++){
arr[i]=(new Integer(i).toString());
}
```
for(String ar:arr){
0
1
O código compila normalmente.
43
O que imprime o código abaixo?
```
int[] arr = new int[2];
try{
System.out.println(arr[2]);
}catch(Exception e) { }
System.out.println(arr[1]);
```
0
Mesmo que se tente acessar um index inexistente do array, o catch pega a exceção.
Vale ressaltar que o mesmo array foi preenchido com o valor padrão do tipo int, que é 0.
44
O que imprime o código abaixo?
int[] arr = new int[2];
System.out.println(arr[2]);
Lança ArrayIndexOutOfBoundsException
Pois se tenta fazer acesso a uma posição inexistente do array.
45
```
Qual das linhas abaixo não compila?
String[] sA = new String[] { "aaa"}; // 1
String[] sA = new String[1] { "aaa"}; // 2
String[] sA = new String[1] ; sA[0] = "aaa"; // 3
String[] sA = {new String( "aaa")}; // 4
String[] sA = { "aaa"}; // 5
```
2
| Não se pode inicializar diretamente o vetor que possui tamanho definido.
46
O código abaixo compila?
String[] sA = new String[1] { "aaa"};
Não
Não se pode inicializar diretamente o vetor que possui tamanho definido.
47
O que imprime o código abaixo?
```
String[] arr = new String[2];
try{
System.out.println(arr[2]);
}catch(Exception e) { }
System.out.println(arr[1]);
```
null
Apesar de fazer um acesso a uma posição invalida do array, esta exceção é tratada.
Portanto a execução segue normalmente.
48
Qual a ordem de inicialização de uma classe?
Primeiro se instancia os membros estáticos, na ordem que eles aparecem.
Em segundo os membros de instância, na ordem que aparecem.
Só então o construtor é executado.
O ultimo item da lista é o método main.
49
O que imprime o código abaixo?
```
public class Inicializadores {
static{
s1 = metodo1("a");
}
```
```
public Inicializadores() {
s1 = metodo1("g");
}
```
static String s1 = metodo1("b");
String s3 = metodo1("d");
{
s1 = metodo1("e");
}
static String s2 = metodo1("c");
String s4 = metodo1("f");
private static String metodo1(String s) {
System.out.println(s);
return s;
}
```
public static void main(String args[]) {
//Inicializadores it = new Inicializadores();
}
}
```
```
a
b
c
d
e
f
g
```
50
O que imprime o código abaixo?
```
public class Inicializadores {
static{
s1 = metodo1("a");
}
```
```
public Inicializadores() {
s1 = metodo1("g");
}
```
static String s1 = metodo1("b");
String s3 = metodo1("d");
{
s1 = metodo1("e");
}
static String s2 = metodo1("c");
String s4 = metodo1("f");
private static String metodo1(String s) {
System.out.println(s);
return s;
}
```
public static void main(String args[]) {
//Inicializadores it = new Inicializadores();
}
}
```
a
b
c
51
O que o código abaixo imprime?
```
public static void main(String[] args){
int i = 10;
tx(i);
System.out.println(i);
}
```
public void tx(int i){
i = 15;
System.out.println(i);
}
Não compila!
| O código tenta chamar um método não estático de um método estático.
52
O que o código abaixo imprime?
```
public static void main(String[] args){
ref r = new ref();
int i = 10;
r.tx(i);
System.out.println(i);
}
```
public void tx(int i){
i = 15;
System.out.println(i);
}
15
| 10
53
O que o código abaixo imprime?
```
public static void main(String[] args){
ref r = new ref();
StringBuilder sb = new StringBuilder("Saulo");
r.tx(sb);
System.out.println(s);
}
```
public void tx(String s){
System.out.println(s);
}
Não compila!
| StringBuilder não pode ser convertido para String.
54
O que o código abaixo imprime?
```
public static void main(String[] args){
ref r = new ref();
StringBuilder sb = new StringBuilder("Saulo");
r.tx(sb);
System.out.println(sb);
}
```
public void tx(StringBuilder s){
s.append("V1");
System.out.println(s);
}
SauloV1
| SauloV1
55
O que o código abaixo imprime?
```
public static void main(String[] args){
ref r = new ref();
int i = 10;
StringBuilder sb = new StringBuilder("Saulo");
r.tx(sb);
System.out.println(sb);
}
```
```
public void tx(StringBuilder s){
s = new StringBuilder("SauloV2");
s.append("V1");
System.out.println(s);
}
```
SauloV2V1
| Saulo
56
O que o código abaixo imprime?
```
public static void main(String[] args){
ref r = new ref();
int i = 10;
StringBuilder sb = new StringBuilder("Saulo");
r.tx(sb);
System.out.println(sb);
}
```
```
public void tx(StringBuilder s){
s = new StringBuilder(s + "SauloV2");
s.append("V1");
System.out.println(s);
}
```
SauloSauloV2V1
| Saulo
57
O que o código abaixo imprime?
```
public static void main(String[] args){
ref r = new ref();
int i = 10;
StringBuilder sb = new StringBuilder("Saulo");
r.tx(sb);
System.out.println(sb);
}
```
```
public void tx(StringBuilder s){
s.append("V1");
s = new StringBuilder(s + "SauloV2");
s.append("V1");
System.out.println(s);
}
```
SauloV1SauloV2V1
| SauloV1
58
O que o código abaixo imprime?
```
public static void main(String[] args){
ref r = new ref();
int i = 10;
StringBuilder sb = new StringBuilder("Saulo");
r.tx(sb);
System.out.println(sb);
}
```
```
public void tx(StringBuilder s){
s.append("V1");
s = new StringBuilder("SauloV2");
s.append("V1");
System.out.println(s);
}
```
SauloV2V1
| SauloV1
59
O que imprime o código abaixo?
public static void main(String[] args){
System.out.println(10 + " " + p());
}
public static int p(){
System.out.println("Go");
return 1;
}
Go
| 10 1
60
O que imprime o código abaixo?
public static void main(String[] args){
System.out.println(10 + " " + p());
}
public int p(){
System.out.println("Go");
return 1;
}
Não compila!
| O código faz uma chamada a um método de instância a partir de um método estático.
61
O que imprime o código abaixo?
```
public class ca{
public void m1(){
System.out.println("M1CA");
}
}
```
```
public class cb extends ca{
public static void main(String[] args){
cb cb1 = new cb();
cb1.m1();
}
public int m1(){
System.out.println("M1CB");
return 0;
}
}
```
Não compila!
Ao sobrescrever um método o retorno não pode ser mais amplo que o método da classe pai.
Neste caso, ao sobrescrever um método que retorna void, o retorno só pode ser void, já que não existe um tipo mais especifico que void.
62
O que imprime o código abaixo?
```
public class ca{
public void m1(){
System.out.println("M1CA");
}
}
```
```
public class cb extends ca{
public static void main(String[] args){
cb cb1 = new cb();
cb1.m1(1);
}
public void m1(int i){
System.out.println("M1CB" + i);
}
```
public void m1(int i, int j){
System.out.println("M1CB" + i + " " + j);
}
}
M1CB1
Neste caso não ocorre um Overriding, mas sim a overloading do código. Pois a assinatura do método é diferente.
63
O que imprime o código abaixo?
```
public class ca{
public String m2(){
System.out.println("M2CA");
return(" ");
}
}
```
```
public class cb extends ca{
public static void main(String[] args){
cb cb1 = new cb();
cb1.m2();
}
public void m2(){
System.out.println("M2CB");
}
}
```
Não compila!
String é considerado um tipo primitivo! Portanto não permite a mudança do tipo de retorno.
64
O que imprime o código abaixo?
```
public class ca{
public int m2(){
System.out.println("M2CA");
return 1;
}
}
```
```
public class cb extends ca{
public static void main(String[] args){
cb cb1 = new cb();
cb1.m2();
}
public short m2(){
System.out.println("M1CB");
return 1;
}
}
```
Não compila!
O overriding não se aplica para tipos primitivos.
Neste caso o retorno na classe filha deveria ser int.
65
O que imprime o código abaixo?
```
public class ca{
public int m2(){
System.out.println("M2CA");
return 1;
}
}
```
```
public class cb extends ca{
public static void main(String[] args){
cb cb1 = new cb();
cb1.m2();
}
public void m2(){
System.out.println("M1CB");
}
}
```
Não compila!
O overriding não se aplica para tipos primitivos.
Neste caso o retorno na classe filha deveria ser void.
66
O código abaixo compila?
```
public class carro extends veiculo{
public static void main(String[] args){
```
```
}
public veiculo getVeiculo(){
System.out.println("Veiculo Carro");
return new veiculo();
}
}
```
```
------------
public class fiat extends carro{
public static void main(String[] args){
```
```
}
public veiculo getVeiculo(){
System.out.println("Veiculo fiat");
return new carro();
}
```
}
Sim!
Neste caso se aplica o overriding no método getVeiculo()
67
O código abaixo compila?
```
public class carro extends veiculo{
public static void main(String[] args){
```
```
}
public veiculo getVeiculo(){
System.out.println("Veiculo Carro");
return new veiculo();
}
}
```
```
------------
public class fiat extends carro{
public static void main(String[] args){
```
```
}
public carro getVeiculo(){
System.out.println("Veiculo fiat");
return new carro();
}
```
}
Sim!
| Neste caso o overriding permite que o método da classe filha retorne um tipo mais especifico.
68
O código abaixo compila?
```
public class carro extends veiculo{
public static void main(String[] args){
```
```
}
public veiculo getVeiculo(){
System.out.println("Veiculo Carro");
return new veiculo();
}
}
```
```
------------
public class fiat extends carro{
public static void main(String[] args){
```
}
public void getVeiculo(){
System.out.println("Veiculo fiat");
}
}
Não compila!
69
O código abaixo compila?
```
public class carro extends veiculo{
public static void main(String[] args){
```
```
}
public Object getVeiculo(){
System.out.println("Veiculo Carro");
return new veiculo();
}
}
```
```
------------
public class fiat extends carro{
public static void main(String[] args){
```
```
}
public carro getVeiculo(){
System.out.println("Veiculo fiat");
return new carro();
}
```
}
Compila normalmente!
| Toda classe herda de Object. O que torna a classe carro uma subclasse de Object.
70
O código abaixo compila?
```
public class carro extends veiculo{
public static void main(String[] args){
```
```
}
public Object getVeiculo(){
System.out.println("Veiculo Carro");
return new veiculo();
}
}
```
```
------------
public class fiat extends carro{
public static void main(String[] args){
```
```
}
public String getVeiculo(){
System.out.println("Veiculo fiat");
return (" ");
}
```
}
Compila normalmente!
| Toda classe herda de Object. O que torna a String carro uma subclasse de Object.
71
O que retorna o código abaixo?
```
public static void main(String[] s){
her h = new her();
h.metodo();
h.metodo(1);
}
```
public void metodo(){
System.out.println("void");
}
public String metodo(int i){
System.out.println("String int");
return " ";
}
void
| String int
72
O que retorna o código abaixo?
```
public static void main(String[] s){
her h = new her();
h.metodo();
h.metodo(1);
h.metodo(1,1);
}
```
public void metodo(){
System.out.println("void");
}
```
public String metodo(int i){
System.out.println("String int");
return " ";
}
public boolean metodo(int k, int b){
System.out.println("int int");
return true;
}
}
```
void
String int
int int
73
Porque o código abaixo não compila?
interface Bozo{
int type = 0;
public void jump();
}
```
public class Type1Bozo implements Bozo{
public Type1Bozo(){
type = 1;
}
}
```
Todos os membros de uma interface são automaticamente public static e final. Mesmo que você não os defina assim!
Portanto a variável type não pode ser redefinida.
74
```
O código abaixo não compila porque?
package yo;
import mm.C;
public class B extends C{
B( ){ }
public static void main(String[] str){
new B();
}
}
-----------------------------------
package mm;
public class C{
C(){};
}
```
O construtor da classe C é default, portanto não pode ser acessado fora do pacote.
75
O que é um covariant return?
Um método que for sobrescrito, pode alterar o tipo do retorno contato que o novo retorno seja uma subclasse do retorno da classe pai.
É importante lembrar que o covariant return não se aplica para tipos primitivos.
76
O que imprime o código abaixo?
```
package mm;
public class C{
public static int k = 10;
}
-----------------------------------
package yo;
import mm.C;
public class B extends C{
```
public static int k = 20;
```
public static void main(String[] str){
C b = new B();
System.out.println(b.k);
}
}
```
10
Neste caso, mesmo que o membro seja estático, o valor acessado é o da classe pai.
O acesso a membros estáticos, de instância e também de métodos estáticos depende da classe da variável, e não do objeto armazenado.
Nestes casos membro acessado é o da classe pai.
Os métodos de instância são uma exceção à regra. Ao serem acessados o método chamado será o da classe filho.
77
O que imprime o código abaixo?
```
package mm;
public class C{
public int k = 10;
}
-----------------------------------
package yo;
import mm.C;
public class B extends C{
```
public int k = 20;
```
public static void main(String[] str){
C b = new B();
System.out.println(b.k);
}
}
```
10
Neste caso, o membro é uma variável de instância. O valor acessado é o da classe pai.
O acesso a membros estáticos, de instância e também de métodos estáticos depende da classe da variável, e não do objeto armazenado.
Nestes casos membro acessado é o da classe pai.
Os métodos de instância são uma exceção à regra. Ao serem acessados o método chamado será o da classe filho.
78
O que imprime o código abaixo?
```
package mm;
public class C{
public static void print(){System.out.println("C");}
}
```
-----------------------------------
```
package yo;
import mm.C;
public class B extends C{
```
```
public static void main(String[] str){
C b = new B();
b.print();
}
public static void print(){
System.out.println("B");
}
}
```
C
Se faz acesso à um método estático. O método que será acessado é o da classe pai. Se o método fosse de instância, o método acionado seria o da classe filho.
O acesso a membros estáticos, de instância e também de métodos estáticos depende da classe da variável, e não do objeto armazenado.
Nestes casos membro acessado é o da classe pai.
Os métodos de instância são uma exceção à regra. Ao serem acessados o método chamado será o da classe filho.
79
O que imprime o código abaixo?
```
package mm;
public class C{
public void print(){System.out.println("C");}
}
```
-----------------------------------
```
package yo;
import mm.C;
public class B extends C{
```
```
public static void main(String[] str){
C b = new B();
b.print();
}
public void print(){
System.out.println("B");
}
}
```
B
O método acessádo é um método de instância. Neste caso é acionado o método da classe filha.
O acesso a membros estáticos, de instância e também de métodos estáticos depende da classe da variável, e não do objeto armazenado.
Nestes casos membro acessado é o da classe pai.
Os métodos de instância são uma exceção à regra. Ao serem acessados o método chamado será o da classe filho.
Ao tentar acessar os membros destas variáveis (Exceto os membros de instância) você estará acessando a classe que foi declarada, e não a classe do objeto.
80
O que imprime o código abaixo?
```
package mm;
public class C{
public int x = 1;
public int printx(){return x;}
}
```
```
-----------------------------------
package yo;
import mm.C;
public class B extends C{
```
```
int x = 11;
public static void main(String[] str){
C b = new B();
C c = (B)b;
```
System.out.println(c.printx());
System.out.println(c.x);
}
public int printx(){return x;}
}
11
1
O valor a ser retornado depende da variável que foi declarada. Em ambos os casos, o tipo declarado é um C.
Então ao tentar acessar os membros destas variáveis (Exceto os membros de instância) você estará acessando a classe que foi declarada, e não a classe do objeto.
81
O que o código abaixo imprime?
public interface B{
int var = 10;
}
```
-----------------------------------
public class A implements B{
public static void main(String[] s){
B b = new B();
System.out.println(b.var);
System.out.println(B.var);
}
}
```
Não compila!
```
Não se pode instanciar uma interface!
B b = new B();
```
82
O que o código abaixo imprime?
public interface B{
int var = 10;
}
```
-----------------------------------
public class A implements B{
public static void main(String[] s){
System.out.println(var);
System.out.println(B.var);
}
}
```
10
10
Todo membro de uma interface é automaticamente public static e final. Portanto pode ser acessado sem uma instância.
83
O que o código abaixo imprime?
public interface B{
int var = 10;
}
```
-----------------------------------
public class A implements B{
public static void main(String[] s){
var = 20;
System.out.println(var);
System.out.println(B.var);
}
}
```
Não compila!
Todo membro de uma interface é automaticamente public static e final. Valores finais não podem ser alterados.
84
O código abaixo compila?
```
public class Super{
}
```
-----------------------------------
```
public class sub extends Super{
public static void main(String[] args){
Super s1 = new Super();
sub s2 = new sub();
s1 = s2;
}
}
```
Sim!
Uma classe superior pode receber uma subclasse da mesma.
Neste caso o cast não é necessário.
85
O código abaixo compila?
```
public class Super{
}
```
-----------------------------------
```
public class sub extends Super{
public static void main(String[] args){
Super s1 = new Super();
sub s2 = new sub();
s2 = s1;
}
}
```
Não compila!
Uma subclasse não pode receber uma super classe sem cast.
86
O código abaixo compila?
```
public class Super{
}
```
-----------------------------------
```
public class sub extends Super{
public static void main(String[] args){
Super s1 = new Super();
sub s2 = new sub();
s2 = (sub)s1;
}
}
```
Compila normalmente!
Uma subclasse não pode receber uma super classe sem cast. Mas neste caso o cast é explicito.
87
O que imprime o código abaixo?
```
class X{
}
```
class XX extends X{
}
```
public class testx{
public static void main(String[] args){
X x = new X();
XX xx = new XX();
x = xx;
System.out.println(x.getClass());
System.out.println(xx.getClass());
}
}
```
```
??????????????????????????????
class XX
class XX
```
O método getClass() pertence à class object. E é um método de instância.
Ao chamar um método de instância, que é de uma classe herdada, será acessado o método do objeto, e não o da variável.
Esta regra não se aplica a objetos e métodos estáticos e variáveis de instância. Nestes casos ao serem acessados, o objeto a ser executado será o da variável.
88
O código abaixo compila?
public interface B{
static void compute();
}
Não!
| Um método estático deve ter uma implementação.
89
```
O código abaixo compila?
public interface A extends B{
static void compute(){
System.out.println("Compute");
}
}
```
```
public interface B{
void compute();
}
```
Não!
O método que sobreescreve um método de instância não pode ser estático.
90
```
O que imprime o código abaixo?
class Animal {
static void fazBarulho() {
System.out.println("Grrr");
}
}
```
```
class Cachorro extends Animal {
static void fazBarulho() {
System.out.println("Au au");
}
}
```
```
class TestaCachorro {
public static void main(String[] args) {
Cachorro c = new Cachorro();
c.fazBarulho();
```
```
Animal a = new Cachorro();
a.fazBarulho();
}
}
```
Au au
| Grrr
91
```
O código abaixo compila?
public interface A{
static void compute(){
System.out.println("Compute");
}
}
```
```
public interface B extends A{
void compute();
}
```
Compila normalmente!
Um método estático não é herdado. Portanto pode existir um método na subclasse com mesmo nome. Seja este estático ou não!
Uma prova disso é que não é possível acessar um método estático da classe pai através da classe filho.
Isso se aplica somente a interfaces. Classes normais não podem ter seus métodos estáticos sobrescritos.
92
O código abaixo compila?
public interface A{
static void compute();
}
```
public interface B extends A{
void compute();
}
```
Não!
Todo método estático deve ter uma implementação!
93
```
O código abaixo compila?
public interface A{
static void compute(){
System.out.println("Compute");
}
}
```
```
public interface B extends A{
static void compute(){
System.out.println("Compute B");
}
}
```
Compila normalmente!
Um método estático não é herdado. Portanto pode existir um método na subclasse com mesmo nome. Seja este estático ou não!
Uma prova disso é que não é possível acessar um método estático da classe pai através da classe filho.
Neste caso cada método estático é tratado de maneira independente.
Isso se aplica somente a interfaces. Classes normais não podem ter seus métodos estáticos sobrescritos.
94
O que código abaixo imprime?
```
public interface veiculo{
static public void getVeiculo(){
System.out.println("Veiculo");
}
}
```
---------------------------
```
public class vw implements veiculo{
public static void main(String[] args){
veiculo vwi = new vw();
vwi.getVeiculo();
}
public void getVeiculo(){
System.out.println("Veiculo vw");
}
}
```
Não compila!
Não se pode chamar um método estático através de uma instância. Em outras palavras, um método estático só pode ser chamado diretamente na própria classe ou interface.
```
vw vwi = new vw();
vwi.getVeiculo(); // ok, pois o método chamado será o da classe filha.
```
```
veiculo vwi = new vw();
vwi.getVeiculo(); // Não compila pois chama o método da classe pai.
```
95
O que código abaixo imprime?
```
public interface veiculo{
static public void getVeiculo(){
System.out.println("Veiculo");
}
}
```
---------------------------
```
public class vw implements veiculo{
public static void main(String[] args){
vw vwi = new vw();
vwi.getVeiculo();
}
public void getVeiculo(){
System.out.println("Veiculo vw");
}
}
```
Veiculo vw
Compila normalmente!
```
veiculo vwi = new vw();
vwi.getVeiculo(); // Não compila pois chama o método da classe pai.
```
96
O código abaixo compila?
```
public interface A{
public default String getNum(){
return "0000";
}
}
---------------------------
public class B implements A{
public static String getNum(){
return "0000";
}
}
```
Não compila!
Tentar sobrescrever um método não estático por um método estático ocasionará um erro de compilação.
Esta regra se aplica também para interfaces e sub-interfaces.
97
O código abaixo compila?
```
public interface A{
public default String getNum(){
return "0000";
}
}
---------------------------
public class B implements A{
public String getNum(){
return "0000";
}
}
```
Compila!
Um método default pode ser sobrescrito sem problemas! Contanto que o novo método não seja static.
Tentar sobrescrever um método não estático por um método estático ocasionará um erro de compilação.
Esta regra se aplica também para interfaces e sub-interfaces.
98
O código abaixo compila?
```
public interface A{
public String getNum();
}
---------------------------
public class B implements A{
public static String getNum(){
return "0000";
}
}
```
Não compila!
Tentar sobrescrever um método não estático por um método estático ocasionará um erro de compilação.
Esta regra se aplica também para interfaces e sub-interfaces.
99
O código abaixo compila?
```
public interface A{
public String getNum();
}
---------------------------
public class B implements A{
public String getNum(){
return "0000";
}
}
```
Compila!
Compila, mas fique atento aos modificadores.
Tentar sobrescrever um método não estático por um método estático ocasionará um erro de compilação.
Esta regra se aplica também para interfaces e sub-interfaces.
100
O código abaixo compila?
```
public interface A{
public default String getNum(){
return "0000";
}
}
---------------------------
public interface B extends A{
public static String getNum(){
return "0000";
}
}
```
Não compila!
Tentar sobrescrever um método não estático por um método estático ocasionará um erro de compilação.
Esta regra se aplica também para interfaces e sub-interfaces.
101
O código abaixo compila?
```
public interface A{
public default String getNum(){
return "0000";
}
}
---------------------------
public interface B extends A{
public default String getNum(){
return "0000";
}
}
```
Compila!
Um método default pode ser sobrescrito por outro método default.
102
O código abaixo compila?
```
public interface A{
public static String getNum(){
return "0000";
}
}
---------------------------
public interface B extends A{
public String getNum(){
return "0000";
}
}
```
Não compila, pois o novo método não é static ou default, portanto não pode ter uma implementação.
103
O código abaixo compila?
```
public interface A{
public static String getNum(){
return "0000";
}
}
---------------------------
public interface B extends A{
public default String getNum(){
return "0000";
}
}
```
Compila!
Esta é a única exceção à regra. Um metodo static pode ser sobrescrito por outro default. Mas o contrário não funciona.
104
O código abaixo compila?
```
public interface A{
public default String getNum(){
return "0000";
}
}
---------------------------
public interface B extends A{
public String getNum(){
return "0000";
}
}
```
Não compila, pois o novo método não é static ou default, portanto não pode ter uma implementação.
105
O código abaixo compila?
```
public interface A{
public String getNum();
}
---------------------------
public class B implements A{
public default String getNum(){
return "0000";
}
}
```
Não Compila!
| Métodos default só podem ser usados em interfaces!
106
O código abaixo compila?
```
public interface A{
public default String getNum(){
return "0000";
}
}
---------------------------
public interface B extends A{
public String getNum();
}
```
Compila normalmente!
107
O código abaixo compila?
```
public interface A{
public static String getNum(){
return "0000";
}
}
---------------------------
public class B implements A{
public String getNum(){
return "0000";
}
}
```
Compila normalmente!
108
O código abaixo compila?
```
public interface A{
public String getNum();
}
---------------------------
public class B implements A{
public static String getNum(){
return "0000";
}
}
```
Não compila!
Tentar sobrescrever um método não estático por um método estático ocasionará um erro de compilação.
Esta regra se aplica também para interfaces e sub-interfaces.
109
Porque o código abaixo não compila?
public static interface A{
final void verge();
}
Métodos de interface não podem ser finais.
110
O código abaixo compila?
```
public interface A{
int FIM = 10;
void verge();
}
---------------------------
public class B implements A{
public void verge(){
FIM = 11;
```
}
}
Não!
| Toda variável de interface recebe automaticamente o modificador final. Portanto não pode ser modificada.
111
O que imprime o código abaixo?
```
public class A{
public static void main(String[] args){
```
```
try{
throw new exp();
}catch(exp e){
System.out.println(e);
}
}
}
```
```
class exp extends Exception{
public exp(){
super("Minha Excecao");
}
}
```
exp: Minha Excecao
112
O que imprime o código abaixo?
```
public class A{
public static void main(String[] args){
```
```
try{
throw new exp();
}catch(exp e){
e.printStackTrace();
}
}
}
```
```
class exp extends Exception{
public exp(){
super("Minha Excecao");
}
}
```
exp: Minha Excecao
| at A.main(A.java:6)
113
O que imprime o código abaixo?
```
public class Exp{
public static void main(String[] str){
try{
throw new Fail("Falha ao Abrir");
}catch(Fail f){
System.out.println(f);
}
}
}
```
```
class Fail extends Exception{
public Fail(String val){
super(val);
}
}
```
Fail: Falha ao Abrir
114
O que imprime o código abaixo?
```
public class Exp{
public static void main(String[] str){
Exp exp = new Exp();
try{
exp.ler();
}catch(Fail f){
System.out.println(f);
}
}
```
```
public void ler()throws Fail{
throw new Fail("Falha ao Abrir");
}
}
```
```
class Fail extends Exception{
public Fail(String val){
super(val);
}
}
```
Fail: Falha ao Abrir
115
O que imprime o código abaixo?
```
public class Exp{
public static void main(String[] str){
Exp exp = new Exp();
try{
exp.ler();
}catch(Fail f){
System.out.println(f);
}
}
```
```
public void ler()throws Fail{
try{
throw new Fail("Falha ao Abrir");
}finally{
System.out.println("Finally");
}
}
}
```
```
class Fail extends Exception{
public Fail(String val){
super(val);
}
}
```
Finally
| Fail: Falha ao Abrir
116
O que imprime o código abaixo?
```
public class Exp{
public static void main(String[] str){
Exp exp = new Exp();
exp.ler();
```
}
```
public void ler(){
try{
throw new Fail("Falha ao Abrir");
}finally{
System.out.println("Finally");
}
}
}
```
```
class Fail extends Exception{
public Fail(String val){
super(val);
}
}
```
Não compila!
Um try finally pode ser executado, mas neste caso a exceção não é tratada, apenas capturada. Ela será devolvida para o método acima, que deve trata-la.
117
O que imprime o código abaixo?
```
public class Exp{
public static void main(String[] str){
Exp exp = new Exp();
exp.ler();
```
}
```
public void ler(){
try{
throw new Fail("Falha ao Abrir");
}catch(Fail f){
System.out.println(f);
} finally{
System.out.println("Finally");
}
}
}
```
```
class Fail extends Exception{
public Fail(String val){
super(val);
}
}
```
Fail: Falha ao Abrir
| Finally
118
O que imprime o código abaixo?
```
abstract class Calcula{
abstract void soma();
int i = 10;
public static void main(String[] args){
System.out.println("Calculadora");
Calcula c = null;
System.out.println(c.i);
}
}
```
Lança uma exceção:
NullPointerException
Uma classe abstrata pode ter main e até ser chamada.
Mas não pode ser inicializada! Caso tente fazer isso, o código não compila.
Neste caso, a classe não é instanciada, portanto o código compila, mas ao tentar imprimir o valor de i, a exceção é lançada.
119
O que imprime o código abaixo?
```
abstract class Calcula{
abstract void soma();
int i = 10;
public static void main(String[] args){
System.out.println("Calculadora");
}
}
```
Calculadora
Uma classe abstrata pode ter main e até ser chamada.
Mas não pode ser inicializada! Caso tente fazer isso, o código não compila.
Neste caso, a classe nunca é instanciada, pois o método main é static.
120
O que imprime o código abaixo?
```
public class Zero{
public static void main(String[] str){
int x = 10;
int y = 0;
if(x/y) System.out.println("Good");
else System.out.println("Bed");
}
}
```
Não compila!
| O valor dentro do if, não é um boolean!
121
O que imprime o código abaixo?
```
List lista = new ArrayList();
lista.add("Saulo");
lista.add("Savio");
lista.add("Manolo");
List lista2 = new ArrayList (lista.subList(1,1));
for(String s:lista2){
System.out.println(s);
}
```
Nada!
O código compila e roda normalmente, mas não imprime nada.
O método lista.subList(1,1) não retorna nada, pois ele retorna um array que contém os valor do index 1(inclusive) e 1(exclusive).
122
O que imprime o código abaixo?
```
public class A{
public static void main(String[] args){
String str = null;
str = str.concat("Saulo");
System.out.println(str);
}
}
```
Compila mas não roda!
Não se pode concatenar um valor à null.
Neste caso, está tentando acessar uma variável null.
Lança NullPointerException!
123
O que imprime o código abaixo?
```
public class B{
public static void main(String[] str){
String nome = "Saulo";
System.out.println("Saulo" == nome);
}
}
```
true
| Ambos os valores estão no pool de String. Uma nova referência não é designada neste caso.
124
O que imprime o código abaixo?
```
public class B{
public static void main(String[] str){
static String VAR0 = "SA";
System.out.println("Saulo" == VAR0+"ULO");
}
}
```
Não compila
| Uma variável Static não pode ser local.
125
O que imprime o código abaixo?
```
public class B{
static String VAR0 = "SA";
public static void main(String[] str){
System.out.println("SAULO" == VAR0+"ULO");
}
}
```
false
Só funciona ao usar intern();
Neste caso, é criado uma nova instância para a variável.
126
O que imprime o código abaixo?
```
public class B{
static String VAR0 = "SA";
public static void main(String[] str){
System.out.println("SAULO" == (VAR0+"ULO").intern());
}
}
```
true
O método intern(); força a busca ou a alocação no pool de strings.
127
O que imprime o código abaixo?
```
public class B{
static String VAR0 = "SA";
public static void main(String[] str){
System.out.println("SAULO" == ("SA"+"ULO"));
}
}
```
true
Neste caso a nova string é armazenada no pool.
Neste caso a falta dos parênteses também não faria diferença.
A linha abaixo também imprime true:
System.out.println("SAULO" == "SA"+"ULO");
128
O que imprime o código abaixo?
```
public class C{
public static void main(String[] args){
C1 c1 = new C1();
System.out.println(c1);
```
}
}
```
class C1{
String val = "Class";
public String getVal(){
return val;
}
}
```
C1@
Toda classe herda de objeto, que implementa toString();
Este método, por padrão imprime o nome da classe e um hash da instância da classe.
Como C1 não sobreescreve toString() imprime o nome da classe seguido do hash da instância.
129
O que imprime o código abaixo?
```
String var = "A";
switch(var){
case "A":
System.out.println("A");
break;
case "B":
System.out.println("B");
break;
default:
System.out.println("DEF");
}
```
A
O default só é acionando quando nenhuma das opções forem verdadeiras.
130
O que imprime o código abaixo?
```
String var = "C";
switch(var){
case "A":
System.out.println("A");
break;
case "B":
System.out.println("B");
break;
default:
System.out.println("DEF");
}
```
DEF
Neste caso, nenhuma das alternativas são válidas, então o case default é acionado.
131
O que imprime o código abaixo?
```
String var = "A";
switch(var){
case 'A':
System.out.println('A');
break;
case 'B':
System.out.println("B");
}
```
Não compila!
O valor do switch é uma String, e a variável nos cases são char.
132
O que imprime o código abaixo?
```
byte b = 10;
switch(b){
case 1:
System.out.println("1");
break;
case 10:
System.out.println("10");
default:
System.out.println("DEF");
}
```
10
DEF
Falta break no segundo case.
133
O código abaixo imprime o que?
```
import java.util.ArrayList;
public class le{
public static void main(String[] args){
ArrayList < int > arl = new ArrayList < int >();
arl.add(1);
arl.add(2);
System.out.println(arl.size());
}
}
```
O código não compila, pois não se pode usar valores primitivos em java containers <>.
Para funcionar neste caso, use Integer.
ArrayList < Integer > arl = new ArrayList< Integer >();
134
Qual a diferença entre length() e length?
O método length() pertence à classe String e StringBuilder.
Já o valor length é um parâmetro de Arrays.
Para ArrayList use o size();
135
O que imprime o código abaixo?
list.add("Saulo");
list.add("Manolo");
String[] lista = new String[list.size()];
list.toArray(lista);
System.out.println(java.util.Arrays.toString(lista));
[Saulo, Manolo]
O método toArray Converte um ArrayList em um Array.
136
O que imprime o código abaixo?
```
public class C{
static public void res(){
System.out.println("C");
}
}
```
---------------------------
public class D extends C{
```
public static void main(String[] args){
C c = new C();
D d = new D();
c = d;
```
d. res();
c. res();
d.print();
c.print();
}
static public void res(){
System.out.println("D");
}
public void print(){
System.out.println("OK");
}
}
Não compila
A variável c, recebe um objeto do tipo D. Neste tipo de situação não é possível acessar objetos e métodos da classe filha. Apenas os da classe pai.
Ao receber um objeto da classe filha, todos os acessos a variáveis e métodos daquele objeto são feitos nos objetos da classe pai. Exceto para métodos de instância. Para estes métodos, são acessados os métodos da classe filho.
Java
flashcards
Decks in class (10)
# Cards
