Nao entendi porque esta thread imprimi:
"Minha thread:start ( ) " seguido de “Executa: run()”.
Alguem poderia me explicar?
Class MinhaThread extends Thread {
public void run ( ) {
System.out.println("MinhaThread: run ( )" );
}
public void start ( ) {
System.out.println("MinhaThread: start ( )" );
}
}
Class Executa implements Runnable {
public void run ( ) {
System.out.println("Executa: run ( )" );
}
public void run ( ) {
System.out.println("Executa: start ( )" );
}
}
public class Teste {
public void static void main ( String args[ ] )
MinhaThread mt = new MinhaThread( );
Executa ex = new Executa( );
Thread th = new Thread (ex);
mt.start ( );
th.start ( );
}
}
Amigo , do jeito que a classe Executa está, vc tem dois métodos com o mesmo nome (run()) e que recebem os mesmos argumentos (neste caso nenhum…)
Como vc espera que o Java saiba qual método chamar, já que a assinatura de ambos é identica?
Pelo que vi ele simplesmente chama o primeiro que encontra, que foi o que gerou a saida “Executa: run()”.
Quando vc chama o método start de uma Thread que recebeu no contrutor um objeto de uma classe que implementa a interface Runnable, a Thread chama o método run() deste objeto, exatamente como esta sua saída… Só que chamou o primeiro run de Executa, pois os dois são identicos em suas assinaturas, mesmo que o corpo do método seja diferente…
Ele deixa compilar sim! é um caso de overridding, a implementação dos metodos é diferente, apesar da assinatura ser indentica…vou tentar compilar em casa…mas creio que dá para compilar sim…e o java vai rodar o primeiro metodo!
Ele deixa compilar sim! é um caso de overridding, a implementação dos metodos é diferente, apesar da assinatura ser indentica…vou tentar compilar em casa…mas creio que dá para compilar sim…e o java vai rodar o primeiro metodo![/quote]
Overriding? Ta certo, ta sobrescrevendo (implementando) o método da interface Runnable, mas o cabeçalho do método é public void run() num é? Ele tem DOIS métodos com a mesma lista de argumentos (nenhuma no caso). Isso não é permitido!!!
E outra, o kra ta sobrescrevendo o método start() da classe Thread! Isso num deve ser feito!!! Ele perde a funcionalidade da thread ao fazer isso! O método start que invoca o método run… O método start num deve ser sobrescrito.
public static void main ( String[] args ) {
MinhaThread mt = new MinhaThread( );
Executa ex = new Executa();
Thread th = new Thread(ex);
mt.start();
th.start();
}
}
class MinhaThread extends Thread {
public void run() {
System.out.println("MinhaThread: run()" );
}
}
class Executa implements Runnable {
public void run() {
System.out.println("Executa: run()" );
}
}[/code]
Então vc pergunta, pq quando eu executo meu aplicativo ele me fornece a saída:
MinhaThread: run()
Executa: run()
Ou mesmo (pode acontecer :D, lembre-se a JVM num garante a Thread q será iniciada primeiro…
Executa: run()
MinhaThread: run()
Meu deus, eu chamo o método start e naum o método run! E ele me mostra o resultado do método run!!! O que está acontecendo? Minha JVM está maluca?
NÃO! Não está maluca!
Quando vc usa threads vc sempre vai sobrescrever (de uma Thread) ou implementar (sobrescrever, eu sei :D) (da Runnable) o método run() que conterá o que a thred deve fazer, mas sempre ao instanciar uma thread vc vai usar o método start para iniciar sua execução. Vc NÃO deve sobrescrever o método start, ele já está implementado na thread e sua implementação faz com que o método run seja executado corretamente.
Pessoal, foi mal. Foi erro de digitacao. Na classe executa o metodo é “public void start ( )” e nao “public void run( )”.
Por isso é que nao estava compilando.
Class MinhaThread extends Thread {
public void run ( ) {
System.out.println("MinhaThread: run ( )" );
}
public void start ( ) {
System.out.println("MinhaThread: start ( )" );
}
}
Class Executa implements Runnable {
public void run ( ) {
System.out.println("Executa: run ( )" );
}
public void start ( ) {
System.out.println("Executa: start ( )" );
}
}
public class Teste {
public void static void main ( String args[ ] ) {
MinhaThread mt = new MinhaThread( );
Executa ex = new Executa( );
Thread th = new Thread (ex);
mt.start ( );
th.start ( );
}
}
Agora ficou tudo claro!! código resolvido!
realmente não compila da maneira que estava escrito…na hora que li fiquei em dúvida…mas realmente, dois metodos com mesma assinatura não caracteriza um overriding…o compilador não tem como saber qual metodo está sendo chamado…
como vc sobrescreveu o metodo start de thread, ele vai chamar o seu metodo que vai imprimir Minha Thread: start
th.start();
aqui, como vc mandou um Runnable para Thread, ele vai executar o run do Runnable, imprimindo Executa: run ( ) (assincronamente, mas nesse caso nao vai fazer diferenca)
Deixa ver se eu entendi, takeshi10.
Se nao tivesse o metodo “public void start ( )” ele executaria o metodo public void run ( ) da classe “MinhaThread”, é isso mesmo?
Mas a funcao do start nao é registrar a thread no ambiente de execucao?
Tem um porque da sobrescricao?
[quote=AlunoJava]Deixa ver se eu entendi, takeshi10.
Se nao tivesse o metodo “public void start ( )” ele executaria o metodo public void run ( ) da classe “MinhaThread”, é isso mesmo?
Mas a funcao do start nao é registrar a thread no ambiente de execucao?
Tem um porque da sobrescricao?
Obrigado [/quote]
sim… o comportamento padrao do start () da classe Thread eh (criar uma nova thread e nela) executar o run() dele mesmo ou do Runnable que vc passou como parametro…
porque da sobrescricao eh vc que tem que dar pq o exemplo foi seu…