- [Kathryn] Almost anything in real life

can be represented in code,

but how well something is represented is up to us

in what we decide to program.

Classes in Java give us a way to model or represent

physical objects in code via a blueprint.

A blueprint or class contains a set of attributes

and behaviors that define an object.

Let's design a tree object in code using a class.

The attributes might be height, trunk diameter,

and maybe even tree type.

Every tree has these properties or attributes,

but their values might not be the same.

That's what makes this class a blueprint.

It contains the definition of what a class should be.

As for the behaviors,

growing could be a behavior for the tree.

It's an action that the tree takes

rather than an attribute

representing the current state of the tree.

Let's create a blueprint for a tree using a class in Java.

I'm on a Mac, so I'll go control click,

and this will allow me to create a new Java class.

We'll call this "tree,"

and our IDE sets up this class as

an empty class named "tree".

A class doesn't have to have attributes or behaviors.

It could be completely empty, as we see here.

It could also just have attributes or just have behaviors.

However, most of the time a given class will have both.

Let's add some code to the "tree" class

so that it actually represents a tree.

Starting with the attributes,

we'll have a height and trunk diameter.

These will have the data type double,

meaning they can be represented by decimal values.

While we could represent the type of tree with a string,

we'll represent it with its own enum here

called "tree type."

To create an enum, we'll control click on the source folder,

select new, Java class, and then enum.

We'll call this enum "tree type."

An enum is a special type

that represents a group of constants.

Here, we'll want those constants to be different tree types.

These are the only values we can give

to a variable with the tree data type.

By using an enum, no one can create

a macaroni tree or a money tree,

which would be the case if we used a string.

The only tree types that can exist

are those listed in the enum class.

To use this enum, all we have to do is

use the data type "tree type"

for a given attribute or variable,

which is what we've done here.

Now our class has attributes.

Let's add the grow behavior

to finish up our definition of a tree.

A behavior is represented by a function.

Our function will return void and be called grow.

In the implementation,

we'll access the height and trunk diameter of the tree,

and increment them accordingly.

To keep things simple, we'll say

all trees will grow 10 feet in height

and one inch in diameter when this behavior is used.

However, you could use the type attribute or other data

to inform how much the tree grows.

There are many different ways

a tree can be represented in code.

Great, now we've combined the attributes and behaviors

related to a tree into a single unit: the "tree" class.

Remember, it's a blueprint, because we're only defining

the attributes and behaviors of a tree.

We haven't created any trees yet.

Our class says if we wanted to create a tree,

this is how it would be represented in our program.

Classes only represent a general blueprint,

but they become more tangible when you use a constructor

to bring your blueprint to life.

To create trees from our "tree" class,

we'll need to add a special type of function

called a constructor, to construct our tree objects.

To create a constructor, we'll use the class name "tree."

We don't need a return type

because the name of the function "tree"

counts as the return type as well,

since "tree" is the class name.

This classifies it as a constructor.

To build a tree, we'll need to know

what its height, diameter, and tree type should be.

This means we'll need to add inputs to the constructor

so that we can construct a custom tree

with the appropriate height, diameter, and type.

Of course, the body of the function doesn't do anything yet.

We'll need to set up the tree we're building

with the appropriate values.

Using the "this" keyword,

we access the tree we're in the midst of creating

and set the height, trunk, and type on the left

equal to the inputted values on the right.

When this constructor is used, it will create a tree

with the inputted height, trunk, and tree type values.

Let's try it.

To keep our "tree" class separate from

the program we want to execute,

we'll create a new class called "main."

This will contain our main method

where we'll execute the program from.

To create a tree, we'll use the constructor "tree"

with the inputs 25 for the height, five for the diameter,

and our tree will be an oak tree.

In addition to using the name of the constructor,

we'll also need to add the new keyword.

This will create a new tree from our "tree" class.

So right now we create the tree, but then we throw it away.

We don't save it in a variable anywhere.

To save it, we'll create a tree variable

called "my favorite oak tree."

We've created our first tree.

If we write "my favorite oak tree,"

we'll be able to see all of the attributes

as well as the behaviors we can use on the tree.

To start off, we'll just print out the tree's type.

We'll use system.out.printLN and run the program.

And it's an oak tree!

By adding a constructor to our "tree" class

and using the constructor in a main method,

we were able to create our first tree in code.

(mellow electronic music)