Regras ou convenção ao utilizar interface gráfica [ Resolvido ]

Tbem estou interessado em saber se existe alguma convenção, geralmente uso Singletons para comunicaçoes entre as telas e o controle da aplicação.
Sobre Layout, fazer um é simples mas trabalhoso
O exemplo abaixo é um Layout q empilha os components(invertido) parecido com o FlowLayout mas na vertical

import java.awt.Component;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Insets;
import java.awt.LayoutManager;

public class LayoutPilha implements LayoutManager {

    private int gap;

    public LayoutPilha(int gap) {
        this.gap = gap;
    }

    public LayoutPilha() {
        this(0);
    }

    @Override
    public void addLayoutComponent(String name, Component comp) {
    }

    @Override
    public void removeLayoutComponent(Component comp) {
    }

    @Override
    public Dimension preferredLayoutSize(Container parent) {
        synchronized (parent.getTreeLock()) {
            Insets i = parent.getInsets();
            int w = 0;
            int h = 0;
            Component[] cs = parent.getComponents();

            for (Component c : cs) {
                w = Math.max(w, c.getPreferredSize().width);
                h += c.getPreferredSize().height;
            }
            
            int v = gap * (cs.length - 1);
            if (v < 0) v = 0;
            
            w += i.left + i.right;
            h += i.top + i.bottom + v;
            return new Dimension(w, h);
        }
    }

    @Override
    public Dimension minimumLayoutSize(Container parent) {
        synchronized (parent.getTreeLock()) {
            Insets i = parent.getInsets();
            int w = 0;
            int h = 0;
            Component[] cs = parent.getComponents();

            for (Component c : cs) {
                w = Math.max(w, c.getMinimumSize().width);
                h += c.getMinimumSize().height;
            }
            
            int v = gap * (cs.length - 1);
            if (v < 0) v = 0;
            
            w += i.left + i.right;
            h += i.top + i.bottom + v;
            return new Dimension(w, h);
        }
    }

    @Override
    public void layoutContainer(Container parent) {
        synchronized (parent.getTreeLock()) {
            Insets i = parent.getInsets();
            int w = parent.getWidth() - i.left - i.right;
            int h = parent.getHeight() - i.top - i.bottom;
            int x = i.left;
            int y = i.top;
            Component[] cs = parent.getComponents();

            for (Component c : cs) {
                if (y < h) {
                    c.setBounds(x, y, w, c.getPreferredSize().height);
                    c.setVisible(true);
                    y += c.getPreferredSize().height;
                    y += gap;
                } else {
                    c.setVisible(false);
                }
            }
        }
    }
}

o “layoutContainer” é q organiza e posiciona os components
Insets seria a borda do Container

sim existem algumas regras que são RECOMENDADAS para que a interface possa ser usual, intuitiva, ágil etc. Procure pelo assunto interface-homem maquina.
Há muitas regras para sistemas web, já sistemas desktop é bem mais tranquilo.

att.

Do ponto de vista técnico: http://www.guj.com.br/java/104644-novo-em-swing#565211

ChronosSage,
já estou estudando sobre os gerenciadores de layout.

hvivox,
Sim, para web existem várias regras porém para desktop eu desconheço. O que você quis dizer com "é bem mais tranquilo. "? Que não é preciso se preocupar com isso?

ViniGodoy,
Obrigado pelo link, era um material desta forma que eu estava procurando.

Agora vai algumas perguntas, se puderem me ajudar a entender melhor…

Há como exibir uma janela sem utilizar o método setVisible ?

Quer dizer que se eu precisar chamar uma nova janela, eu devo enviar os dados através de um construtor? Seria essa a única opção?

Ao utilizar gerenciador de layout, eu escolho ser o mais apropriado para minha aplicação ou um layout A serve somente para uma aplicação do tipo A?

Obrigado pela ajuda.

Existe o método show(), mas está deprecated. Portanto, o meio oficial é só o serVisible mesmo. Para que você queria outro método?

Não, é a geralmente a melhor opção.
Outras opções são através de métodos setters, ou fazer com que sua janela escute eventos de outras.

E claro, há sempre a opção gambi de variáveis estáticas, mas essa gera tantos problemas que não deveria nem ser considerada (embora seja relativamente popular nos códigos dos iniciantes do GUJ).

Na verdade, você usa uma combinação de gerenciadores de layout para chegar na tela desejada.

Por exemplo, você pode começar com um BorderLayout para dividir a tela nas 5 áreas. Na área sul você coloca um painel com FlowLayout para conter botões (salvar, fechar, etc). Na área CENTER você coloca um GridBagLayout, para conter alguns componentes. E na área EAST você poderia colocar um GridLayout com uma JTree e um JTable de propriedades.

Usar paineis sobre paineis, cada um com seu próprio layout manager é uma maneira bastante efetiva de se conseguir o layout final desejado. Mas não crie layouts que dependam de posições exatas de componentes, pixel-a-pixel. Isso não só não é portável, como será muito difícil de fazer, e dificilmente tornará as janelas redimensionáveis.

Sobre a alternativa ao setVisible, é só para conhecimento mesmo, sempre procuro as várias formas que posso fazer algo.
Então irei testar com construtores já que é a melhor opção, detesto código feio e POG.
E acho que já comecei interpretando o gerenciamento de layout de forma errônea ou incompleta, achei que para cada janela só poderia ser utilizado um. Então eu posso utilizar vários tipos para cada painel que eu utilizar, vamos dizer.

Obrigado pelo esclarecimento das minhas dúvidas. Caso alguém tenha algo para complementar o tópico, fique a vontade, irei colocar como resolvido.