Now that you've seen how to connect to and interact with

a database in Java using JDBC, we're ready to take it to the next level.

If we're writing a contact manager application,

one of the obvious objects we'd want to work with would be a contact object.

We can write a POJO.

Remember, that's plain old Java object.

That models a contact by creating a class that includes an instance field for

each of the database columns we define.

Then, when we have a new contact object,

we should be able to simply save it to the database.

Let's write a first draft of what that might look like.

What I'd like to do here is write a save method that allows us to quickly save

a contact to the database without having to continually rewrite the SQL to do so.

Let's get this started at the bottom.

So I'll start by entering a method stub here, public static void.

I'll call it save.

And I'd like to save a cCntact object so I'll include that as a parameter.

And let me drop a couple comments in here.

The things that we'd like to do.

So we'll start by composing the query, and then we will execute the query.

Let's begin composing the query by using a String variable, I'll name it sql.

And this variable will hold the general syntax for an insert statement.

We wanna insert it into the contacts table.

We'll list our column names, and

then we'll list the actual values that we'd like to insert.

So my column names here are firstname, lastname, email, and phone.

And what I wanna do is stick placeholders in here where I can put the actual

values from my contact object for the values of the insert statement.

But, so that I don't forget the single quotes that surround a string value in

SQL, I'm gonna stick those in right now.

The first three columns are string columns.

So for our first name we'll have a string placeholder.

Same for last name and email.

And for the phone we'll have a numeric placeholder.

Now, let's take the actual values of the Contact object's fields

into this string using String.format.

And I will place or assign that value right back to the SQL variable.

So I'll use string String.format.

The sql variable holds my general format, and

then into the placeholders I will place the values contact.getFirstName(),

contact.getLastName(), contact.getEmail() and

contact.getPhone.

If you wanna verify that those getters actually exist are are in

alignment with the Contact class, go ahead and

click on Contact.java to verify that that is indeed the case.

In order to execute this update using statement.executeUpdate,

we'll need that statement object.

Let's include it as a parameter after the Contact object.

And I will just call this Statement.

So under execute the query, I can now call statement.executeUpdate.

And pass it the value of the sql variable,

which will hold our fully formatted insert statement,

including the values that have been placed into these placeholders.

Just one more issue with this method.

The statement.executeUpdate method is declared as throwing a SQL Exception.

So, either we'll need a try catch block right here,

which catches the SQL exception.

Or, we'll have to declare this save method as throwing the SQL exception,

which means that the caller of this method will have to handle this.

We'll choose this ladder approach,

since the caller of this method will be the main method up above.

And up here in the main method we already have a try catch that handles

the SQL exception.

So let's add that throws clause right here.

Throws, SQLException.

Speaking of that main method, let's return to that main method and replace these two

insert statements with calls to our newly coded save method.

So the first I'll need to do is create a Contact object

with all the same information that's included in this first insert statement.

So the order of this, and again,

you can verify this in contact.java is first name,

last name, email, and phone.

I'm gonna just copy and paste this.

But this is a long value, so I won't forget to append the L there so

the JVM knows to consider it a long.

Now, I'm ready to call our newly coded save method.

So I'll save this contact using the statement object that I constructed above.

And we'll repeat all that for James Gosling as well.

We'll add him right here, James Gosling.

James@java.com.

And I'll use this phone number, without forgetting the L.

Now I should be able to delete these two calls to the executeUpdate method.

Let's compile and run our code to see if we get the same results.

javac JdbcMain.java.

Looks like all compiles well.

So, let's run it specifying the class path that includes both the jar file and

the current directory.

Awesome!

Same result as before.

We've now abstracted away the actual SQL for insert statements.

So up above, instead of crafting the actual SQL statements,

we can simply call our save method and it takes care of the details for us.

Hey, great job!

You've now used Java to connect to and interact with a database.

In addition, you've taken your first step toward allowing the saving of POJOs.

It's nice to be able to call a save method with your POJO instead of having to craft

and re-craft SQL statements with every database change.

You're well on your way to discovering the next level of data management

using application code.