Como impedir de uma Janela ser aberta + de 1 vez?

Crie uma variável static boolean e sete como true no construtor e depois como false no finalize().

Ainda no construtor da sua classe você verifica se a variável for true você não constroe seu objeto …

Bem, é uma saída.

se vc estiver usando JInternalFrame´s chamados por um Menu, vc pode desabilitar o menu qdo clicar nele p/ abrir e soh habilitar de novo qdo fechar a janela…

falow

VALEU PESSOAL !!!
OBRIGADO PELA DICA !!!
:lol:

A questão do finalize() é interessante.

Porém, a especificação do JAVA não dá garantias do momento em que o método será executado.

Devemos, portanto, tomar cuidado com sua utilização pois podemos acabar caindo em armadilha… já pensou fechar a janela e a booleana estar em false ainda?!

Se for uma janela mesmo, achava melhor vc setar a variável no evento close dela… assim pelo menos vc tem certeza do que aconteceu com ela…

Deve haver outras saídas para o problema, se mais alguém souber gostaria de apreciar.

[]'s

:lol:

Por acaso vocês não teria nenhum exemplo de como este código ficaria?

Obrigado

E se usar singleton??? não sei se é adequado para o caso, e se estiver errado, me corrijam.

com singleton apenas uma instancia da sua classe é permitida em memória. Assim quando você precisa dela você chama o getInstance() e ele retorna a janela pra você. se ela estiver em memória, ele apenas a retora, se não ele a constrói. Espero ter ajudado… []'s

public class MinhaClasse {

    pirivate static MinhaClasse minhaclasse;

    static {
        minhaclasse = new MinhaClasse();
    }

    public MinhaClasse getInstance() {
        return minhaclasse;
    }
}

Todas essas alternativas falham se for usada mais de uma VM, ou seja, se cada janela for aberta utilizando uma máquina virtual diferente. Em minha opinião, a melhor alternativa nesse caso é abrir um socket quando a janela for aberta e fechá-lo quando ela for fechada. Então, ao abrir a janela você verifica se o socket já está aberto. Se estiver, não abra a janela.

Neste meu caso tenho a janela principal (principal) que nela é chamando outra janela (compras), quando está janela (compras) esta em aberta e o usuário for na janela (principal) e tentar abrir novamente a janela (compras) sem fechar o janela (compras) que foi aberta primeramente ela não poderá abrir.

Neste caso como devo proceder para abrir uma janela só, mesmo o usuário clicando varias vezes no menu para abrir a janela compras?

Já que é uma janela interna, creio que o que eu falei não seria necessário (apesar de ser uma solução válida). Você pode usar alguma das outras alternativas que foram propostas, se achar mais fácil. Nesses casos, qual a dificuldade que você está tendo?

Vamos lá,

Tenho a janela principal com o menu de cadastro e o sub-menu compras, quando o usuário clica no sub-menu compras abre a janela de cadastro compras ate ai tudo legal, se o o usuário não fechar a janela de cadastro compras e abrir outra janela de cadastro compras ele abre normamente e não deveria, só deveria abrir a janela quando a janela compras estiver fechada.

com o singleton, do jeito que falei, da´para fazer o que você quer. Apenas chame, em qualquer situação:

nomedaclasse.getInstance().setVisible(true);

se a janela estiver aberta, ou em memória, ele vai retornar a janela já aberta. se não, ele a abrirá. Estava com o mesmo problema que o seu. usei singleton e resolveu. apenas adicione aqueles métodos à classe, e quando for instanciá-la, nao ume mais MinhaClasse c - new MinhaClasse(), mas sim MinhaClasse.getInstance()
Com isso você recebe a instância já em memória desta classe.

Singleton é bastante usado em classes de conexão com um banco de dados, mas também me parece adequada para a ocasião.

Se tiver mais alguma dúvida, estamos aqui. []'s

crashy:

Vamos lá,

Tenho a janela principal com o menu de cadastro e o sub-menu compras, quando o usuário clica no sub-menu compras abre a janela de cadastro compras ate ai tudo legal, se o o usuário não fechar a janela de cadastro compras e abrir outra janela de cadastro compras ele abre normamente e não deveria, só deveria abrir a janela quando a janela compras estiver fechada.

Nao eh mais facil usar JInternalDialogs entao? ou o cara pode operar varias janelas internas ao mesmo tempo mas nao pode operar o mesmo tipo de janela? Singleton nela que eh mais comum acredito eu… quando criar o menu, cria as janelas escondidas e depois soh dah setVisible toda vez que chamar o item do menu… nao?

foi exatamente assim q eo fiz… e deu certo.
[]'s

(PS: problemas com os acentos desconsiderar…)

Amigo sem invecoes! ,

O problema no JAVA 'e que vc fica preso nas “regras” da linguagem e para contornar inventa moda e vai se prendendo e se enrolando cada vez mais…

Lhe aconselho a fazer o seguinte…

crie um arquivo tipo:

se esse arquivo existir bloqueia acesso a janela simples ;b

Eu não entendi a qual dos casos abaixo a sua dúvida se aplica, marceloatias:
1)Se a janela de “cadastro compras” estiver aberta e se o menu “cadastro compras” da tela de principal for clicado, então não deve ser aberta uma outra janela

2)Enquanto a janela de “cadastro de compras” estiver aberta, o usuário não consegue ter acesso à jenala principal

Qual desses se encaixa na sua dúvida?

Eu faria assim

public SuaClasse classe;


onde for instanciar a classe vc colocar

if(classe == null){
   classe = new SuaClasse()
}else{
   classe.show();
}

isso faz com q se a classe ja tenha sido instanciada so mostrara ela senao
instancia ela…

espero ter ajudado…

Muito interessante esse topico, a semiose tá rolando solta :D
Gostei da idéia de usar porta, nunca tinha pensado em usar isso!

Pelo q eu entendi qd o evento do button é disparado vc instancia um objeto da janela e dá setVisible(true) nele, daí se ficar apertando o button um monte de vez um monte de instâncias da janela vão ser abertas.

A solução mais simples q eu consigo imaginar é tirar a instanciação do objeto do evento do button, e colocar ele por exemplo no construtor da janela principal. Vc faria alguma coisa assim:

public void JanelaPrincipal extends JFrame{

private JanelaCompras compras;

...

public JanelaPrincipal(){

...

compras=new JanelaCompras();
compras.setDefaultCloseOperation(HIDE_ON_CLOSE);

...
}

Pronto, assim a janela compras vai ser instanciada junto com a janela principal (e vai ficar o tempo todo na memória!), e qd o evento do button for disparado vc só faz compras.setVisible(true) e tá resolvido.

O efeito prático é o mesmo do simpleton, com a diferença q o simpleton te dá garantia total q só uma instância do objeto vai tar na memória, no caso de algum outro lugar do código tentar instanciar o objeto tb.

Mas uma ressalva, o código do simpleton q o gfcittolin colocou tem uma falha. Ela naum define o construtor, daí ainda tem a possibilidade de em vez de usar o getInstance() usar o new pra fazer outra instância do objeto. O melhor seria fazer assim:

public class MinhaClasse {
 
     private static MinhaClasse minhaclasse;
 
     private MinhaCasse(){   //construtor private
     ...
     }
 
     public MinhaClasse getInstance() {
         if(minhaclasse==null) minhaclasse=new MinhaClasse();
	 return minhaclasse;
     }
 }

Eu uso um esquema desse tipo para controlar os dialogs:

private static ProgramaDialog programadialog = null;
(...)
if (programadialog == null){
    programadialog = new ProgramaDialog();
    desktopPane.add(programadialog, javax.swing.JLayeredPane.DEFAULT_LAYER);
    programadialog.setDefaultCloseOperation(HIDE_ON_CLOSE);
    programadialog.setVisible(true);
}else {
    programadialog.moveToFront();
    programadialog.show();
}