Dúvida se o jeito que estou programando está correto

Programação Java
#1

Olá Meus queridos tudo bem?

Eu estou aprendendo a programar e gostaria de uma avaliação se o meu jeito de escrever códigos estão ok.

package telasSistema;

import java.awt.Color;
import java.awt.Font;
import java.awt.SystemColor;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JPanel;
import javax.swing.JTextField;
import javax.swing.border.EmptyBorder;

import bancoDados.InserirDados;
import cliente.Usuario;

public class PainelAdm {

	private JPanel painel = new JPanel();
	private JFrame janela = new JFrame("Painel Administrativo");
	private JMenuBar barraMenu = new JMenuBar();
	private JMenu menu = new JMenu("User");
	private JMenuItem itemInsert = new JMenuItem("Insert");
	private JMenuItem itemRemove = new JMenuItem("Remove");
	private JMenuItem itemUpdate = new JMenuItem("Update");
	private JMenuItem itemSearch = new JMenuItem("Search");

	public PainelAdm() {

		// Passa as configurações do painel
		painel.setBackground(new Color(225, 225, 225));
		painel.setBorder(new EmptyBorder(5, 5, 5, 5));
		painel.setLayout(null);

		// Configurações da janela
		janela.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		janela.setBackground(new Color(189, 183, 107));
		janela.setBounds(100, 100, 700, 400);
		janela.setResizable(false);
		janela.setContentPane(painel);
		janela.setLocationRelativeTo(null);

		// Configura a barra de menu
		this.configMenuBar(janela);

		// Adiciona o campo
		configFieldsToInsert();

		janela.setVisible(true);
	}

	// Configura os campos para inserir
	private void configFieldsToInsert() {

		// Cria o campo nome do usuário
		JLabel nome = this.creatLabel("Nome", 20, 8, 100, 15);
		JTextField nomeUsuario = campoTexto(20, 25, 100, 20);

		// Cria o campo cpf
		JLabel cpf = this.creatLabel("Cpf", 130, 8, 100, 15);
		JTextField cpfUsuario = campoTexto(130, 25, 100, 20);

		// Cria o campo de senha
		JLabel senha = this.creatLabel("Senha", 20, 53, 100, 15);
		JTextField senhaUsuario = campoTexto(20, 70, 100, 20);

		// Cria o campo de telefone
		JLabel telefone = this.creatLabel("Telefone", 130, 53, 100, 15);
		JTextField telefoneUsuario = campoTexto(130, 70, 100, 20);

		// Cria o campo Valor
		JLabel valor = this.creatLabel("Valor", 20, 96, 100, 15);
		JTextField valorUsuario = campoTexto(20, 113, 100, 20);

		// Cria o campo Data de Pagamento
		JLabel dataPagamento = this.creatLabel("Data Pagamento", 130, 96, 100, 15);
		JTextField dataPagamentoUsuario = campoTexto(130, 113, 100, 20);

		// Cria o campo Status
		JLabel status = this.creatLabel("Status", 20, 138, 100, 15);
		JTextField statusUsuario = campoTexto(20, 155, 100, 20);

		// Cria o campo Plano
		JLabel plano = this.creatLabel("Plano", 130, 138, 100, 15);
		JTextField planoUsuario = campoTexto(130, 155, 100, 20);

		// Cria o botão
		JButton botaoInserir = configBotao("Inserir", 155, 190, 75, 20);

		// Cria uma label de status
		JLabel statusSistema = this.creatLabel("", 20, 230, 700, 15);

		// Cria a ação do botão
		botaoInserir.addActionListener(new ActionListener() {

			@Override
			public void actionPerformed(ActionEvent e) {

				// Verifica se todos os campos estão preenchidos
				if (VerificarCampoVazio(nomeUsuario) && VerificarCampoVazio(cpfUsuario)
						&& VerificarCampoVazio(senhaUsuario) && VerificarCampoVazio(telefoneUsuario)
						&& VerificarCampoVazio(valorUsuario) && VerificarCampoVazio(dataPagamentoUsuario)
						&& VerificarCampoVazio(statusUsuario) && VerificarCampoVazio(planoUsuario)) {
					
					// Cria o usuário
					Usuario user = new Usuario();
					user.setNome(nomeUsuario.getText());
					user.setCpf(cpfUsuario.getText());
					user.setSenha(senhaUsuario.getText());
					user.setTelefone(telefoneUsuario.getText());
					user.setValor(Double.valueOf(valorUsuario.getText()));
					user.setDataPagamento(dataPagamentoUsuario.getText());
					user.setStatus(statusUsuario.getText());
					user.setPlano(planoUsuario.getText());
					
					// Faz o insert no banco de dados
					InserirDados inserir = new InserirDados();
					inserir.Inserir(user);

					statusSistema.setText("Dados gravados.");
				} else {
					statusSistema.setText("Preencha todos os campos.");
				}

			}
		});

	}

	// Verifica se o campo está vazio
	private boolean VerificarCampoVazio(JTextField campo) {

		boolean confirmar = false;

		// Faz as validações para inserir o usuário no banco de dados
		if (campo.getText().equals("")) {
			return confirmar;
		} else {
			confirmar = true;
			return confirmar;
		}

	}

	private JButton configBotao(String name, int x, int y, int l, int a) {

		// Cria o botao
		JButton botao = new JButton(name);
		botao.setFont(new Font("Verdana", Font.ITALIC, 11));
		botao.setForeground(SystemColor.desktop);
		botao.setBounds(x, y, l, a);
		this.painel.add(botao);

		return botao;
	}

	// Cria e configura os labels
	private JLabel creatLabel(String name, int x, int y, int l, int a) {

		// Cria a label
		JLabel label = new JLabel(name);

		// Adiciona os Labels na tela configurados
		label.setFont(new Font("Verdana", Font.ITALIC, 12));
		label.setForeground(SystemColor.desktop);
		label.setBounds(x, y, l, a);
		this.painel.add(label);

		// Retorna a label
		return label;
	}

	// Criar Texto box configurada
	private JTextField campoTexto(int x, int y, int l, int a) {

		// Cria o campo
		JTextField campo = new JTextField();

		// Configura o campo
		campo.setFont(new Font("Verdana", Font.ITALIC, 10));
		campo.setForeground(SystemColor.desktop);
		campo.setBounds(x, y, l, a);
		campo.setColumns(10);
		this.painel.add(campo);

		// Retorna um campo de texto previamente configurado
		return campo;
	}

	// Configura a barra de menu
	private void configMenuBar(JFrame janela) {

		// Muda acorde fundo da barra de menu
		barraMenu.setBackground(new Color(220, 220, 220));

		// Adiciona a barra de menu
		janela.setJMenuBar(barraMenu);

		// Adiciona a cor de fundo do menu
		this.configMenu(menu);

		// Adiciona os itens dentro do menu
		this.configMenuItem(itemInsert);
		this.configMenuItem(itemRemove);
		this.configMenuItem(itemUpdate);
		this.configMenuItem(itemSearch);

	}

	// Configura o menu
	private void configMenu(JMenu menu) {

		menu.setFont(new Font("Verdana", Font.ITALIC, 12));
		menu.setForeground(SystemColor.desktop);
		this.barraMenu.add(menu);

	}

	// Configura item do menu
	private void configMenuItem(JMenuItem item) {

		item.setBackground(new Color(220, 220, 220));
		item.setFont(new Font("Verdana", Font.ITALIC, 10));
		item.setForeground(SystemColor.desktop);

		// Adiciona o item no menu
		menu.add(item);

	}
}
#2

Essa é dificil heim.
Programar é meio abstrato, pois existem n maneiras de fazer a mesma coisa, logo não é possivel afirmar se esta certo ou errado, ou mesmo opinar sobre seu codigo. ( se seguidas as boas praticas, claro.).

#3

Achei seu código bem organizado. Pra mim, está muito bom.

Se vc quiser tentar, vc pode tentar dividir “código de tela” do código das funcionalidades que a tela apresenta, ex.: PainelAdministrativoUI e PainelAdministrativoController.

A UI teria apenas os elementos visuais e a controller ficaria responsável por executar as ações da tela recuperando os dados da mesma. Isso seria uma forma de implementar diferente para vc ver sua implementação com uma abordagem diferente (não significa que a forma como vc fez está errado, mas apenas uma forma diferente de abordar um mesmo problema).

Dessa forma, toda validação e execução das ações seriam invocadas na controller, veja:

PainelAdministrativoUI

public class PainelAdministrativoUI {

  private final PainelAdministrativoController controller = new PainelAdministrativoController(this);

  // código

  botaoInserir.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
      controller.inserir();
    }
  });

  // resto do código
}

PainelAdministrativoController

public class PainelAdministrativoController {

  private final PainelAdministrativoUI ui;

  // Construtor
  public PainelAdministrativoController(PainelAdministrativoUI ui) {
    this.ui = ui;
  }

  public void inserir() {
    // Verifica se todos os campos estão preenchidos
    if (VerificarCampoVazio(nomeUsuario) && VerificarCampoVazio(cpfUsuario)
      && VerificarCampoVazio(senhaUsuario) && VerificarCampoVazio(telefoneUsuario)
      && VerificarCampoVazio(valorUsuario) && VerificarCampoVazio(dataPagamentoUsuario)
      && VerificarCampoVazio(statusUsuario) && VerificarCampoVazio(planoUsuario)
    ) {
      Usuario user = new Usuario();
      user.setNome(ui.nomeUsuario.getText());
      user.setCpf(ui.cpfUsuario.getText());
      user.setSenha(ui.senhaUsuario.getText());
      user.setTelefone(ui.telefoneUsuario.getText());
      user.setValor(Double.valueOf(ui.valorUsuario.getText()));
      user.setDataPagamento(ui.dataPagamentoUsuario.getText());
      user.setStatus(ui.statusUsuario.getText());
      user.setPlano(ui.planoUsuario.getText());
            
      // Faz o insert no banco de dados
      InserirDados inserir = new InserirDados();
      inserir.Inserir(user);

      ui.showMessage("Dados gravados.");
    } else {
      ui.showMessage("Preencha todos os campos.");
    }
  }
}

Repare que a captura dos dados e validações foram para o controller, e a apresentação da mensagem na tela virou o método showMessage que ficaria na UI.

É apenas uma ideia, o código que fiz com certeza pode ser melhorado.

De qualquer forma, achei seu código bom e só quis tentar apresentar uma outra forma de fazer para vc ver que dá para separar as responsabilidades, deixando o código menor e provavelmente mais limpo.

Uma boa prática no swing é usar gerenciadores de layout para organizar os componentes na tela: Conhecendo Gerenciadores de Layout GUI do Java