- [Kathryn] Almost anything in real life

- [Kathryn]現實生活中的幾乎所有事情

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

Java中的類給了我們一種建模或表示的方法

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.

讓我們用Java中的一個類來創建一個樹的藍圖。

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

我用的是Mac，所以我去控制點擊。

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

而這將使我能夠創建一個新的Java類。

We'll call this "tree,"

我們把這稱為 "樹"。

and our IDE sets up this class as

而我們的IDE將這個類設置為

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.

選擇新建，Java類，然後是枚舉。

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

所有的樹木將長到10英尺高

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."

為了創建一個構造函數，我們將使用類名 "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."

我們將創建一個名為 "main "的新類。

This will contain our main method

這將包含我們的主方法

where we'll execute the program from.

我們將從那裡執行程序。

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

為了創建一棵樹，我們將使用構造函數 "tree"

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

輸入25為高度，5為直徑。

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.

我們將使用system.out.printLN並運行該程序。

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)

(醇厚的電子音樂)