Exceções - TestKiller

cara o testekiller sempre tem erros, acho legal isso pq quando voce começar a pegar os erros do testkiller é que voce ta ficando pronto para fazer a prova.

Diabo Loiro, vlw mesmo. O pior é que eu não acho erros só em testes não, até em livros já achei,
da vontade de ligar pra revisão tecnica dos livros chingar todos eles.

muito obrigado

sempre tem erros.
Quando voce comprar um livro no site da altabooks por exemplo tem parte que tem uma errata, se o erro que voce encontrou não estiver lá envie ele para poupar ou outros usuários deste aborrecimento.

Ei achei mais uma estranha:

public class Questao91 {
	 public String makinStrings() {
	 String s = "Fred";
	 s = s + "47";
	 s = s.substring(2, 5);
	 s = s.toUpperCase();
	 return s.toString();
	 }

}

//Quantos objetos String serão criados quando este método for chamado?
//
//		A. 1
//		B. 2
//		C. 3 -OK
//		D. 4
//		E. 5
//		F. 6

Eu dei uma olhada nos hashcodes de cada atribuição feita, e me deu 4 objetos diferentes, sera que eu to certo de novo? ou não?
obrigado

Eu acho que são 4 mesmo, respectivamente
“Fred”
“Fred47”
“e7”
“E7”
Como cada String é final, para cada uma foi um objeto diferente… 8)

drigo.angelo:

Eu acho que são 4 mesmo, respectivamente "Fred" "Fred47" "e7" "E7" Como cada String é final, para cada uma foi um objeto diferente.. 8)

Isso acontece não porque a String é final, mas porque ela retorna uma nova string na invocação do método

Olha o método substring

public String substring(int beginIndex, int endIndex) {
	if (beginIndex < 0) {
	    throw new StringIndexOutOfBoundsException(beginIndex);
	}
	if (endIndex > count) {
	    throw new StringIndexOutOfBoundsException(endIndex);
	}
	if (beginIndex > endIndex) {
	    throw new StringIndexOutOfBoundsException(endIndex - beginIndex);
	}
	return ((beginIndex == 0) && (endIndex == count)) ? this :
	    new String(offset + beginIndex, endIndex - beginIndex, value);
    }

Eu acho que seria:

Fred
Fred47
Fred4
FRED4

pessoal por favor, respondam qual alternativa vocês acham que seria a correta
na minha opiniao é 4 objetos String criados, sendo que no TestKiller fala que é 3.

Ou seja, Strings são constantes (não necessáriamente final, foi mals :oops: ) ; seus valores não podem ser alterados depois que elas são criadas.

Logo, se temos 4 valores para String:
“Fred”
“Fred47”
“ed47”
“ED47”

Temos 4 objetos String.

Realmente tem 4 objetos ali, mas a pergunta se refere a quantos são criados no momento que o método é chamado. A primeira linha não cria uma String, apenas pega uma referência do pool.

Vejam a explicação do thingol: http://www.guj.com.br/java/116352-duvida-na-quantidade-de-strings-criadas-resolvido

ta muito estranho isso, se na primeira linha, ou seja, na atribuição (String s = “Fred”) fala que pegou essa
literal do pool de Strings, qual a diferença para o codigo na proxima linha (s = s + “47”) sendo que o 47 tambem
vem do pool???

aqui esta a minha versao. O pool só serve para que a JVM economize memória, por exemplo:

public class Teste {
	public static void main(String[] args) {
		String s1 = new String("Java");// Um objeto String "Java" foi criado e
										// foi para o pool, assim quando ou se
										// outra String
										// "Java" for criada
										// simplesmente essa nova variavel pega
										// a referencia da String "Java"
										// anterior.
		String s2 = "Java";

		System.out.println(s1.hashCode());
		System.out.println(s2.hashCode());
	}
}

Na minha opiniao é isso, e tambem foi o que eu entendi do livro do Roberto Serson.
Rodem o programa e vejam como os hashcodes sao iguais.
No comando (String s = “Fred” uma objeto String é criado da mesma forma como usando
a palavra “new”, porém só se esta String ainda não foi criada, se não, entao ela simplesmente pega
a referencia da String igual anterior.

me desculpem, acho que eu falei besteira. Mas se for verdade, entao o livro ta errado.

IronM:

ta muito estranho isso, se na primeira linha, ou seja, na atribuição (String s = “Fred”) fala que pegou essa
literal do pool de Strings, qual a diferença para o codigo na proxima linha (s = s + “47”) sendo que o 47 tambem
vem do pool???

http://java.sun.com/docs/books/performance/1st_edition/html/JPMutability.fm.html

http://www.javaranch.com/journal/200409/Journal200409.jsp#a1

E diversos posts do thingol aqui no GUJ.

Na questão levantada, o que eu entendi é que “Fred” e “47” já estão no pool desde que a classe foi carregada, porque foram declarados como literais entre as aspas, porém “Fred47” não, ele foi criado no momento que houve a concatenação (s + “47”) dentro do método citado.

Agora no caso do hashCode, se for implementado na classe para gerar o número de acordo com o conteúdo, vai retornar o mesmo número quando os objetos tiverem o mesmo conteúdo, mas não significa que é o mesmo objeto instanciado na memória.

Bom, esta é a minha opinião.

Oi de novo amigos, aproveitando este mesmo topico, tenho outra suspeita de uma questão do testkiller:

abstract class A{
      abstract void a1();
      void a2() {}
 }
 class B extends A {
      void a1() {}
      void a2() {}
}
 class C extends B {
      void c1() {} 
}

public class Questao141 {
	public static void main(String[] args) {
		A x = new B(); 
		C y = new C(); 
		A z = new C();
		
		 x.a2();
		 z.a2();
		 z.c1();
		 z.a1();
		 y.c1();//como é que essa pode ser certa??
		 x.a1();
	}
}

aquela alternativa não pode estar certa, sendo que uma referecia do tipo “C” recebe de fato um “C”,
como a chamada a o metodo “c1” pode ser polimorfica senfo que o metodo “c1” só é definido
na classe “C”? sera que estou enganado?

obrigado

desenterrando o tópico… alguém sabe porque ?

é cara… certeza

tá errado kkkkk