Pilha em Java

Pilha:

A forma mais geral de uma lista permite a inserção ou eliminação de um elemento em qualquer posição na lista. Se restringirmos a ocorrência de inserção e eliminação a uma extremidade da lista, por exemplo, extremidades superiores, então temos uma estrutura de dados chamada de pilha.

Utilizando a terminologia de pilhas, operações de inserção e eliminação são comumente citadas como operações “push” e “pop”, respectivamente. O único elemento diretamente acessível de uma pilha é seu elemento superior. O elemento menos acessível é seu elemento inferior.

Desde que as operações de inserção e eliminação são executadas na mesma extremidade da pilha (por exemplo, na extremidade superior), os elementos podem ser removidos somente na ordem oposta a que foram inseridos.

Este interessante fenômeno é conhecido como LIFO. LIFO é um acrônimo para a expressão inglesa Last In, First Out que, em português significa último a entrar, primeiro a sair.

Um exemplo comum de pilha, que permite a seleção de seu elemento superior, é a pilha de pratos num restaurante. Os pratos em pilha fazem com que a pessoa tenha acesso ao prato superior, à remoção de um prato superior faz com que a pessoa tenha acesso ao próximo prato, se colocado um novo prato na pilha, esse será o primeiro a sair.

Em Java, já existe a classe para o TAD pilha, que é a java.util.Stack.

Os métodos disponíveis nesta classe, entre outros, são: push(), pop(), equivalentes a empilha() e desempilha() e peek(), equivalente a topo(), tamanho() e vazia().

Os métodos pop() e peek() lançam a exceção StackEmptyException se a pilha estiver vazia quando eles são chamados.

• Outros métodos
  • size(): retorna o número de objetos da pilha
  • isEmpty(): retorna true se a pilha estiver vazia
  • top(): retorna, mas não remove, o objeto do topo da pilha, retornando um erro se a pilha estiver vazia

Exemplo simples:

Operação	Conteúdo da Pilha	Saida
Inserir X	X	-
Inserir Y	X Y	-
Inserir Z	X Y Z	-
Remover	X Y	Z
Inserir W	X Y W	-
Remover	X Y	W
Remover	X	Y
Remover		X
Remover		erro

Traduzindo a tabela em linguagem java.

import java.util.Stack;

/**

* Esta classe demonstra como funciona uma pilha em java

*

* @author Nico

*

* @since 20 MAIO, 2009

*

*/

public class TestarUmaStack {

public static void main(String[] args) {

// DECLARANDO NOSSOS ELEMENTOS/OBJETOS

String nico = “Nico”, kawano = “Kawano”, gaucho = “Gaucho”, erick = “Erick”, cris = “Cris”, junior = “Junior”, silvio = “Silvio”, jean = “Jean”;

// DECLARANDO A PILHA

Stack<String> nossaPilha = new Stack<String>();

// Passo 1: Incrementar Nico

nossaPilha.push(nico);

// Passo 2: Incrementar Kawano

nossaPilha.push(kawano);

// Passo 3: Incrementar Gaucho e Cris

nossaPilha.push(gaucho);

nossaPilha.push(cris);

// Passo 4: Decrementar elemento Cris do topo

nossaPilha.pop();

// Passo 5: Incrementar Erick

nossaPilha.push(erick);

// Passo 6: Incrementar Jean e Junior

nossaPilha.push(jean);

nossaPilha.push(junior);

// Passo 7: Substituir elemento na pilha. Jean por Silvio!

nossaPilha.set(4, silvio);

// EXIBINDO INFORMAÇÕES SOBRE A PILHA

if (nossaPilha.isEmpty()) {

System.out.println(“A PILHA ESTÁ VAZIA!”);

} else {

System.out

.println(“NOSSA PILHA DO GRUPO…\n\nElemento\tÍndice\n———————-”);

for (int i = nossaPilha.size() – 1; i > -1; i–) {

System.out.println(nossaPilha.get(i) + “\t\t” + i);

}

System.out.println(“\nNÚMERO DE ELEMENTOS: “ + nossaPilha.size());

System.out.println(“ELEMENTO NO TOPO: \”" + nossaPilha.peek()

+ “\” no índice “ + nossaPilha.indexOf(nossaPilha.peek()));

}

}

}

Resultado:

NOSSA PILHA DO GRUPO…

Elemento    Índice
———————-
Junior      5
Silvio       4
Erick        3
Gaucho   2
Kawano  1
Nico        0

NÚMERO DE ELEMENTOS:  6
ELEMENTO NO TOPO:  “Junior” no índice 5

Tratamento de exceções em Java

Hoje vou falar um pouquinho sobre o tratamento de exceções em Java, tambem do porque usar, sua estrutura e o que é uma exceção.

Como é comum no estudo do Java, ao chegar nesta parte e não conseguir visualizar a utilidade desse recurso e confundir os resultados com as instruções condicionais.

Conceito de Exceção

Exceção representa uma situação não esperada ocorrida na execução de algum trecho de programa.

Uma exceção deve ser vista como um retorno alternativo da execução de algum método.

O processo de gerar uma exceção é chamado de “lançamento de exceção” e o processo de processar uma exceção é chamado de “capturar a exceção”.

A exceção pode ser capturada por uma função dentro da seqüência de funções chamadas.

Agora veremos abaixo a estrutura de como tratar um erro ou exceção:

try - é usada para indicar um bloco de código que possa ocorrer uma exceção.

catch – serve para manipular as exceções, ou seja, tratar o erro

finally – sempre será executado depois do bloco try/catch. O importante é saber que esse bloco sempre será executado (exceto nos casos de encerramento da jvm System.exit()).

Veja abaixo as combinações válidas e inválidas para o uso do try{}, cacth{} e finally{} (isso é questão de certificação).

Combinações válidas:

try{}	catch{}
try{}	finally{}
try{}	catch{}	finally{}

Inválidas não Compila:

try{}	—	–
catch{}	finally{}	—
try{}	finally{}	catch{}

Tipos de Exceções em Java

Existem três tipos básicos de exceção em Java

Error

São exceções lançadas internamente pela Máquina Virtual na ocorrência de algum tipo de erro interno ou de falta de algum recurso.

Não se deve lançar nem tratar exceções desse tipo.

RuntimeException

São exceções lançadas devido algum erro do programa, como por exemplo, cast inválido, índice fora dos limites, acesso a referência nula de alguma classe.

Outras Exceções

São as exceções criadas para representar diversas situações. Podem ser as exceções criadas pelas bibliotecas ou exceções criadas pelo usuário.

Documentando as Exceções

A linguagem Java irá obrigar o programador a definir uma lista de exceções no cabeçalho do método quando ocorrer algumas das seguintes situações.

O método chama algum outro método que também possui em seu cabeçalho a indicação de lançamento de exceção e não faz o tratamento dessa exceção. O método lança uma exceção e não trata a mesma.

Sintaxe:

tipo_de_retorno nome ([params]) throws NomeExceção { ….. }

Capturando uma Exceção

Para capturar uma exceção devemos colocar o código passível de lançamento de exceção dentro de um bloco try. Para capturar a exceção devemos usar o catch.

Sintaxe:

try {

…. –> Código que pode lançar uma exceção

}

catch (tipo_exc e){

…. –> Código de tratamento

}

Lançando uma Exceção

Para lançar uma exceção deve-se usar o comando throw seguido de uma referência de uma classe de exceção.

Essa referência deve ter uma instância da classe de exceção a ser lançada.

Sintaxe:

retorno_do_método nome ([params]) throws

NomeExceção {

…..

if (cond_erro)

throw new IOException ();

….

}

Criando uma Classe de Exceção

Para criar uma nova classe de exceção de aplicação deve-se:

• Criar a classe herdando de alguma outra exceção existente ou da classe Exception.
• Criar um construtor sem parâmetros e um com um parâmetro do tipo String.
• No construtor do tipo String chamar o construtor da classe base, usando super, passando a string recebida.
• Podem-se colocar atributos e métodos adicionais na classe para definição melhor da exceção.

Métodos da Classe Throwable

A classe Throwable, classe base de todas as exceções do Java, possui os seguintes métodos:

• String getMessage( );

Retorna a descrição usada na criação da exceção.

• String toString( );

Retorna a descrição curta da exceção (nome/msg).

• void printStackTrace( );

Mostra todas as informações da pilha no momento da exceção.

• Throwable fillInStackTrace( );

Recoloca as informações na pilha da exceção.

Relançando uma Exceção

Uma vez capturada uma exceção, ela termina a função de indicar algum erro. Caso seja necessário que o tratamento continue em níveis superiores deve-se relançar a mesma através do comando throw colocado dentro do bloco catch.

O relançamento de uma exceção difere do lançamento no sentido de que não é criada uma nova instância e sim lançada a mesma instância da exceção capturada.

Sintaxe:

catch (tipo_exc e){

…. –> Código de tratamento

throw e; –> Relançando

}

Bloco finally

O bloco finally serve para indicar o código que será sempre executado em uma estrutura try…catch independente do caminho realizado por uma execução, normal ou exceção.

O bloco deve ser colocado após os blocos catch.

Pode-se colocar uma estrutura try com um bloco finnaly somente, sem o bloco catch.

Sintaxe:

finally {

…. –> Código a ser executado sempre

}

Exceções predefinidas do JAVA

Dentro do pacote-padrão java.lang Java define várias classes de exceção.  A maioria destas exceções são subclasses do tipo padrão RuntimeException. Desde que java.lang é implicitamente importada para todos os programas Java, a maioria das exceções derivadas de RuntimeException estão automaticamente disponíveis.

Então quando Usar Exceções !

Algumas sugestões sobre o uso de exceções:

• Não utilize exceções no lugar de testes simples. O tratamento de uma exceção custa muito em termos de processamento.
• Não faça o gerenciamento detalhado de exceção colocando cada comando que pode lançar uma exceção dentro de um bloco try/catch.
• Não descarte uma exceção, ou seja, não coloque um bloco catch vazio somente para evitar o erro de compilação.
• Não sinta constrangimento em não tratar todas as exceções que o seu código lançou. Trate somente as exceções cujo contorno você conhece.

Introdução ao Java.

Oi pessoal como vão?

Faz tempo que não posto nada aqui, ultimamente está corrido, muito trabalho e faculdade está puxada também.

Estava pensando hoje sobre o Java, já coloquei vários códigos que ensinei a mexer com partes gráficas GUI e mysql em Java, e achei interessante explicar sobre o início do Java e alguns detalhes internos interessantes.

 

Tópicos abordados

• O início e o histórico.
• Objetivo do projeto
• A linguagem java
• Ferramentas de desenvolvimento
• Plataforma java – apis
• Pacotes
• Ambiente java
• Referências bibliográficas
• Sites interessantes

 

O INÍCIO E O HISTÓRICO.

• 1991 – Patrick Naughton & James Gosling (emacs).
  • Sun Microsystem – pesquisa corporativa interna projeto de uma linguagem de programação de pequeno porte para dispositivos eletrônicos – projeto Green.
  • Linguagem Oak (carvalho)
  • Cafeteria – Java
• 1993 – World Wide Web.
• 1995 – Browser e Applets.
• 1996 – Netscape 2.0 e Java.
• 1997 – Java 1.02
• 1998 – Java 1.1
  • plataforma com 504 classes em 23 pacotes.
• 1999 – Java 1.2
  • plataforma com 1.520 classes em 59 pacotes – Java 2.
• 1999 – Java 1.3
  • correções e atualizações.

 

OBJETIVO DO PROJETO

• Simples
• Segura
• Portável
• Orientada a Objetos
• Robusta
• Multitarefa
• Neutra em relação à Arquitetura
• Interpretada
• Alto desempenho
• Distribuída
• Dinâmica

 

A LINGUAGEM JAVA

• Linguagem de Programação: linguagem na qual os aplicativos Java são escritos
• Um programa Java compilado é convertido a código de bytes que é a linguagem de máquina portável de uma arquitetura de CPU conhecida como Java Virtual Machine – JVM
• Java não é JavaScript.

 

FERRAMENTAS DE DESENVOLVIMENTO

• javac  Compilador
• java  Interpretador
• appletviewer  Visualizador para Applets
• javadoc  Gerador de Documentação
• jdb  Depurador
• jar  Compactador
• HtmlConverter  Gerador de arquivos HTML

 

PLATAFORMA JAVA – APIS

Conjunto de classes predefinidas que compreendem a Plataforma Java

• API – Application Programming Interface (Interface de Programação de Aplicativo)
• As classes são organizadas em grupos relacionados conhecidos como pacotes
• A plataforma Java define os pacotes por funcionalidades: entrada/saída, rede, gráficos, interface, segurança, etc.

 

PACOTES

Mecanismo de agrupar classes relacionadas

Alguns pacotes padrão da Java:

• java.applet: suporte para applet
• java.awt: suporte para E/S baseado em Windows
• java.io: suporte para E/S em console e em arquivo
• java.lang: suporte básico da linguagem
• java.math: suporte para funções matemáticas
• java.net: suporte para implementação de aplicações em rede
• java.text: suporte para tratamento de texto, datas, números e mensagens
• java.util: suporte para uma coleção de facilidades
• java.util.jar: suporte para formato de arquivo jar
• java.util.zip: suporte para formato de arquivo zip e gzip
• javax.swing: suporte para aplicativos gráficos

 

AMBIENTE JAVA

• Editor: programa fonte – gravado em disco em formato de texto
• Compilador: gera um código intermediário que o interpretador conhece: bytecode
• Carregador de classe: carrega os bytecodes para a memória
• Verificador de bytecode: confirma que todos os bytecode são válidos e não violam restrições de segurança de Java
• Interpretador: lê e executa os bytecodes

 

REFERÊNCIAS BIBLIOGRÁFICAS

• Core Java 2 Vol. I – Fundamentos
  • Cay S. Horstmann • Gary Cornell
• Core Java 2 Vol. II – Conceitos Avançados
  • Cay S. Horstmann • Gary Cornell
• Java 2 Como Programar
  • H. M. Deitel • P. J. Deitel
• Aprendendo Java
  • Patrick Niemeyer • Jonathan Knudsen
• Java O Guia Essencial
  • David Flanagan

 

SITES INTERESSANTES

• www.javasoft.com
  • Site Oficial, tutoriais, exemplos
• www.gamelan.com
  • Recursos Diversos
• www.bruceeckel.com
  • Livro Thinking in Java gratuito.
• www.informit.com
  • Livros gratuitos
• www.experts-exchange.com
  • Para tirar dúvidas

Como trabalhar com MySql em Java – PT 2.

Gravando dados no mysql utilizando uma interface gráfica em Java.

 Nessa segunda parte desse tutorial que mostrei como trabalhar com mysql e Java, irei mostrar como fazer cadastros no banco de dados, utilizando uma interface gráfica no Java.

 Atenção: É necessário você ter visto a parte 1 desse post pra você entender perfeitamente esse.

 Irei disponibilizar o código fonte desse post pra facilitar pra vocês. Uma coisa ruim que acho do wordpress é que não tem a opção pra postar códigos igual aos fóruns por ai. :\

 Separei a parte que faz a conexão com o banco de dados em uma classe só pra isso.

 Não irei me ater a parte de construir a interface gráfica agora, farei isso em outro post OK?

 Então vamos lá…

// Classe que conecta ao banco de dados. (ConectaBanco.java)

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException; 

/**
 * Classe que faz a conexão com o banco de dados
 * 
 * @author fernando Kawano
 * 
 * @since NOV 20, 2008.
 * 
 */
public class ConectaBanco {

             // Variável que indicará o caminho do driver.

            private static final String DRIVER = “org.gjt.mm.mysql.Driver”;

             // Nome da base de dados que criamos para o exemplo.

            private static final String BASE_DE_DADOS = “tideveloper”;

             // localhost indicando que estamos testando na nossa máquina local.

            private static final String IP = “localhost”;

             private static final String URL = “jdbc:mysql://” + IP + “/” + BASE_DE_DADOS;

             // Usuário do banco de dados (padrão do VertrigoServ)

            private static final String USUARIO = “root”;

             // Senha do banco de dados (padrão do VertrigoServ)

            private static final String SENHA = “vertrigo”;

             public static Connection conex() {

                         try {

                                    Class.forName(“org.gjt.mm.mysql.Driver”).newInstance();

                                    Connection conn = DriverManager.getConnection(URL, USUARIO, SENHA);

                                    return conn;

                         }

                         catch (SQLException ex) {

                                    System.out.println(“SQLException: “ + ex.getMessage());

                                    System.out.println(“SQLState: “ + ex.getSQLState());

                                    System.out.println(“VendorError: “ + ex.getErrorCode());

                                    return null;

                         }

                         catch (Exception e) {

                                    System.out.println(“Problemas ao tentar conectar com o banco de dados: “ + e);

                                    return null;

                         }

             }

 }

Pronto, a classe de conexão com o banco está pronta!

Como nós já criamos nosso banco e a tabela na parte 1 desse post vamos continuar uilizando elas…

Relembrando:

database: tideveloper

tabela: tbusuario 

 

// Classe que cria a interface gráfica. (TelaCadastro.java) 

import java.awt.FlowLayout;

import java.awt.GridLayout;

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.JPanel;

import javax.swing.JTextField;

import javax.swing.border.TitledBorder;

 

import java.sql.Connection;

import java.sql.PreparedStatement;

import java.sql.SQLException;

 /**

 * Programa que grava dados no mysql.

 *

 * @author fernando Kawano

 *

 * @since NOV 25, 2008.

 *

 */

 

public class TelaCadastro extends JFrame implements ActionListener {

 

     private JPanel painel;

     private JPanel painelBotoes;

      private JLabel labelNome;

     private JLabel labelIdade;

     private JLabel labelCidade;

 

     private static JTextField caixaTextoNome;

     private static JTextField caixaTextoIdade;

     private static JTextField caixaTextoCidade;

 

     private JButton botaoGravar;

 

     public TelaCadastro() {

         super(“Cadastrar Clientes”);

          painel = new JPanel();

          painel.setBorder(new TitledBorder(“Dados”));

          painel.setLayout(new GridLayout(6, 1, 0, 5));

          // NOME

          painel.add(labelNome = new JLabel(“Nome do cliente:”));

          caixaTextoNome = new JTextField(20);

          caixaTextoNome.addActionListener(this);

          painel.add(caixaTextoNome);

          // IDADE

          painel.add(labelIdade = new JLabel(“Idade:”));

          painel.add(caixaTextoIdade = new JTextField(3));

          caixaTextoIdade.addActionListener(this);

          painel.add(caixaTextoIdade);

          // CIDADE

          painel.add(labelCidade = new JLabel(“Cidade:”));

          painel.add(caixaTextoCidade = new JTextField(50));

          caixaTextoCidade.addActionListener(this);

          /**

         * PAINEL DOS BOTÕES (gravar)

         */

          painelBotoes = new JPanel();

          painelBotoes.setLayout(new FlowLayout());

          botaoGravar = new JButton(“Gravar”);

          botaoGravar.addActionListener(this);

          painelBotoes.add(botaoGravar);

          /**

         * Propriedades da janela

         */

          getContentPane();

          setLayout(new BorderLayout());

          add(painel, BorderLayout.NORTH);

          add(painelBotoes, BorderLayout.CENTER);

          setSize(400, 250);

          setLocation(180, 180);

          setVisible(true);

          setDefaultCloseOperation(EXIT_ON_CLOSE);

      }

      public static void cadCliente() {

          Connection conn = null;

          PreparedStatement pst = null;

          StringBuffer sql = new StringBuffer(“”);

          conn = ConectaBanco.conex();

          if (conn != null) {

               System.out.println(“Conexão efetuada com sucesso!”);

               try {

                    sql.append(“INSERT INTO tbusuario “).append(

                           “(v_nome, v_idade, v_cidade)”).append(” values “)

                           .append(” (?,?,?)”);

                    pst = conn.prepareStatement(sql.toString());

                    pst.setString(1, caixaTextoNome.getText());

                   pst.setString(2, caixaTextoIdade.getText());

                   pst.setString(3, caixaTextoCidade.getText());

                   pst.executeUpdate();

                    System.out.println(“Dados gravados com sucesso!!”);

               } catch (SQLException e) {

                    System.out.println(“Não foi desta vez.”);

               } finally {

                    try {

                         conn.close();

                    } catch (SQLException e) {

                         e.printStackTrace();

                    }

                    try {

                         pst.close();

                    } catch (SQLException e) {

                         e.printStackTrace();

                    }

                    System.out.println(“Fim…”);

               }

          } else {

               System.out.println(“Problemas!”);

          }

          caixaTextoNome.setText(“”);

         caixaTextoIdade.setText(“”);

         caixaTextoCidade.setText(“”);

      }

      // Ação no botão Gravar.

      public void actionPerformed(ActionEvent arg) {

          if (arg.getSource() == botaoGravar) {

               System.out.println(“Pressionado o botão Gravar.”);

               cadCliente();

          }

      }

      public static void main(String[] args) {

          // Chama a classe que cria a interface gráfica

         TelaCadastro tela = new TelaCadastro();

      }

 }

Agora é só compilar, preencher os campos e mandar gravar.

 

Note que o formulário apenas está sendo usado pra entrar com os dados não tendo nenhuma verificação de dados nos campos preenchidos.

 

Abordaremos esse tema num futuro próximo.

 

É isso pessoal, espero que consigam e entendam como foi feito, qualquer coisa é só deixar um comentário aqui no blog. OK?!

 

Código fonte do post aqui. 

Abraços a todos.

Montando um formulário em Java

Aqui estou eu de novo com mais um post sobre Java.

 

Vou ensinar a vocês como utiliza os componentes do Java, para montar um formulário “na unha”, com label, textfield, combobox, radiobutton e Button... Então simbora!

 

Seria bem interessante se você já ter conhecimento sobre os tipos de gerenciadores de layout do Java, ou ter visto um antigo post meu sobre o assunto.

 

Vou explicar o código por pedaços e depois irei disponibilizar o código fonte pra vocês.

 

// Estas 3 importações servem pro gerenciados de layout que utilizo no formulário
import java.awt.BorderLayout;
import java.awt.FlowLayout;
import java.awt.GridLayout;
 

// Importações responsáveis por fazer o click no botão funcionar.
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
 

// RadioButton, é aquele componente em que uma só opção é marcada.
import javax.swing.JRadioButton;
 

// ButtonGroup – É utilizado junto com o RadioButton, para definer os grupos de radio button.
import javax.swing.ButtonGroup;
 

// Button – Botão que utilizaremos pra “gravar” o conteúdo.
import javax.swing.JButton;
 

// ComboBox – Opção de menu que aparecem opções a serem escolhidas pelo usuário
import javax.swing.JComboBox;
 

// Necessário para a criação da janela.
import javax.swing.JFrame;
 

// Label – Tipo de caixa de texto que não pode ser editado.
import javax.swing.JLabel;
 

// TextField – Caixa de texto que pode ser digitado texto nela.
import javax.swing.JTextField;
 

// Panel – Servirá para adicionarmos os componentes.
import javax.swing.JPanel;
 

// TitledBorder – Serve pra colocarmos um “título” no panel.
import javax.swing.border.TitledBorder;
 

/**
 * Criando uma interface gráfica.
 * 
 * www.tideveloper.wordpress.com
 * 
 * @author Fernando Kawano
 * 
 * @since DEZ, 3, 2008.
 * 
 */
 

// Nosso formulário ficará assim:
  

 

public class InterfaceGrafica extends JFrame implements ActionListener {
 
// Criaremos dois painéis, um para o botão gravar e outro para o resto.
      private JPanel painel;
      private JPanel painelBotoes;
 
      // Estes serão os textos que utilizaremos no formulário.
      private JLabel labelNome;
      private JLabel labelIdade;
      private JLabel labelSexo;
      private JLabel labelMoradia;
      private JLabel labelCidade;
 
      // Caixas de texto que o usuário vai entrar com dados.
      private static JTextField caixaTextoNome;
      private static JTextField caixaTextoIdade;
      private static JTextField caixaTextoCidade;
 
      // Conteúdo das opçoes do ComboBox.
      private String textComboBox[] = { “Masculino”, “Feminino” };
 
      // O ComboBox
     private static JComboBox comboSexo;      // Opções do radioButton, Casa ou Apartamento.
      private static JRadioButton radioCasa, radioAp;
 

     // Faz com que uma só opção do grupo seja marcada.
      private ButtonGroup sexoGrupo;
 
      // Botão que sera usado pra “graver” os dados.
      private JButton botaoGravar;
 
            public InterfaceGrafica() {
 
            // Título que vai na Barra de título da janela.
            super(“Cadastrar Clientes”);
 
            // Criando o painel que receberá os componentes.
            painel = new JPanel();
 
            // Colocando um título no Painel.
            painel.setBorder(new TitledBorder(“Dados”));
 
            // Definindo o tipo de layout será usado no painel.
            // GridLayout, 11 linhas, 1 coluna
            painel.setLayout(new GridLayout(11, 1, 0, 5));
 

            // NOME
 

            // Criando labelNome, já passando uma String e adicionando-a no painel.
            painel.add(labelNome = new JLabel(“Nome do cliente:”));
 
            // Criando textField para ser digitado o nome.
            caixaTextoNome = new JTextField(20);
 
            // Adicionando a caixa de texto no painel
            painel.add(caixaTextoNome);
 
            // IDADE
 

            // Criando labelIdade, já passando uma String e adicionando-a no painel.
            painel.add(labelIdade = new JLabel(“Idade:”));
 
            // Criando textField para ser digitado o idade.
            painel.add(caixaTextoIdade = new JTextField(3));
 
            // Adicionando a caixa de texto no painel
            painel.add(caixaTextoIdade);
 
            // SEXO
 
            // Criando labelSexo, já passando uma String e adicionando-a no painel.
            painel.add(labelSexo = new JLabel(“Sexo:”));
 
            // Inicializnado e passando os valores do comboBox
            comboSexo = new JComboBox(textComboBox);
 
            // Adicionando o comboBox no painel
            painel.add(comboSexo);
  
            // COMPLEMENTO – casa, ap
 
// Criando labelComplemento, já passando uma String e adicionando-a no painel.
            painel.add(labelComplemento = new JLabel(“Complemento:”));
 
            // Criando o radiobutton Casa
            radioCasa = new JRadioButton(“Casa”, false);
 
            // Criando o radiobutton Apartamento
            radioAp = new JRadioButton(“Apartamento”, false);
 
            // Inicializando a variável ButtonGroup, ela é responsável por fazer somente uma
as 2 opções ficar marcadas
            complementoGrupo = new ButtonGroup();
 

            // Adicionando o radioButton Casa e AP no grupo

            complementoGrupo.add(radioCasa);

            complementoGrupo.add(radioAp);

 

            // Adicionando os 2 radioButtons no painel

            painel.add(radioCasa);

            painel.add(radioAp);

 

            // CIDADE
 
            // Criando labelCidade, já passando uma String e adicionando-a no painel.
            painel.add(labelCidade = new JLabel(“Cidade:”));
 
            // Criando textField para ser digitado o cidade e já adicionando no painel.
            painel.add(caixaTextoCidade = new JTextField(50));
 
            /**
             * PAINEL DOS BOTÕES (gravar)
             */

            // Inicializando o painel do botão
            painelBotoes = new JPanel();
 
            // Definindo o layout FlowLayout para o panel painelBotoes
            painelBotoes.setLayout(new FlowLayout());
 
            // Inicializando a variavel do botão e passando um texto para ele
            botaoGravar = new JButton(“Gravar”);
            // Faz com que o botão tenha ação de click
            botaoGravar.addActionListener(this);
 
            // Adiciona o botão no painelBotoes
            painelBotoes.add(botaoGravar);
 
            /**
             * Propriedades da janela
             */
 
            getContentPane();
 
            // Definindo o layout BorderLayout para a janela
            setLayout(new BorderLayout());
 
            // Adicionando o painel dos componentes na região NORTH.
            add(painel, BorderLayout.NORTH);
            // Adicionando o painelBotoes na região CENTER
            add(painelBotoes, BorderLayout.CENTER);
 
            // Tamanho que a janela irá ter.
            setSize(400, 430);

            // Posição que a janela irá aparecer
            setLocation(180, 180);
 
            // Deixando a janela visivel
            setVisible(true);
 
            // Caso a janela seja fechada, o programa para de executar.
            setDefaultCloseOperation(EXIT_ON_CLOSE);
 
      }
 
      // Ação no botão Gravar.
 
      public void actionPerformed(ActionEvent arg) {
 
            // Se pressionar o botão Gravar imprima os valores passados aos componentes.
            if (arg.getSource() == botaoGravar) {
 
                  System.out.println(“Pressionado o botão Gravar.\n”);
 
                  System.out.println(“DADOS\n”);
 
                  System.out.println(“\tNome: “ + caixaTextoNome.getText()); 
                  System.out.println(“\tIdade: “ + caixaTextoIdade.getText());
 
                  System.out.println(“\tSexo: “ + comboSexo.getSelectedItem());
 
                  System.out.println(“\t\tPosição do ítem no combo: “
                             + comboSexo.getSelectedIndex());
 
                  if (radioCasa.isSelected()) {
 
                        System.out.println(“\tComplemento: Casa”);
 
                  } else if (radioAp.isSelected()) {
 
                        System.out.println(“\tComplemento: Apartamento”);
 
                 } else {
 
                        System.out.println(“\tComplemento: Tipo indefinido”);
 
                  }
 
                  System.out
                             .println(“\tCidade: “ + caixaTextoCidade.getText() + “\n”);
 
            }

      }
 
      // MAIN
      public static void main(String[] args) {

             InterfaceGrafica tela = new InterfaceGrafica();
 

      }
 

}

 

Código fonte: aqui