Duvida sobre interface grafica

No priemeiro caso, você criou uma classe filha de WindowAdapter, com um nome.

No segundo caso, você também criou uma classe filha de WindowAdapter, mas anônima.

O importante é saber que o Java irá chamar o método windowActivated para qualquer classe (anônima ou não) que implemente a interface WindowListener.

A classe WindowAdapter implementa essa interface, simplesmente inserindo um método em branco para cada método de WindowListener, para que as filhas não sejam obrigadas a implementar os métodos que não querem trabalhar. Por exemplo, no segundo código que você postou o método windowActivated poderia ser totalmente suprimido, pois é justamente para evitar implementações vazias como esta que um método igual vazio foi inserido na classe WindowAdapter.

ViniGodoy entao existem 2 formas de criar uma classe filha. No 1° codigo utilizando herança e no 2° codigo a criacao de um objeto da classe Windowsadapter?

Deixa ver se eu entendi. A classe windowsadapter serve para colocar metodos em branco da interface windowlistener.
Se retirar o metodo windowActivated do codigo, ele vai ser executado do mesmo jeito?É isso?

Obrigado!

Existem duas formas de se fazer herança. A primeira é explícita, dando um nome a classe filha que você criou:

public class WindowHandler extends WindowAdapter {
   //Implementação do filho de WindowAdapter
}

WindowAdapter adapter = new WindowHandler();

A segunda é anônima. Ou seja, uma classe filha será criada, mas você não dará nome a ela. Note que dessa forma você só pode criar classes internas. Não tem como criar uma classe pública anônima.

WindowAdapter adapter = new WindowAdapter() {
   //Implementação do filho de WindowAdapter
};

Em ambas as formas, existe herança e estamos criando um filho de WindowAdapter.

Mas, o que é a classe WindowAdapter? É uma implementação, em branco, de WindowListener, WindowStateListener e WindowFocusListener.

Isso para você não ser obrigado a colocar implementações em branco caso queira usar apenas um evento.

O código dela (sem os comentários) é:

public abstract class WindowAdapter
    implements WindowListener, WindowStateListener, WindowFocusListener
{
    public void windowOpened(WindowEvent e) {}
    public void windowClosing(WindowEvent e) {}
    public void windowClosed(WindowEvent e) {}
    public void windowIconified(WindowEvent e) {}
    public void windowDeiconified(WindowEvent e) {}
    public void windowActivated(WindowEvent e) {}
    public void windowDeactivated(WindowEvent e) {}
    public void windowStateChanged(WindowEvent e) {}
    public void windowGainedFocus(WindowEvent e) {}
    public void windowLostFocus(WindowEvent e) {}
}

Lembre-se, sempre que você implementar uma interface, você é obrigado a implementar todos os seus métodos.
O seu mesmo código, sem o WindowAdapter, criando uma classe filha anônima diretamente de WindowListener ficaria obrigatoriamente assim:

public class Exemplo extends JFrame implements MouseListener,KeyListener... 
 { 
   { 
         public static void main(String[] args) 
         { 
           JFrame Janela= new Exemplo(); 
           Janela.show(); 
           WindowListener x= new WindowListener() 
           { 
              public void windowClosing(WindowEvent e) 
              { 
                        System.exit(0) 
              } 
 
               //Implementação em branco de método que não interessam.
               public void windowActivated(WindowEvent e)  {} 
               public void windowDeactivated(WindowEvent e);
               public void windowOpened(WindowEvent e) {}
               public void windowClosed(WindowEvent e) {}
               public void windowIconified(WindowEvent e) {}
               public void windowDeiconified(WindowEvent e) {}
          }; 
            Janela.addWindowsListener(x);

Note que há uma série de métodos em branco, que podem ser evitados se você usar o WindowAdapter. Isso porque essa classe já define esses métodos desse jeito, como você pode ver no código fonte dela...

Entendi!! Agora compreendi legal! Obrigado, esta me ajudando muito!
É dificil encontrar explicaçao sobre isso.
Mas, surgiu umas duvidas boba em relacao ao 1 programa.

Porque que no 1° programa nao foi colocado desse jeito que voce mostrou:

Codigo do 1º programa

import java.awt.*; 
    import java.awt.event.*; 
    public class Janela extends Frame { 
   class WindowHandler extends WindowAdapter { 
   public void windowClosing(WindowEvent we) { 
   dispose(); 
   System.exit(0); 
   } 
   public void windowActivated(WindowEvent we) { 
  we.getWindow().validate(); 
   } 
   } 
 public Janela() { 
   this("Janela"); 
   } 
  public Janela(String titulo) { 
  setTitle(titulo); 
  setSize(320,200); 
  addWindowListener(new WindowHandler()); 
  } 
  public static void main(String[] args) { 
  Janela j = new Janela(); 
  j.setVisible(true); 
  } 
  }

ViniGodoy,Outra duvida que surgiu é sobre a execuçao desse programa. Ele começa executar chamando o metodo.

Depois cria o objeto para a classe janela.
Chama o 1°metodo construtor, depois o 2º metodo construtor.
Registra o objeto que ira tratar o evento da interface windowlistener??

Esse é o fluxo do programa?? Estou com duvida sobre o funcionamento desse programa.

Obrigado!! e desculpe esta te encomodando mais uma vez.

Esse programa chama um construtor, o da janela, sem parâmetros.

Para não ter que reimplementar todo o segundo construtor, esse construtor chama o segundo, passando um título como default. Mas apenas um objeto será construído, pois os construtores chamam uns aos outros de maneira especial.

O código não fez:
WindowAdapter adapter = new WindowHandler();

Porque não haveria necessidade de usar a variável adapter em lugar nenhum, exceto na linha:
addWindowListener(adapter);

Então, para evitar ter duas linhas assim:

WindowAdapter adapter = new WindowHandler();
addWindowListener(adapter);

O programador do código “pegou um atalho” e já colocou o valor da variável adapter direto. Essa técnica se chama “inline”.

Note que você poderia fazer a mesma coisa no seu main e trocar de:

Janela j = new Janela(); j.setVisible(true);
Para:

O fluxo do programa que você descreveu está correto.
Ele chama um construtor, que irá chamar o segundo construtor. Nesse segundo construtor ele define alguns atributos da janela e registra o listener dos eventos.

Depois, o programa sai do construtor e torna a janela visível.

Obrigado!! Solucionou as minhas duvidas.
Que material ou curso voce recomenda para aprender mais sobre java?