JDBC – CaracterísticasObjetivos do Capítulo

Pra que serve JDBC Entender sua funcionalidade

Primeiramente, o que devemos saber sobre JDBC é que ele é uma API J Java, faz parte da biblioteca de classes. Essas classes fornecem para os programadores recursos para manipularem banco de dados. O JDBC trabalha junto com a linguagem SQL (Structured Query Language – Linguagem de Consulta Estruturada). Caso você não tenha nenhum conhecimento em SQL não se preocupe, no capítulo _ abordaremos instruções básicas. Uma das principais funções da API JDBC é separar programadores Java dos problemas de banco de dados, ou seja, você pode executar o mesmo código para diferentes bancos de dados.

Gerenciamento de TransaçãoImagine que temos um banco de dados e uma aplicação que se conecte a ele. Todas as transações que são realizadas entre esses dois elementos podem ser com sucesso ou sem sucesso. O gerenciamento de transação tem exatamente essa função, de alertar se uma transação teve sucesso ou não. Podemos optar por duas opções no registro de transações, pode ser a cada instrução ou esperar por uma série de instrução para registrar sucesso ou fracasso.

JDBC x Banco de Dados RelacionalA API JDBC é fortemente voltada para banco de dados relacionais, e sua linguagem de consulta é a SQL. Entretanto Java trabalha orientado a objetos, assim precisamos em nossa aplicação uma camada que mapeie o mundo relacional do mundo orientado a objetos. Para exemplificar vamos imaginar um banco de dados relacional sobre carros.

Tab_CarrosCod Marca Modelo Cor AnoFabr01 Fiat Uno Cinza 199702 Ford Escort Prata 199903 Chevrolet Astra Preto 2004

Agora uma classe Carro em Java:

1. class Carro{2. private int cod;3. private String marca;4. private String modelo;5. private String cor;6. private String anoFabr;7.8. //…9. //setters e getters…10. //…11. }

Agora um código em grosso modo para exemplificar a função da classe de mapeamento do mundo OO para o relacional.

1. class CarroDAO{2.3. public void gravar(Carro car){4.5. //conexões ao banco de dados...6.7. tab_Carros.cod = car.cod;8. tab_Carros.marca = car.marca;9. tab_Carros.modelo = car.modelo;10. tab_Carros.cor = car.cor;11. tab_Carros.anoFabr = car.anoFabr;12.13. }14. }

Gostaria de deixar bem claro que o código acima apresentado na classe CarroDAO não está correto do ponto de vista da linguagem Java. Ele está sendo usado somente para exemplificar a função da classe de mapeamento.

Vamos entender então a função da classe CarroDAO.

Linha 1:class CarroDAO{

Declaramos a aqui a classe CarroDAO. No nome da classe fazemos referência a classe na qual mapearemos para o mundo relacional junto a abreviação de Data Acess Objetc (DAO – Objeto de Acesso a Dados) .

Linha 3:public void gravar(Carro car){

Declaramos o método gravar, que recebe como argumento um objeto tipo Carro, e armazena sua referência em car.

Linha 5://conexões ao banco de dados...

Aqui temos em forma de comentário a simulação da conexão ao banco de dados, que para o nosso exemplo não é necessário. Mais adiante veremos em detalhes em vista do JDBC como realizar a conexão ao banco de dados e executar comandos SQL como INSERT, UPDATE, DELETE e SELECT.

Linha 7 a 11: tab_Carros.cod = car.cod;tab_Carros.marca = car.marca;tab_Carros.modelo = car.modelo;tab_Carros.cor = car.cor;

tab_Carros.anoFabr = car.anoFabr;

Temos em grosso modo referência à nossa tabela de carros e atribuímos a cada campo valores respectivos do objeto car, que foi recebido através de argumento pelo método gravar. Dessa forma temos a conversão dos valores de um objeto para uma tabela relacional.Como mencionado anteriormente, o código usado na classe CarroDAO não é correto ao ponto de vista da linguagem Java. No capítulo _ teremos em detalhe o código Java para realizar a mesma operação.

SQL BásicoPara nossos exemplos usaremos o banco de dados MySql v.5.0.45. Assim em outros bancos de dados os comandos podem ser diferentes dos apresentados aqui.Para efetuarmos consultas, inserções, exclusões ou alterações nos dados usamos a linguagem SQL (Structured Query Language – Linguagem de Consulta Estruturada). Dentro da linguagem SQL temos seus comandos divididos em grupos: DML (Data Manipulation Language – Language de Manipulação de Dados)DDL (Data Definition Language – Linguagem de Definição de Dados)DCL (Data Control Language – Linguagem de Controle de Dados)DQL (Data Query language – Linguagem de Consulta a Dados)

Para o foco da apostila explicaremos somente o grupo DML e alguns comandos a parte de outros grupos.

CREATE – Grupo DDL

Para iniciarmos nossos exemplos precisamos ter um banco de dados, fazemos isso digitando:

CREATE DATABASE nome_do_banco_de_dados;

Exemplo:

CREATE DATABASE apostila_java;

Para visualizarmos os bancos de dados existentes digitamos:

SHOW DATABASES;

E para saber o banco de dados que está em uso no momento usamos:

SELECT DATABASE();

Após criado o banco de dados devemos selecioná-lo como em uso. Para isso usamos:

USE nome_do_banco_de_dados

Exemplo:

USE apostila_java

O comando USE não necessitada de ponto-e-vírgula ao seu final, mas caso você o use não fará diferença.Após de criado o bando de dados e colocá-lo em uso devemos criar sua(s) tabela(s). Para isso usamos:

CREATE TABLE nome_da_tabela(nome_coluna tipo_coluna modificadores_coluna,nome_coluna tipo_coluna modificadores_coluna,....,nome_coluna tipo_coluna modificadores_coluna)

Alguns modificadores importantes são:PRIMARY KEY – Define uma coluna como chave primáriaNOT NULL - Define que uma coluna não pode ser nula ( precisa inserir o dado)UNIQUE - Define que o valor de uma coluna deve ser únicoREFERENCES nome_tabela - Define que uma coluna é chave estrangeira

Exemplo – Criando tabela carros

CREATE TABLE tab_carros(cod INT PRIMARY KEY,marca CHAR(35),modelo CHAR(35),cor CHAR(25),anoFabr CHAR(4))

Tab_CarrosCod Marca Modelo Cor AnoFabr01 Fiat Uno Cinza 199702 Ford Escort Prata 199903 Chevrolet Astra Preto 2004

Para visualizar se criamos a tabela conforme esperado digite:

DESCRIBE nome_da_tabela;

Exemplo:

DESCRIBE tab_carros;

Se por algum motivo precisar excluir uma tabela usamos o seguinte comando:

DROP TABLE nome_tabela;

Grupo DML Nesse grupo temos os comandos INSERT, DELETE, UPDATE E SELECT (SELECT pode ser encaixado também no grupo DQL – Data Query Language – Linguagem de Consulta a Dados).

INSERTCriamos uma tabela com propósito de armazenar dados. Quando desejamos inserir algum dado na tabela usamos o comando INSERT que segue a sintaxe:

INSERT INTO nome_tabela VALUES ();

Exemplos:

INSERT INTO tab_carros VALUES (01, ‘Fiat’, ‘Uno’, ‘Cinza’, ‘1987’);

Caso deseje não inserir valor em todas as colunas pode ser feito da seguinte maneira:

INSERT INTO tab_carros VALUES (01, NULL, ‘Astra’, ‘Vermelho’, NULL);

Perceba o uso da palavra NULL, indica para o banco de dados a ausência de valor. No lugar referente a coluna que desejamos não inserir valor colocamos a palavra NULL. Permitido apenas quando a coluna não foi definida como NOT NULL.

Ou você pode especificar as colunas nas quais você deseja inserir os valores, ficando dessa forma:

INSERT INTO nome_tabela ( coluna1, coluna2, ..., colunaN) VALUES (valor1, valor2,..., valorN);

Observe que o valor1 é referente a coluna1, valor2 a coluna2 e assim respectivamente. Da mesma forma devem ser seguidas as regras referentes aos modificadores da coluna.

Exemplo:

INSERT INTO tab_carros(cod, modelo, anoFabr) VALUES (04, ‘Ford’, ‘1998’);

UPDATEA instrução UPDATE permite modificar dados já inseridos no banco de dados.

UPDATE nome_tabela SET nome_coluna = novo_valor WHERE condição

Exemplo:

UPDATE tab_carros SET anoFabr = 2000 where cod = 01;

No nosso exemplo redefinimos o campo anoFabr para 2000 mas somente para a linha que possui cod = 01. Nota, a saber, que se não usássemos a cláusula where todas as linhas seriam modificadas para 2000.

DELETEA instrução DELETE é usada quando desejamos excluir o conteúdo de uma linha inteira.

DELETE FROM nome_tabela WHERE nome_coluna = valor;

Exemplo:

DELETE FROM tab_carros WHERE cod = 01;

Nessa situação excluiríamos a linha que possui o cod =1. Novamente, se não possuíssemos a cláusula where todas as linhas seriam excluídas.

SELECT

Um dos mais importantes comandos da linguagem SQL. Possui umas das sintaxes mais compridas. O select nos fornece suporte para pesquisas em nosso banco de dados. Sua sintaxe de forma mais básica:

SELECT nome_coluna1, nome_coluna2, ...., nome_colunaNFROM nome_tabelaWHERE nome_coluna = valor;ORDER BY nome_coluna;

Exemplo:

SELECT modelo FROM tab_carros where cod <= 2 ORDER BY modelo;

Nesse código seria selecionada a coluna modelo na qual o cod é menor igual que 2, e seria mostrado para nós, ordenado em ordem alfabética, pelos nomes da coluna modelo.

Apresentamos nesse capítulo as formas mais básicas do comando SQL, a saber, sintaxes mais avançadas a respeito, uma boa indicação é o site do MySQL:

http://dev.mysql.com/doc/refman/4.1/pt/index.html

JDBC – EstruturaObjetivos do Capítulo

Estrutura JDBC Drivers JDBC

Estrutura JDBCComo dito anteriormente a função da API JDBC é fornecer aos programadores Java conexão a diversos bancos de dados e traduzir o mundo relacional para o mundo Orientado a Objetos e vice-versa. Essa API também fornece suporte para que independente da linguagem usada na aplicação, você possa ter acesso a uma grande quantidade de base de dados sem precisar programar métodos de acesso específicos. Obviamente para acessar a uma determinada base de dados você precisa de um driver específico da base de dados.

Existem 4 distintos grupos de Drivers:

Tipo 1 – Ponte JDBC-ODBCInicialmente, para que possamos entender esse conceito de ponte, temos que ter claramente na mente o papel da API ODBC. Muitos servidores de banco de dados usam seu protocolo próprio para comunicação com o exterior. Dessa forma, para implementar uma aplicação que acesse a uma determinada base de dados, é necessário que você aprenda primeiramente os métodos de acesso da mesma, ou seja, um trabalho e tanto. Imagine agora uma aplicação que necessite acessar vários tipos de bases de dados, o programador ficaria loco. Para minimizar esse problema, a Microsoft elaborou uma API chamada ODBC. Sua principal função é fazer com que o acesso à base de dados seja independente, o programador não precisa saber os métodos de acesso específico das suas bases de dados, ele apenas implementa métodos de acesso para a ODBC e assim a mesma faz a chamada na base de dados. Porém para que a ODBC consiga acesso é necessário o Drive da determinada base de dados.Temos até aqui então a seguinte situação:

Na imagem percebemos que uma mesma aplicação tem acesso a duas base de dados, isso é possível graças a ODBC, que através do Drive específico da consegue fazer acesso. Dessa maneira é possível realizarmos acesso a quanta base de dados nos fosse necessária.Agora podemos entender como funciona a ponte JDBC – ODBC. Que nada mais é do que uma ligação da API JDBC para a API ODBC. A função da ponte é apenas converter chamadas tipo JDBC para ODBC, e quanto o retorno do banco de dados são várias linhas de uma tabela, nos da suporte oferecendo objetos como ResultSet (visto adiante), que possui métodos para manipulação.

Tipo 2 – JNMI

São construídos através do protocolo nativo da base de dados usada, ou seja, você tem que saber como funcionam os controles de acesso da base de dados que você deseja utilizar.

Tipo 3 – JDBC-Net Driver

Esta categoria consiste de drivers que conversam com servidores de acesso a banco de dados através de um protocolo de rede padrão (como por exemplo, HTTP). Estes servidores de acesso a banco de dados por sua vez ficam responsáveis em traduzir o protocolo de rede em um protocolo nativo do sistema de banco de dados, possivelmente utilizando ODBC.

Tipo 4 – Driver Nativo

Funciona como o tipo 2 de driver, a diferença está que esse é totalmente escrito em Java. Não é preciso que saibamos sequer um comando da linguagem nativa da base de dados.

Agora para exemplificarmos de uma melhor forma irei mostrar um exercício que faz todas as etapas necessárias para realizar uma conexão com o banco de dados. Como já citado usaremos o banco de dados MySql, que é possível fazer o download na página http://dev.mysql.com/downloads/Depois de instalado e configurado o servidor MySql precisaremos também do seu Drive que usaremos em nossa aplicação Java. Esse Drive que iremos usar é tipo 4, assim obvio saber que não usaremos ponte com a ODBC.Download drive tipo 4 para MySql: http://dev.mysql.com/downloads/connector/j/5.1.html

Uma das partes que há bastantes dúvidas é na hora de inserir o Drive em nossa aplicação. Para isso precisamos indicar ao classpath onde está o nosso arquivo .jar.Veja a imagem:

Depois de baixado, dentro do arquivo “mysql-connector-java-5.1.5.zip” teremos o mostrado acima. Nosso arquivo .jar é o selecionada na imagem, para facilitar o copiaremos para o local C:Imagine agora a seguinte situação:

Temos na unidade c:\ a classe Ex_01.class que contem o nosso código de acesso ao banco de dados, e temos também nosso drive MySQl, ambos selecionados na imagem.Assim:

Perceba o uso de aspas ao indicar o classpath, e ao seu final ‘;.’ e então o nome da classe. A mensagem retornada é devido ao nosso banco de dados não estar em execução. Essa é apenas umas das maneiras de executar nossa classe Ex_01. É possível que você adicione à sua IDE o local do Drive MySql, assim podendo ser compilado através da mesma.Chega de enrrolação, vamos para o código propriamente dito, vejamos:

Exercício_01

1. import java.sql.*;2.3. public class Ex_01{4.5. public static void main(String args[]){6. String url = 7. +"jdbc:mysql://localhost/apostila_java?user=root&pass”8. +”word=123";9.10. Connection con = null;11.12. try {13. String driver = "com.mysql.jdbc.Driver";14. Class.forName(driver).newInstance();15. }16.17. catch(Exception ex){18. System.out.println("Failed to load MySql Driver.");19. return;20. }21.22.23. try{24. con = DriverManager.getConnection(url);25. Statement stmt = con.createStatement();26. ResultSet result = stmt.executeQuery("SELECT * from"27. +"tab_carros;");28.29. if(!result.next()){30. System.out.print("Não Há Dados Na Tabela.");

31. }32. else{33. System.out.print("Há Dados Na Tabela.");34. }35.36. }37. catch(SQLException ex){38. System.out.println("SQLException: " + 39. ex.getMessage());40. System.out.println("SQLState: " + ex.getSQLState());41. System.out.println("VendorError: " + 42. x.getErrorCode());43. }44.45. }//Main46.47. }//Class

Na Linha 1:import java.sql.*;

temos a instrução import para todas a classes que estão em java.sql, essas fornecendo um grande leque para a manipulação com base de dados.

Na Linha 6 à 8:String url = +"jdbc:mysql://localhost/apostila_java?user=root&pass”+”word=123";

Temos a declaração de uma variável String que contém o endereço de nossa base de dados. A sintaxe para o endereço URL de uma base de dados é: jdbc:subprotocolo:subnome, onde subprotocolo identifica qual driver será usada para conexão e subnome fornece ao driver qualquer informação referente a conexão, com local, usuário e senha. Importante lembrar que a sintaxe de uma URL varia de driver para driver.

Linha 10:Connection con = null;

Aqui se cria uma variável tipo referência para um objeto que for instanciado da classe Connection. Esse objeto é a conexão propriamente dita.Até agora temos a seguinte situação

Vemos na imagem que nossa conexão não aponta para nenhum banco de dados.

Linha 12 à 15:try {

String driver = "com.mysql.jdbc.Driver";Class.forName(driver).newInstance();}

Nesse bloco try temos inicialmente uma String chamada driver, que armazena o local do driver mysql, e como já dito, em caso do uso de outro driver, é necessário ver na especificação do mesmo o local em que ele se encontra.. Na linha Class.forName o que estamos fazendo nada mais é do que falar para a classe DriverManager, que se necessário temos o driver MySql para uso. Em outras palavras, estamos registrando o driver.

Linha 17 à 20:catch(Exception ex){

System.out.println("Failed to load MySql Driver.");return;}

Temos uma exceção caso ocorra um erro ao registrar o driver. O erro mais comum que ocorre nessa fase, é a falta do caminho do driver no classpath da aplicação.

Linha 23 e 24:try{

con = DriverManager.getConnection(url);

Aqui criamos a conexão com a base de dados. Observe a classe DriverManager criar uma conexão para a variável con, usando como parâmetro a variável URL, que segue com endereço, usuário e senha da base de dados.Temos então nessa fase a seguinte situação:

Como o próprio nome diz, a classe DriverManager é o gerente de drives. Para devolver à variável con uma conexão com o banco de dados, ela tenta uma implementação com todos os drivers registrado em sua lista, caso não consiga uma conexão, uma exceção é gerada.

Na linha 25:Statement stmt = con.createStatement();

Uma instância da classe Statement permite a nós realizar comandos básicos do SQL.Para executarmos uma consulta através de um objeto Statement usamos seu método chamado executeQuery(String Sql), assim nos retorna um objeto da classe ResultSet, que contêm métodos para manipular as linhas que foram selecionadas. Caso queiramos executar um UPDATE, INSERT ou DELETE usamos o método executeUpdate(String Sql) que nos retorna apenas a quantidade de linhas que foram afetadas.Vemos então a criação de um objeto Statement para a conexão con.

Linha 26:ResultSet result = stmt.executeQuery("SELECT * from"+"tab_carros;");

Temos aqui um objeto ResultSet, como dito anteriormente, usado para manipulação de consultas SQL. Veja o uso do objeto Statement com seu método executeQuery para consultas, e como parâmetro a String SQL.

Linha 29 à 34:if(!result.next()){

System.out.print("Não Há Dados Na Tabela.");}else{System.out.print("Há Dados Na Tabela.");}

Temos um exemplo de como podemos manipular os dados que foram selecionados, usando o objeto de ResultSet. Um dos métodos da classe ResultSet é o next(), que não recebe nada como parâmetro, porém nos retorna true se há linhas para serem manipuladas, ou retorna false, se não há mais linhas. Na ocasião, caso ele retorne true (sim a linhas), imprimimos a mensagem que há dados na tabela, caso contrário, imprimimos a mensagem que não há dados na tabela.

Linha 37 à 43:catch(SQLException ex){

System.out.println("SQLException: " + ex.getMessage());System.out.println("SQLState: " + ex.getSQLState());System.out.println("VendorError: " + x.getErrorCode());}

Aqui apenas temos uma exceção para possíveis erros na consulta ou qualquer outra instrução. Usamos aqui alguns métodos da classe SQLException para mostrar informações sobre o erro que ocorreu.

Vamos agora criar uma aplicação completa, que faça inicialmente INSERT’s, depois um SELECT, em seguida UPDATE e DELETE.

A seguir um script usado no MySql, para criação da base de dados, tabelas e inserções de alguns dados.

Script Exercício_02

*----------------------------------Script---------------------------*

--* Script Exemplo para apostila Java & JDBC.--* Criado por Felipe Alvares Nemeth--* Instituição: Universidade de Sorocaba--* Em 31/01/2008

CREATE DATABASE apostila_java;USE apostila_java

CREATE TABLE tab_carros(cod INT(4) PRIMARY KEY AUTO_INCREMENT,marca VARCHAR(30) NOT NULL,modelo VARCHAR(30) NOT NULL,cor VARCHAR(15) NOT NULL,anoFabr VARCHAR(4) NOT NULL);

INSERT INTO tab_carros(marca, modelo, cor, anoFabr) VALUES ('Fiat', 'Uno', 'Cinza', '1997');INSERT INTO tab_carros(marca, modelo, cor, anoFabr) VALUES ('Ford', 'Escort', 'Prata', '1998');

*------------------Fim do Script-----------*

Para usar esse Script, basta você copiar seu conteúdo para um arquivo .txt, e dentro do MySql digitar ‘source [diretório][arquivo];Exemplo: source c:\criaBd.txt;

Exercício_02

1. import java.sql.*;

2. public class Ex_02{

3. public static void main(String args[]){4. String url =5. "jdbc:mysql://localhost/apostila_java?user=root&passwo6. rd=123";7.8. Connection con = null;9.10. try {11. String driver = "com.mysql.jdbc.Driver";12. Class.forName(driver).newInstance();13. }14.15. catch(Exception ex){16. System.out.println("Failed to load MySql Driver.");17. return;18. }19.20. //Criando a conexão21. try{22. con = DriverManager.getConnection(url);23. Statement stmt = con.createStatement();24.25. //Usando INSERT26. int linhasAfetadas=0;27. linhasAfetadas = stmt.executeUpdate("INSERT INTO 28. tab_carros(marca, modelo, cor, anoFabr) VALUES29. ('Chevrolet', 'Prisma', 'Prata', '2006')");30.31. //Usando SELECT32. ResultSet rs = stmt.executeQuery("SELECT * from 33. tab_carros");34. //Tratanto dados do ResultSet35. while(rs.next()){36. System.out.println("Cod: "+ rs.getInt(1));37. System.out.println("Marca: "+ rs.getString(2));38. System.out.println("Modelo: "+ rs.getString(3));39. System.out.println("Cor: "+ rs.getString(4));40. System.out.println("Ano Fabricação: "+ 41. s.getString(5));42. System.out.println("*------------------------------43. ");44. }

45. //Usando DELETE46. stmt.executeUpdate("DELETE FROM tab_carros where 47. noFabr = 2006");48. rs = stmt.executeQuery("Select * from tab_carros");49. while(rs.next()){50. System.out.println("Cod: "+ rs.getInt(1));51. System.out.println("Marca: "+ rs.getString(2));52. System.out.println("Modelo: "+ rs.getString(3));53. System.out.println("Cor: "+ rs.getString(4));54. System.out.println("Ano Fabricação: "+ 55. s.getString(5));56. System.out.println("*------------------------------57. ");58. }59.60. //Usando UPDATE61. stmt.executeUpdate("UPDATE tab_carros SET cor = 62. Vermelho' WHERE cod = 1");63.64. }65.66. catch(SQLException ex){67. System.out.println("Erro em INSERT");68. System.out.println("SQLException: " + 69. ex.getMessage());70. System.out.println("SQLState: " + ex.getSQLState());71. System.out.println("VendorError: " + 72. x.getErrorCode());73. }74.75. }//Main76.77. }//Class

Esse exercício foi implementado pelo único motivo de mostrar o uso de comandos SQL dentro da linguagem Java. Como explicado anteriormente temos nossa String url, onde armazena o ‘endereço’ do banco, pode ser ele local (nosso caso) ou ser externo.Na linha 8 criamos uma variável tipo Connection que será nossa conexão propriamente dita com a base de dados.Na linha 10 até a linha 13 temos um try, que em seu corpo possui uma String chamada driver que possui o endereço da classe drive, que está dentro do nosso pacote Jar baixado do site do MySql. Logo após fazemos o registro do nosso drive na lista de DriverManager. Ele que irá criar a conexão para nós e atribuí-la à variável con de Connection, mas para isso é preciso registrar o drive que será usado. Após isso, nas linhas 15 a 18 temos um catch(Exception ) para eventuais erros.Na linha 21 começamos, com o bloco try, começamos o processo de conexão com a base de dados. Perceba a sintaxe:

con = DriverManager.getConnection(url);

a classe DriverManager com o método getConnection, que recebe como parâmetro a string url (endereço do banco), assim é criada uma conexão para a variável con. Em seguinte temos a seguinte declaração:

Statement stmt = con.createStatement();

Aqui criamos uma variável tipo Statement, será nela que iremos inserir os comandos SQL. Na linha 26 a 29 temos o uso do método executeUpdate(), e seu retorno para nós é a quantidade de linhas que foram afetadas com o nosso comando. Vale lembrar que para usar select, usamos o comando executeQuery(), porém, o nosso retorno será as linhas selecionadas pela nossa instrução, e para manipulação das mesmas, usamos um objeto chamado ResultSet. Veja a sintaxe:ResultSet rs = stmt.executeQuery("SELECT * from" +"tab_carros");

A partir de agora podemos manipular as linhas selecionadas como exemplo nas linhas 35 a 43:

while(rs.next()){System.out.println("Cod: "+ rs.getInt(1));System.out.println("Marca: "+ rs.getString(2));System.out.println("Modelo: "+ rs.getString(3));System.out.println("Cor: "+ rs.getString(4));System.out.println("Ano Fabricação: "+ s.getString(5));System.out.println("*------------------------------");}

Vemos o uso da estrutura while, ela nos permite fazer a verificação antes de entrar em seu corpo, diferente de outras estruturas. Na condição do while, foi usado rs.next(). O Objeto rs possui um método chamado next(), ele nos retorna true caso haja mais linhas para serem manipuladas, assim o while sairá de sua iteração quando não houver mais linhas para manipulação.Nas linhas seguintes temos as mesmas instruções com diferença apenas nos comandos SQL.