• Edição de arquivos em abas
• Salvar documentos
• Copiar texto através de um menu
• Colar texto através de um menu
• Mostrar uma caixinha de "Sobre o Editor"

É possível que conforme eu vá mexendo no editor e aprendendo truques novos eu adicione coisas novas.
Nessa primeira parte do tutorial irei mostrar os seguintes conceitos:

• Como criar uma janela com Swing
• Como adicionar componentes a janela
• Como criar um menu para a janela
• Como tratar eventos no seu menu
• Como criar um painel com abas

Wow! Não imaginei que eram tantos assuntos hehehe. Bom, a intenção aqui é de ser mais um guia e não uma referência completa. Conforme discuto cada assunto, colocarei informações básicas e links apontando para lugares onde pode-se obter maiores informações (basicamente para a Javadoc).
Tendo escrito tanto, hora de ir para a parte interessante da coisa... a programação!

Como criar uma janela com Swing
Rapidamente antes de começar, preciso dizer uma coisinha. Eu estou assumindo que você, leitor, tem ao menos um leve conhecimento de Java (sintaxe e um pouquinho de nada de orientação a objetos). Caso não tenha, pode seguir em frente, mas recomendo ler algum material falando um pouco sobre a linguagem.

import javax.swing.JFrame;
 
public class JanelaSimples extends JFrame {
 
	public JanelaSimples() {
		this.setTitle("Minha primeira janela");
		this.setSize(640,480);
		this.setVisible(true);
		this.setDefaultCloseOperation(EXIT_ON_CLOSE);
	}
 
	public static void main(String[] args) {
		new JanelaSimples();
	}
}

[JanelaSimples.java]

Para compilar:
javac JanelaSimples.java

Para executar:
java JanelaSimples

Não coloque a extensão .class ou .java quando for executar a aplicação pois não irá funcionar.

Deu pra ver que é uma janela bastante útil. Você consegue redimensionar, fechar e... e é isso :)
Mesmo não servindo para muita coisa já deu um gostinho, então vamos as partes desse programa.

	public class JanelaSimples extends JFrame {

Aqui estamos criando a nossa classe JanelaSimples e herdando toda a funcionalidade de JFrame, que é a classe responsável pelos métodos que criam a nossa janela.

	public JanelaSimples() {
		this.setTitle("Minha primeira janela");
		this.setSize(640,480);
		this.setVisible(true);
		this.setDefaultCloseOperation(EXIT_ON_CLOSE);
	}

Em primeiro lugar, todas os métodos que estão sendo invocados foram herdados da classe JFrame, e é por isso que eu os chamo com 'this.'.
O que estes métodos estão fazendo? Na respectiva sequencia:
Definindo o titulo da janela para "Minha primeira janela"
Definindo o tamanho da janela para 640x480
Definindo que a janela deve ser exibida
Definindo que a operação padrão para quando você fechar a janela é a de que o programa deve terminar

Tudo muito simples.

	public static void main(String[] args) {
		new JanelaSimples();
	}

Como esse é o nosso programa principal ele precisa de uma função main que serve de ponto de entrada para ele. Nossa função main simplesmente instancia a classe JanelaSimples. Quando a instancia é criada, o construtor (explicado logo acima) é chamado e a nossa janela se faz visível.

Como adicionar componentes a janela

Agora que já sabemos criar a janela, vamos adicionar uma caixa de texto a ela. Para isso, usaremos o mesmo código da JanelaSimples.java e adicionaremos alguns comandos no construtor da classe. O construtora ficará da seguinte maneira:

import javax.swing.JFrame;
import javax.swing.JTextPane;
 
public class JanelaSimples extends JFrame {
 
	public JanelaSimples() {
		JTextPane texto = new JTextPane();
 
		this.setTitle("Minha primeira janela");
		this.setSize(640,480);
		this.add(texto);
		this.setVisible(true);
		this.setDefaultCloseOperation(EXIT_ON_CLOSE);
	}
 
	public static void main(String[] args) {
		new JanelaSimples();
	}
}

[JanelaSimples-2.java]

Se quiser compilar este exemplo, renomeie o arquivo para JanelaSimples.java e use as instruções fornecidas acima.
Daqui pra frente eu evitarei re-escrever todo o código o tempo todo e colarei apenas as novas partes que foram adicionadas. Para acessar o código todo, por favor use os arquivos que estão linkados em cada seção :)
Este novo código não mudou muito. As novidades aqui são:

import javax.swing.JTextPane;
...
		JTextPane texto = new JTextPane();
		...
		this.add(texto);

Adicionei o import referente a classe JTextPane que nos fornece uma caixa de texto. Dentro do construtor eu simplesmente crio uma instancia da class JTextPane e adiciono essa instancia a minha janela. O método 'add()' também foi herdado de JFrame.
Você vai perceber que o componente está usando a janela toda. Isso pode ser mudado, e será discutido quando estivermos falando de layouts da janela.
Todo componente que você desejar criar, basta instancia-lo e então adiciona-lo a janela utilizando o método 'add()'.
Se você deseja maiores informações sobre os métodos que a classe JFrame implementa e seus respectivos protótipos, de uma olhada na documentação do JFrame

Como criar um menu para a janela

Até então tudo muito interessante. Vamos adicionar um pouco de emoção agora e criar um menu para a nossa linda janela que não faz muita coisa.

import javax.swing.JFrame;
import javax.swing.JTextPane;
import javax.swing.JMenuBar;
import javax.swing.JMenu;
import javax.swing.JMenuItem;
...
 
	public JanelaSimples() {
		JMenuBar barra = new JMenuBar();
		JMenu menuArquivo = new JMenu("Arquivo");
		JMenuItem arqSair = new JMenuItem("Sair");
 
		menuArquivo.add(arqSair);
		barra.add(menuArquivo);
		this.setJMenuBar(barra);
		...
	}
 
}

[JanelaSimples-3.java]

E o nosso programa está crescendo!
Só para esclarecer; um menu é feito de basicamente três partes:
A barra de menus
Os menus
Os items dos menus
Como pode-se perceber nós adicionamos três novos imports em nosso código que se referem a cada um desses items. Em nosso construtor então nós instanciamos uma barra de menu (JMenuBar), instanciamos um menu (JMenu) e finalmente instanciamos um item para o menu (JMenuItem). Depois de cada um dos items instanciados e configurados conforme desejamos, basta associa-los conforme feito no código.
Adicionamos o item 'arqSair' dentro do menu 'menuArquivo'. Adicionamos o menu 'menuArquivo' a barra de menu 'barra' e por fim chamamos o método setJMenuBar para adicionar o menu a nossa janela.
Para adicionar o menu nós utilizamos o método especial setJMenuBar pois ele já configura o nosso menu para ser mostrado da maneira esperada no topo da janela.

Como tratar eventos no seu menu

Eu estou achando esse programa cada vez mais empolgante! :D (espero que vocês também)
Como deu pra notar, o nosso menu 'Sair' não faz absolutamente nada :(
Iremos abordar agora um tipo simples de evento, e falar um pouquinho sobre alguns tipos de eventos que existem. Ao longo dos próximos tutoriais de como criar o nosso editor de texto iremos falando mais sobre esse assunto e explorando novos eventos.
Vamos então colocar uma funcionalidade nesse item 'Sair' para que ele faça aquilo que ele promete :)

...
 
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
 
...
 
		JMenuItem arqSair = new JMenuItem("Sair");
 
		arqSair.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				System.exit(0);
			}
		});
 
		menuArquivo.add(arqSair);
		barra.add(menuArquivo);
		this.setJMenuBar(barra);
 
...

[JanelaSimples-4.java]

Mais dois imports para nos auxiliar e um trecho de código um tanto quanto diferente. Deixe-me falar um pouco sobre eventos e listeners e especialmente sobre o ActionListener e o ActionEvent.
Eventos, como o nome sugere, são coisas que acontecem ao seu programa. Quando o usuário interage com o programa ao clicar em algo, digitar algo, movimentar o mouse ou coisas do genêro, um evento está acontecendo. O nosso programa sabe desses eventos através do chamamos de Listeners.
Os Listeners ficam 'ouvindo' o programa por eventos que aconteçam. Quando um evento acontece, o Listener invoca o método associado ao tipo de evento.
O ActionListener é um Listener para os eventos mais comums, como um clique ou como quando o usuário pressiona Enter ou Space. O evento que é lido por um ActionListener é um ActionEvent. Quando você tem um item em seu menu e clica com o botão direito ou esquerdo nele você gerou um ActionEvent. Se voce selectionar o menu e apertar Enter, você gerou um ActionEvent nele.
Possuindo essa noção de Listener e Event, vamos reanalizar o código acima.

	arqSair.addActionListener(new ActionListener() {
		public void actionPerformed(ActionEvent e) {
			System.exit(0);
		}
	});

O componente JMenuItem possui um método que nos permite associar a instancia de uma classe que trata eventos do tipo ActionEvent ao seu ActionListener.
Sempre que um ActionEvent acontecer o método 'actionPerformed' dessa instancia será chamado para tratar do evento.
No nosso caso, para não precisarmos escrever toda uma classe para isso, nós criamos uma instancia anonima de ActionListener explicitando o nosso método actionPerfomed. Quando a ação ocorrer, esse método será executado e em nosso caso irá fazer com que a aplicação encerre.
O parametro que o método recebe contém informações sobre o evento, tais como: De onde veio o evento, quando o evento aconteceu, quais teclas estavam pressionadas quando o evento occoreu e etc... Para maiores informações sobre o que se pode tirar do ActionEvent, acesse esse link
Com isso, encerramos a breve introdução a eventos. Se ficaram algumas dúvidas, não se preocupe pois iremos falar mais sobre eles no futuro.

Como criar um painel com abas

Nosso editor de texto já está ganhando forma e agora é hora de dar a ele a primeira funcionalidade prometida: Abas!
Vamos criar então um painel de abas onde cada aba será uma caixa de texto diferente para escrevermos.

import javax.swing.JFrame;
import javax.swing.JTextPane;
import javax.swing.JMenuBar;
import javax.swing.JMenu;
import javax.swing.JMenuItem;
 
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
 
// JTabbedPane para nosso painel de abas!
import javax.swing.JTabbedPane;
 
public class JanelaSimples extends JFrame {
 
	public JanelaSimples() {
		JMenuBar barra = new JMenuBar();
		JMenu menuArquivo = new JMenu("Arquivo");
		JMenuItem arqSair = new JMenuItem("Sair");
 
		arqSair.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				System.exit(0);
			}
		});
 
		menuArquivo.add(arqSair);
		barra.add(menuArquivo);
		this.setJMenuBar(barra);
 
		JTextPane texto = new JTextPane();
 
		this.setTitle("Minha primeira janela");
		this.setSize(640,480);
 
		/**
		 * A caixa de texto não é mais adicionada a janela
		 * e sim ao painel de abas
		 */
		//this.add(texto); <--- comentado!
 
		this.setDefaultCloseOperation(EXIT_ON_CLOSE);
 
		/**
		 * Criar o painel e adiciona-lo a janela
		 */
		JTabbedPane painel = new JTabbedPane();
		painel.addTab("Aba 1", texto);
		this.add(painel);
 
		this.setVisible(true);
 
	}
 
	public static void main(String[] args) {
		new JanelaSimples();
	}
}

[JanelaSimples-5.java]

Coloquei o código completo para não nos perdermos. As partes novas estão comentadas para serem mais facilmente identificadas.

...
 
		//this.add(texto); <--- comentado!
 
		...
 
		/**
		 * Criar o painel e adiciona-lo a janela
		 */
		JTabbedPane painel = new JTabbedPane();
		painel.addTab("Aba 1", texto);
		this.add(painel);
		...

Até aqui, bastante simples. Criamos um JTabbedPane, que é o nosso painel com abas e adicionamos uma aba com o título "Aba 1" e o componente que ela irá exibir é a nossa caixa de texto. Adicionamos então o painel a janela. Vejam que comentei a linha que adicionava a caixa de texto a janela já que agora a caixa de texto faz parte do painel de abas.

Próximo episódio

Bem pessoal, por hoje é só :)
Na próxima parte iremos abordar os seguintes temas:

• Criação do menu 'Novo'
• Criação do menu 'Salvar'
• Criação do menu 'Salvar Como'
• Criação do menu 'Sobre'

Talvez eu aborde mais coisas, mas não sei ainda.
Até a próxima :)

Aqui estou de novo tentando voltar a postar hehehe. Hoje vou mostrar um exemplo simples de classe em Java para se conectar ao MySQL, para que mais pra frente eu possa mostrar algumas coisas bacanas para se fazer com JSP + TagLibs + MySQL + Servlets :) (Não sou grande fã de usar frameworks quando ainda não conheço bem a linguagem).
Bom, chega de lenga lenga, e vamos ao que interessa :D

Para poder brincar você vai precisar do MyConnector/J instalado. Ele pode ser obtido em: http://dev.mysql.com/downloads/connector/j/5.1.html!
Ao baixar o Connector/J você encontrará dentro do .zip (ou do .tar.gz) um arquivo com o nome parecido com: mysql-connector-java-5.1.5-bin.jar. Certifique-se que você adicionará esse arquivo ao seu CLASSPATH pois ele será necessário para que os exemplos que usaremos funcionem.

Agora vamos criar um banco de dados simples para utilizarmos nos nossos exemplos:

CREATE DATABASE projeto;
USE projeto;
CREATE TABLE usuario (
   id_usuario INT NOT NULL PRIMARY KEY AUTO_INCREMENT
   ,nome VARCHAR(100)
   ,idade INT(3)
);

E aqui inserimos alguns dados, para podermos consulta-los.

INSERT INTO usuario (
   nome
   ,idade
) VALUES (
   "Henrique"
   ,22
);
 
INSERT INTO usuario (
   nome
   ,idade
) VALUES (
   "José"
   ,35
);
 
INSERT INTO usuario (
   nome
   ,idade
) VALUES (
   "Andreia"
   ,21
);

Vou começar com uma classe bem simples, que simplesmente se conecta ao MySQL, e ao longo do texto vamos incrementa-la para que faça mais coisas. Vamos então a primeira classe:

package com.heap.db;
 
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Connection;
 
public class MySQL {
 
    private String host;
    private String user;
    private String pass;
    private String database;
 
    public Connection c;
 
    /**
     * Construtor da classe
     *
     * @param host Host em que se deseja conectar
     * @param database Nome do database em que se deseja conectar
     * @param user Nome do usuário
     * @param pass Senha do usuário
     */
    public MySQL( String host, String database, String user, String pass ) {
        this.pass = pass;
        this.user = user;
        this.host = host;
        this.database = database;
    }
 
    /**
     * Método que estabelece a conexão com o banco de dados
     *
     * @return True se conseguir conectar, falso em caso contrário.
     */
    public boolean connect() {
        boolean isConnected = false;
        String url;
 
        url = "jdbc:mysql://"+this.host+"/"
              +this.database+"?"
              +"user="+this.user
              +"&password="+this.pass;
 
        try {
            Class.forName("com.mysql.jdbc.Driver").newInstance();
            System.out.println(url);
            this.c = DriverManager.getConnection(url);
            isConnected = true;
        } catch( SQLException e ) {
            e.printStackTrace();
            System.out.println(e.getMessage());
            isConnected = false;
        } catch ( ClassNotFoundException e ) {
            e.printStackTrace();
            System.out.println(e.getMessage());
            isConnected = false;
        } catch ( InstantiationException e ) {
            e.printStackTrace();
            System.out.println(e.getMessage());
            isConnected = false;
        } catch ( IllegalAccessException e ) {
            e.printStackTrace();
            System.out.println(e.getMessage());
            isConnected = false;
        }
 
        return isConnected;
    }
}

Código bastante simples como podemos perceber. A primeira linha indica que essa classe pertence ao pacote com.heap.db. É importante ressaltar isso, porque teremos de importar esse código para dentro da nossa classe que será o nosso programa de verdade, que chamará o método de conexão. Perceba também que no código eu não faço nenhum tratamento especial para as exceptions, apenos imprimo o erro. Essa não é uma técnica muito bacana, pois podemos perder informações. Eu gost de criar uma outra classe que faça o handle das exceptions e salve os erros em algum lugar, para que eu possa consulta-los se ncessário, mas em nosso caso aqui é o bastante apenas imprimi-las.

import com.heap.db.MySQL;
 
public class TesteDB {
 
    public static void main (String [] args) {
        MySQL db = new MySQL("localhost","projeto","root","12345");
        if ( db.connect() ) {
          System.out.println("Conectado!");
        };
      }
 
}

Logo na primeira linha desse código é feito o import da classe que se conecta ao MySQL. No método main() criamos uma instancia da classe MySQL com os parametros para especificar onde estamos conectando, e logo na sequência chamamos o método para conectar.
Agora é hora de testar isso tudo. Então apenas para motivos de esclarecimento, vamos dar uma olhada em como ficou a estrutura do nosso diretório.

C:\Projeto
¦   TesteDB.class
¦   TesteDB.java
¦
+---com
¦   +---heap
¦      +---db
¦               MySQL.class
¦               MySQL.java
¦
+---lib
         mysql-connector-java-5.1.5-bin.jar

No meu caso já se pode ver os arquivos .class pois já compilei o código, mas aqui vai a forma como iremos compilar:

À partir da raiz do projeto (No meu caso aqui C:\Projeto (Sim, estou usando windows porque estou escrevendo isso do computador do trabalho :|))
javac -cp . com\heap\db\MySQL.java
javac -cp . TesteDB.java

Agora que tudo está compilado, basta rodar!

java TesteDB
java.lang.ClassNotFoundException: com.mysql.jdbc.Driver
         at java.net.URLClassLoader$1.run(URLClassLoader.java:200)
         at java.security.AccessController.doPrivileged(Native Method)
         at java.net.URLClassLoader.findClass(URLClassLoader.java:188)
         at java.lang.ClassLoader.loadClass(ClassLoader.java:306)
         at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:276)
         at java.lang.ClassLoader.loadClass(ClassLoader.java:251)
         at java.lang.ClassLoader.loadClassInternal(ClassLoader.java:319)
         at java.lang.Class.forName0(Native Method)
         at java.lang.Class.forName(Class.java:169)
         at com.heap.db.MySQL.connect(MySQL.java:32)
         at TesteDB.main(TesteDB.java:7)
com.mysql.jdbc.Driver

Oops! Algo saiu errado. Lembram-se no começo quando eu disse que precisavamos do Mysql Connector/J e que ele estivesse no CLASSPATH? Bem, como da pra notar na estrutura de diretórios, eu coloquei o Connector/J no diretório lib porém não fiz referência a essa lib quando fui rodar o programa, o que causou o erro. Então vamos rodar o comando correto e ver o que acontece:

java -cp .;lib\mysql-connector-java-5.1.5-bin.jar TesteDB
jdbc:mysql://localhost/projeto?user=root&password=12345
Conectado!

Como pode perceber, agora parece que tudo funcionou! A opção -cp do comando java diz ao interpretador qual o CLASSPATH a utilizar. Nesse caso mandei que utilizasse o diretório atual, e o arquivo .jar do Connector/J.

Muito legal isso tudo, porém uma classe que simplesmente conecta no banco é bastante inútil. Vamos então melhorar a nossa classe MySQL, adicionando algums métodos para que possamos consultar dados.

O primeiro método que irei adicionar é um que recebe uma query como parametro e retorna um ResultSet. O ResultSet nada mais é do que um resource que representa a tabela. Eis o código:

    /**
     * Esse método executa a query dada, e retorna um ResultSet
     * Talvez fosse melhor idéia fazer esse método lançar uma exception
     * a faze-lo retornar null como eu fiz, porém isso é apenas um exemplo
     * para demonstrar a funcionalidade do comando execute
     *
     * @param query String contendo a query que se deseja executar
     * @return ResultSet em caso de estar tudo Ok, null em caso de erro.
     */
    public ResultSet executar( String query ) {
        Statement st;
        ResultSet rs;
 
        try {
            st = this.c.createStatement();
            rs = st.executeQuery(query);
            return rs;
        } catch ( SQLException e ) {
            e.printStackTrace();
        }
 
        return null;
    }

Nesse trecho de código, criamos um Statement a partir da nossa conexão. O objeto Statement nos permite executar comando no nosso banco de dados.
E para testar esse código, nós iremos rodar uma query contra o nosso banco de dados que criamos no começo desse texto. O nosso código da classe TesteDB vai ficar dessa maneira:

import java.sql.ResultSet;
import java.sql.SQLException;
 
import com.heap.db.MySQL;
 
public class TesteDB {
 
    public static void main (String [] args) {
        MySQL db = new MySQL("localhost","projeto","root","12345");
        String query;
 
        if ( db.connect() ) {
            System.out.println("Conectado!");
            System.out.println("Rodando uma query contra o banco");
 
            query = "select * from usuario";
            ResultSet rs = db.executar(query);
            try {
                if ( rs != null ) { // Verifica se a query retornou algo
                    while ( rs.next() ) {
                        // Podemos referenciar a coluna pelo índice
                        System.out.println("Id: " + rs.getInt(1));
 
                        // Ou pelo seu nome
                        System.out.println("Nome: " + rs.getString("nome"));
                        System.out.println("Idade: " + rs.getInt("idade"));
                        System.out.println("----------------------------");
                    }
                }
          } catch ( SQLException e ) {
              e.printStackTrace();
          }
 
        };
      }
 
}

Recompile e rode esse código da mesma forma que fizemos lá em cima, você deve ter uma saída como essa:

jdbc:mysql://localhost/projeto?user=root&password=12345
Conectado!
Rodando uma query contra o banco
Id: 1
Nome: Henrique
Idade: 22
----------------------------
Id: 2
Nome: Jos‚
Idade: 35
----------------------------
Id: 3
Nome: Andreia
Idade: 21
----------------------------

No código você pode reparar que eu referenciei as colunas tanto utilizando um índice (cada coluna tem um índice numérico que vai de 1, representando a primeira coluna da tabela, até N onde N é o número de colunas na tabela). Repare também que para cada tipo de dados que a tabela possui utilizamos um método get distinto. Para a lista de métodos get que se pode utilizar, consulte a documentação do ResultSet .
Já melhoramso bastante! Agora nossa classe já tem uma função, ela consulta dados na nossa base! Vamos ver então como podemos ecrever um método para inserir dados em nossa tabela. De volta na classe MySQL adicione o seguinte método:

    /**
     * Executa uma query como update, delete ou insert.
     * Retorna o número de registros afetados quando falamos de um update ou delete
     * ou retorna 1 quando o insert é bem sucedido. Em outros casos retorna -1
     *
     * @param query A query que se deseja executar
     * @return 0 para um insert bem sucedido. -1 para erro
     */
    public int inserir( String query ) {
        Statement st;
        int result = -1;
 
        try {
            st = this.c.createStatement();
            result = st.executeUpdate(query);
        } catch ( SQLException e ) {
            e.printStackTrace();
        }
 
        return result;
    }

Esse método poderá ser utilizado tanto para inserir dados, como para apagar ou atualizar. Novamente criamos um Statement e chamamos um método para executar a nossa query. Para maiores informações sobre os métodos da classe Statement consulte a documentação.

Vejamos então como ficou a nossa classe MySQL completa, e um programa de exemplo que a utiliza.

MySQL.java

package com.heap.db;
 
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Connection;
import java.sql.Statement;
 
public class MySQL {
 
    private String host;
    private String user;
    private String pass;
    private String database;
 
    public Connection c;
 
    /**
     * Construtor da classe
     *
     * @param host Host em que se deseja conectar
     * @param database Nome do database em que se deseja conectar
     * @param user Nome do usuário
     * @param pass Senha do usuário
     */
    public MySQL( String host, String database, String user, String pass ) {
        this.pass = pass;
        this.user = user;
        this.host = host;
        this.database = database;
    }
 
    /**
     * Método que estabelece a conexão com o banco de dados
     *
     * @return True se conseguir conectar, falso em caso contrário.
     */
    public boolean connect() {
        boolean isConnected = false;
        String url;
 
        url = "jdbc:mysql://"+this.host+"/"
              +this.database+"?"
              +"user="+this.user
              +"&password="+this.pass;
 
        try {
            Class.forName("com.mysql.jdbc.Driver").newInstance();
            System.out.println(url);
            this.c = DriverManager.getConnection(url);
            isConnected = true;
        } catch( SQLException e ) {
            e.printStackTrace();
            System.out.println(e.getMessage());
            isConnected = false;
        } catch ( ClassNotFoundException e ) {
            e.printStackTrace();
            System.out.println(e.getMessage());
            isConnected = false;
        } catch ( InstantiationException e ) {
            e.printStackTrace();
            System.out.println(e.getMessage());
            isConnected = false;
        } catch ( IllegalAccessException e ) {
            e.printStackTrace();
            System.out.println(e.getMessage());
            isConnected = false;
        }
 
        return isConnected;
    }
 
    /**
     * Esse método executa a query dada, e retorna um ResultSet
     * Talvez fosse melhor idéia fazer esse método lançar uma exception
     * a faze-lo retornar null como eu fiz, porém isso é apenas um exemplo
     * para demonstrar a funcionalidade do comando execute
     *
     * @param query String contendo a query que se deseja executar
     * @return ResultSet em caso de estar tudo Ok, null em caso de erro.
     */
    public ResultSet executar( String query ) {
        Statement st;
        ResultSet rs;
 
        try {
            st = this.c.createStatement();
            rs = st.executeQuery(query);
            return rs;
        } catch ( SQLException e ) {
            e.printStackTrace();
        }
 
        return null;
    }
 
    /**
     * Executa uma query como update, delete ou insert.
     * Retorna o número de registros afetados quando falamos de um update ou delete
     * ou retorna 1 quando o insert é bem sucedido. Em outros casos retorna -1
     *
     * @param query A query que se deseja executar
     * @return 0 para um insert bem sucedido. -1 para erro
     */
    public int inserir( String query ) {
        Statement st;
        int result = -1;
 
        try {
            st = this.c.createStatement();
            result = st.executeUpdate(query);
        } catch ( SQLException e ) {
            e.printStackTrace();
        }
 
        return result;
    }
}

TesteDB.java

import java.sql.ResultSet;
import java.sql.SQLException;
 
import com.heap.db.MySQL;
 
public class TesteDB {
 
    public static void main (String [] args) {
        MySQL db = new MySQL("localhost","projeto","root","12345");
        String query;
        int result;
 
        if ( db.connect() ) {
            System.out.println("Conectado!");
            System.out.println("Rodando uma query contra o banco");
 
            query = "select * from usuario";
            ResultSet rs = db.executar(query);
            try {
                if ( rs != null ) { // Verifica se a query retornou algo
                    while ( rs.next() ) {
                        // Podemos referenciar a coluna pelo índice
                        System.out.println("Id: " + rs.getInt(1));
 
                        // Ou pelo seu nome
                        System.out.println("Nome: " + rs.getString("nome"));
                        System.out.println("Idade: " + rs.getInt("idade"));
                        System.out.println("----------------------------");
                    }
                }
          } catch ( SQLException e ) {
              e.printStackTrace();
          }
 
          System.out.println("Inserindo dados na tabela");
          query = "insert into usuario (nome, idade) values ('Maria',23)";
          result = db.inserir(query);
          if (  result > -1 ) {
              System.out.println("Dado inserido com sucesso! Resutlt = " + result);
          } else {
              System.out.println("Erro inserindo dado.");
          }
 
          query = "update usuario set idade = 99";
          result = db.inserir(query);
          if (  result > -1 ) {
              System.out.println("Dado inserido com sucesso! Resutlt = " + result);
          } else {
              System.out.println("Erro inserindo dado.");
          }
 
        };
      }
 
}

O procedimento para compilar e rodar é o mesmo que seguimos lá no começo.
Bom, por hoje é só pessoas! Espero que esse pequeno tutorial possa ajudar aqueles que como eu estão começando! Continuem estudando e boa sorte!
No próximo vamos falar de coisas pouco mais avançadas e ainda mais divertidas.

Para maiores informações consulte os links:
MySQL AB: Basic JDBC Concepts
Java Documentation
Google