Instanciar Objeto pela sua referência

Olá Pessoal,

Tenho uma JInternalFrame que chama uma segunda nesta segunda eu recebo que foi o chamador:

javax.swing.JInternalFrame chamador;

public void instancia(javax.swing.JInternalFrame jIframe){
this.chamador = jIframe; // Guarda o valor recebido pelo parâmetro.
}

Aonde o chamador é a classe: wrkflw.RAP.InternalFrameRAP

Aí eu gostaria de fazer isso:
wrkflw.RAP.InternalFrameRAP jIframeRAP = (wrkflw.RAP.InternalFrameRAP)this.chamador;

Porém utilizando o chamador, algo como:
chamador.getName() jIframeRAP = (chamador)this.chamador;

Será que fui claro? Alguém consegue me dar uma dica?

Não entendi o que você quer fazer.

Esse exemplo é sintaticamente errado.

Então deixa eu perguntar:
Qual o motivo que você precisa saber quem foi o “chamador” ?
Que tipo de comportamento você quer implementar com essas duas classes?

Desculpe não ficou claro, Tenho uma jIframe que chama outra, que é um zoom de clientes, quando chamo o zoom passo a instancia de quem chamou através deste método:

public void instancia(javax.swing.JInternalFrame jIframe){
this.chamador = jIframe;
}

Aí quando é escolhido o cliente preciso passar o valor para quem chamou o zoom que faço assim:

public void passaValor(String usuario, String setor, String eMail)
{
wrkflw.RAP.InternalFrameRAP jIframeRAP = (wrkflw.RAP.InternalFrameRAP)this.chamador;
jIframeRAP.campoRecebe(usuario, setor, eMail); // Chama o método que está na ‘janelaPrincipal’
}

Porém este zoom pode ser chamado por várias classes e ele esta fortemente acoplado pois para eu passar os valores preciso escrever o nome da classe que chamou wrkflw.RAP.InternalFrameRAP então, então como quebra galho estou fazendo assim para passar para quem chamou:

public void passaValor(String usuario, String setor, String eMail)
{
if (nomeClass == “RAP”)
{
wrkflw.RAP.InternalFrameRAP jIframeRAP = (wrkflw.RAP.InternalFrameRAP)this.chamador; // Aqui acontece toda mágica, e feito um CAST
jIframeRAP.campoRecebe(usuario, setor, eMail); // Chama o método que está na ‘janelaPrincipal’
}
else
if (nomeClass == “RAC”)
{
wrkflw.RAC.InternalFrameRAC jIframeRAC = (wrkflw.RAC.InternalFrameRAC)this.chamador; // Aqui acontece toda mágica, e feito um CAST
jIframeRAC.campoRecebe(usuario, setor, eMail); // Chama o método que está na ‘janelaPrincipal’
}
}

Como consigo executar o metodo do campoRecebe sem escrever o nome da classe?

Legal, imaginei que fosse algo nesse sentido.

Nestas situações você cria uma interface Listener e está feito o desacoplamento.

Veja o exemplo:

1 - Iterface do Listener

// esta é uma interface para objetos que desejam
// ser notificados quando uma janela faz algo
public interface JanelaListener {

    public void algumaCoisaFoiFeitaNaOutraJanela();
}

2 - Classe que permite que um Listener seja notificado

import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.FlowLayout;
import java.awt.Point;
import java.util.LinkedList;
import java.util.List;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;

// esta é uma janela que avisa aos objetos interessados
// quando ela faz alguma coisa
@SuppressWarnings("serial")
public class JanelaQueAvisaQuandoFazAlgo extends JFrame {

    // está é uma lista de objetos que querem ser notificados
    // quando esta janela faz alguma coisa
    private final List<JanelaListener> listeners = new LinkedList<>();

    public JanelaQueAvisaQuandoFazAlgo() {
        super("Janela que avisa quando faz algo");
        montaLayout();
    }

    private void montaLayout() {
        JButton botao = new JButton("Clique aqui!");
        botao.addActionListener(event -> fazAlgumaCoisaAoClicarNoBotao());

        JPanel painelBotoes = new JPanel(new FlowLayout(FlowLayout.RIGHT));
        painelBotoes.add(botao);

        Container painelPrincipal = getContentPane();
        painelPrincipal.add(painelBotoes, BorderLayout.SOUTH);

        setDefaultCloseOperation(DO_NOTHING_ON_CLOSE);
        setSize(480, 320);
        setLocationRelativeTo(null);
        Point p = getLocation();
        setLocation(p.x + getWidth() / 2, p.y);
    }

    private void fazAlgumaCoisaAoClicarNoBotao() {
        // Aqui você faz o que tem que fazer
        // e em seguida notifica os seus listeners

        for (JanelaListener listener : listeners) {
            listener.algumaCoisaFoiFeitaNaOutraJanela();
        }
    }

    // este método é usado por outra classe
    // para informar que ela quer ser notificada
    // quando esta classe aqui fizer algo
    public void addJanelaListener(JanelaListener listener) {
        if (listener != null) {
            listeners.add(listener);
        }
    }
}

3 - A janela principal que é um Listener da outra janela

import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.FlowLayout;
import java.awt.Point;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.SwingConstants;

// esta janela implementa JanelaListener pois ela quer saber quando
// outra janela fez alguma coisa
@SuppressWarnings("serial")
public class JanelaPrincipal extends JFrame implements JanelaListener {

    public static void main(String[] args) {
        try {
            JanelaPrincipal janela = new JanelaPrincipal();
            janela.setVisible(true);
        } catch (Throwable t) {
            t.printStackTrace();
        }
    }

    private JanelaQueAvisaQuandoFazAlgo outraJanela;

    private JLabel label;
    private int contador;

    public JanelaPrincipal() {
        super("Janela Principal");

        // crio a outra janela
        outraJanela = new JanelaQueAvisaQuandoFazAlgo();

        // avisio a outra janela que esta janela aqui
        // quer ser notificada quando a outra fizer algo
        outraJanela.addJanelaListener(this);

        montaLayout();

    }

    private void montaLayout() {
        JButton botao = new JButton("Abrir outra janela");
        botao.addActionListener(event -> abreOutraJanela());

        label = new JLabel("Fique de olho aqui\nquando clicar no botão\nda outra janela", SwingConstants.CENTER);

        JPanel painelBotoes = new JPanel(new FlowLayout(FlowLayout.RIGHT));
        painelBotoes.add(botao);

        Container painelPrincipal = getContentPane();
        painelPrincipal.add(label, BorderLayout.CENTER);
        painelPrincipal.add(painelBotoes, BorderLayout.SOUTH);

        setDefaultCloseOperation(EXIT_ON_CLOSE);
        setSize(480, 320);
        setLocationRelativeTo(null);
        Point p = getLocation();
        setLocation(p.x - getWidth() / 2, p.y);
    }

    private void abreOutraJanela() {
        outraJanela.setVisible(true);
    }

    // este método é chamado pela outra janela que faz alguma coisa
    @Override
    public void algumaCoisaFoiFeitaNaOutraJanela() {
        contador++;
        label.setText("Fez algo na outra janela " + contador + " vezes!");
        outraJanela.setVisible(false);
    }
}

O que você vai fazer é criar uma interface pra sua janela de zoom.
Aí, quem quiser ser notificado sobre o que o zoom faz, tem que implementar essa interface (ou usar uma inner class, ou lambda) e passar a refêrencia do objeto dessa interface para a tela de zoom antes de abrí-la.

1 curtida

Muito Obrigado staroski!!!

Agora sim, funcionou perfeitamente.
Me tira uma dúvida para que serve esta parte no código:
@SuppressWarnings(“serial”)

Abraço.

A classe JFrame implementa a interface java.io.Serializable

Conforme a documentação, classes que implementam essa interface deveriam declarar uma constante com essa assinatura:

private static final long serialVersionUID = /* um número indicando a versão da classe */;

O compilador gera warnings quando não se declara essa constante.
Entretanto, nesse exemplo aqui nós não queremos serializar essa classe, então eu pus o @SuppressWarnings(“serial”) para o compilador ignorar esse warning.