介绍 ( Introduction )

Before you read this step-by-step guide you might want to cast your eye over the introduction to object-oriented programming. The Java code contained in the following steps matches the example of a Book object used in the theory of that article.​

在阅读本分步指南之前，您可能需要对面向对象编程的介绍有所了解 。 以下步骤中包含的Java代码与该文章的理论中使用的Book对象的示例相匹配。

By the end of this guide you will have learned how to:

到本指南结束时，您将学习如何：

• design an object设计一个对象
• store data in an object将数据存储在对象中
• manipulate data in an object处理对象中的数据
• create a new instance of an object创建一个对象的新实例

类文件 ( The Class File )

If you're new to objects you will most likely be used to created Java programs using only one file – a Java main class file. It's the class that has the main method defined for the starting point of a Java program.

如果您不熟悉对象，则很可能会习惯于仅使用一个文件(Java主类文件)来创建Java程序。 该类具有为Java程序的起点定义的main方法。

The class definition in the next step needs to be saved in a separate file. It follows the same naming guidelines as you have been using for the main class file (i.e., the name of the file must match the name of the class with the filename extension of .java). For example, as we are making a Book class the following class declaration should be saved in a file called "Book.java".

下一步中的类定义需要保存在单独的文件中。 它遵循与主类文件相同的命名准则(即，文件名必须与文件名扩展名为.java的类名匹配)。 例如，当我们制作Book类时，以下类声明应保存在名为“ Book.java”的文件中。

班级宣言 ( The Class Declaration )

The data an object holds and how it manipulates that data is specified through the creation of a class. For example, below is a very basic definition of a class for a Book object:

通过创建类来指定对象保存的数据以及如何处理该数据。 例如，以下是Book对象的类的非常基本的定义：

public class Book { }

It's worth taking a moment to break down the above class declaration. The first line contains the two Java keywords "public" and "class":

值得花点时间来分解上面的类声明。 第一行包含两个Java关键字“ public”和“ class”：

• The public keyword is known as an access modifier. It controls what parts of your Java program can access your class. In fact, for top-level classes (i.e., classes not contained within another class), like our book object, they have to be public accessible.public关键字被称为访问修饰符。 它控制Java程序的哪些部分可以访问您的类。 实际上，对于顶级类(即，其他类中未包含的类)，例如我们的书本对象，它们必须是公共可访问的。
• The class keyword is used to declare that everything within the curly brackets is part of our class definition. It's also followed directly by the name of the class.class关键字用于声明大括号内的所有内容都是我们类定义的一部分。 它也直接跟在类的名称之后。

领域 ( Fields )

Fields are used to store the data for the object and combined they make up the state of an object. As we're making a Book object it would make sense for it to hold data about the book's title, author, and publisher:

字段用于存储对象的数据，并结合起来构成对象的状态。 当我们制作Book对象时，有意义的是保存有关书名，作者和出版商的数据：

public class Book {    //fields    private String title;    private String author;    private String publisher; }

Fields are just normal variables with one important restriction – they must use the access modifier "private". The private keyword means that theses variables can only be accessed from inside the class that defines them.

字段只是具有一个重要限制的普通变量–它们必须使用访问修饰符“ private”。 private关键字意味着只能从定义它们的类内部访问这些变量。

Note: this restriction is not enforced by the Java compiler. You could make a public variable in your class definition and the Java language won't complain about it. However, you will be breaking one of the fundamental principles of object-oriented programming – data encapsulation. The state of your objects must only be accessed through their behaviors. Or to put it in practical terms, your class fields must only be accessed through your class methods. It's up to you to enforce data encapsulation on the objects you create.

注意： Java编译器没有强制执行此限制。 您可以在类定义中创建一个公共变量，而Java语言不会抱怨它。 但是，您将打破面向对象编程的基本原理之一-数据封装 。 您只能通过对象的行为来访问它们的状态。 换句话说，您只能通过类方法访问您的类字段。 由您决定对创建的对象实施数据封装。

构造方法 ( The Constructor Method )

Most classes have a constructor method. It's the method that gets called when the object is first created and can be used to set up its initial state:

大多数类都有构造函数方法。 这是在首次创建对象时调用的方法，可用于设置其初始状态：

 public class Book {    //fields    private String title;    private String author;    private String publisher;    //constructor method    public Book(String bookTitle, String authorName, String publisherName)    {      //populate the fields      title = bookTitle;      author = authorName;      publisher = publisherName;    } }

The constructor method uses the same name as the class (i.e., Book) and needs to be publicly accessible. It takes the values of the variables that are passed into it and sets the values of the class fields; thereby setting the object to it's initial state.

构造方法使用与类(即Book)相同的名称，并且需要可公开访问。 它获取传递给它的变量的值并设置类字段的值。 从而将对象设置为其初始状态。

新增方法 ( Adding Methods )

Behaviors are the actions an object can perform and are written as methods. At the moment we have a class that can be initialized but doesn't do much else. Let's add a method called "displayBookData" that will display the current data held in the object:

行为是对象可以执行的动作，并被编写为方法。 目前，我们有一个可以初始化但没有做很多其他事情的类。 让我们添加一个名为“ displayBookData”的方法，该方法将显示对象中保存的当前数据：

 public class Book {    //fields    private String title;    private String author;    private String publisher;    //constructor method    public Book(String bookTitle, String authorName, String publisherName)    {      //populate the fields      title = bookTitle;      author = authorName;      publisher = publisherName;    }    public void displayBookData()    {      System.out.println("Title: " + title);      System.out.println("Author: " + author);      System.out.println("Publisher: " + publisher);    } }

All the displayBookData method does is print out each of the class fields to the screen.

displayBookData方法所做的全部工作是将每个类字段打印到屏幕上。

We could add as many methods and fields as we desire but for now let's consider the Book class as complete. It has three fields to hold data about a book, it can be initialized and it can display the data it contains.

我们可以根据需要添加任意数量的方法和字段，但现在让我们考虑Book类是否完整。 它具有三个字段来保存有关书籍的数据，可以对其进行初始化并显示其中包含的数据。

创建对象的实例 ( Creating an Instance of an Object )

To create an instance of the Book object we need a place to create it from. Make a new Java main class as shown below (save it as BookTracker.java in the same directory as your Book.java file):

要创建Book对象的实例，我们需要一个地方来创建它。 制作一个新的Java主类，如下所示(将其保存为BookTracker.java与Book.java文件位于同一目录中)：

 public class BookTracker {    public static void main(String[] args) {    } }

To create an instance of the Book object we use the "new" keyword as follows:

要创建Book对象的实例，我们使用“ new”关键字，如下所示：

 public class BookTracker {    public static void main(String[] args) {      Book firstBook = new Book("Horton Hears A Who!","Dr. Seuss","Random House");    } }

On the left hand side of the equals sign is the object declaration. It's saying I want to make a Book object and call it "firstBook". On the right hand side of the equals sign is the creation of a new instance of a Book object. What it does is go to the Book class definition and run the code inside the constructor method. So, the new instance of the Book object will be created with the title, author and publisher fields set to "Horton Hears A Who!", "Dr Suess" and "Random House" respectively. Finally, the equals sign sets our new firstBook object to be the new instance of the Book class.

等号的左侧是对象声明。 就是说我要创建一个Book对象并将其称为“ firstBook”。 等号的右侧是Book对象的新实例的创建。 它要做的是转到Book类定义，然后在构造方法中运行代码。 因此，将创建书名对象的新实例，并将标题，作者和发布者字段分别设置为“霍顿听见某人！”，“苏斯博士”和“随机屋”。 最后，等号将我们的新firstBook对象设置为Book类的新实例。

Now let's display the data in firstBook to prove that we really did create a new Book object. All we have to do is call the object's displayBookData method:

现在，让我们在firstBook中显示数据以证明我们确实创建了一个新的Book对象。 我们要做的就是调用对象的displayBookData方法：

 public class BookTracker {    public static void main(String[] args) {      Book firstBook = new Book("Horton Hears A Who!","Dr. Seuss","Random House");      firstBook.displayBookData();    } }

The result is:Title: Horton Hears A Who!Author: Dr. SeussPublisher: Random House

结果是：标题：霍顿听到了谁！作者：苏斯博士出版者：兰登书屋

多个物件 ( Multiple Objects )

Now we can begin to see the power of objects. I could extend the program:

现在我们可以开始看到物体的力量了。 我可以扩展程序：

 public class BookTracker {    public static void main(String[] args) {      Book firstBook = new Book("Horton Hears A Who!","Dr. Seuss","Random House");      Book secondBook = new Book("The Cat In The Hat","Dr. Seuss","Random House");      Book anotherBook = new Book("The Maltese Falcon","Dashiell Hammett","Orion");      firstBook.displayBookData();      anotherBook.displayBookData();      secondBook.displayBookData();    } }

From writing one class definition we now have the ability to create as many Book objects as we please!

通过编写一个类定义，我们现在可以根据需要创建尽可能多的Book对象！