Java 简明教程

Java - Classes and Objects

Java 是一种面向对象的编程语言。在 Java 中， classes and objects 是面向对象编程系统中的重要基础特性，Java 支持以下基础 OOPs concepts -

Classes
Objects
Inheritance
Polymorphism
Encapsulation
Abstraction
Instance
Method
Message Passing

在本教程中，我们将了解 Java 类和对象，创建类和对象，访问类方法等。

What are Java Classes?

class 是用于创建单个对象的蓝图（或者可以称之为一个类的 data type 对象类型）。在 Java 中，所有内容都与类和对象相关。每个类都有可以通过对象访问和操作的 methods 和 attributes 。

例如，如果您希望为学生创建课程。这种情况下，“Student”将是一个课程，而学生记录（例如 student1、student2 等）将成为对象。

我们还可以认为课程是可以用于生成对象的工厂（用户定义的蓝图）。

Properties of Java Classes

类不占用任何字节的内存。
类就像一个真实世界的实体，但它不是真实世界的实体。这是一个蓝图，我们在此指定功能。
类主要包含两件事：方法和数据成员。
类也可以是嵌套类。
类遵循所有面向对象编程规则，例如继承、封装、抽象等。

Types of Class Variables

课程可以包含任何以下变量类型。

Local variables − 在方法、构造函数或块内定义的变量称为局部变量。变量将在方法内声明和初始化，并且在方法完成后销毁变量。
Instance variables − 实例变量是课程内的变量，但在任何方法的外部。这些变量在实例化课程时初始化。可以从特定课程的任何方法、构造函数或块内访问实例变量。
Class variables − 类变量是使用 static 关键字在课程内声明的变量，位于任何方法外部。

Creating (Declaring) a Java Class

要创建（声明）一个类，需要使用 access modifiers ，后跟类关键字和类名。

Syntax to create a Java class

用以下语法在 Java 中创建（声明）类：

access_modifier class class_name{
  data members;
  constructors;
  methods;
  ...;
}

Example of a Java Class

在这个例子中，我们创建了一个课程“Dog”。类属性包括 breed、age 和 color。类方法是 setBreed()、setAge()、setColor() 和 printDetails()。

// Creating a Java class
class Dog {
  // Declaring and initializing the attributes
  String breed;
  int age;
  String color;

  // methods to set breed, age, and color of the dog
  public void setBreed(String breed) {
    this.breed = breed;
  }
  public void setAge(int age) {
    this.age = age;
  }
  public void setColor(String color) {
    this.color = color;
  }

  // method to print all three values
  public void printDetails() {
    System.out.println("Dog detials:");
    System.out.println(this.breed);
    System.out.println(this.age);
    System.out.println(this.color);
  }
}

What are Java Objects?

object 是类型为 class 的变量，是面向对象编程系统的一个基本组件。一个类拥有方法和数据成员（属性），这些方法和数据成员是通过一个 object 访问的。因此，对象是一个类的实例。

如果我们考虑真实世界，我们可以发现周围有很多对象，如汽车、狗、人等。所有这些对象都有状态和行为。

如果我们考虑一只狗，那么它的状态是名称、品种和颜色，而行为是吠叫、摇尾巴和奔跑。

如果您比较软件对象和真实世界对象，它们拥有非常类似的特征。软件对象也有状态和行为。软件对象的状态存储在字段中，而行为通过方法显示。因此，在软件开发中，方法操作对象内部状态，而对象间的通信是通过方法完成的。

Creating (Declaring) a Java Object

正如之前提到的，一个类为对象提供蓝图。所以基本上，一个对象是从一个类创建的。在 Java 中，使用 new 关键字创建新对象。

从一个类创建对象时有三个步骤 −

Declaration − 使用对象类型和变量名称声明一个变量。
Instantiation − 使用“new”关键字创建对象。
Initialization − 在“new”关键字后面调用一个构造函数。此调用初始化新对象。

Syntax to Create a Java Object

请考虑以下语法在 Java 中创建课程对象：

Class_name object_name = new Class_name([parameters]);

注：参数是可选的，可以在类中使用 constructors 时使用。

Example to Create a Java Object

在这个示例中，我们正在创建一个名为 obj 的 Dog 类对象并访问其方法。

// Creating a Java class
class Dog {
  // Declaring and initializing the attributes
  String breed;
  int age;
  String color;

  // methods to set breed, age, and color of the dog
  public void setBreed(String breed) {
    this.breed = breed;
  }
  public void setAge(int age) {
    this.age = age;
  }
  public void setColor(String color) {
    this.color = color;
  }

  // method to print all three values
  public void printDetails() {
    System.out.println("Dog detials:");
    System.out.println(this.breed);
    System.out.println(this.age);
    System.out.println(this.color);
  }
}

public class Main {
  public static void main(String[] args) {
    // Creating an object of the class Dog
    Dog obj = new Dog();

    // setting the attributes
    obj.setBreed("Golden Retriever");
    obj.setAge(2);
    obj.setColor("Golden");

    // Printing values
    obj.printDetails();
  }
}

Dog detials:
Golden Retriever
2
Golden

Accessing Instance Variables and Methods

实例变量和方法可以通过创建对象来访问。要访问实例变量，以下是完全限定路径 −

/* First create an object */
ObjectReference = new Constructor();

/* Now call a variable as follows */
ObjectReference.variableName;

/* Now you can call a class method as follows */
ObjectReference.MethodName();

Example

在这个示例中，我们创建了一个名为 Puppy 的类。在 Puppy 类构造函数中，打印小狗的名字，以便在创建对象时打印其名字。添加了实例变量 puppyAge，并且可以使用 getter/setter 方法来处理年龄。在 main 方法中，使用 new 运算符创建一个对象。使用 setAge() 方法更新年龄，并且使用 getAge()，打印年龄。

public class Puppy {
   int puppyAge;

   public Puppy(String name) {
      // This constructor has one parameter, <i>name</i>.
      System.out.println("Name chosen is :" + name );
   }

   public void setAge( int age ) {
      puppyAge = age;
   }

   public int getAge( ) {
      System.out.println("Puppy's age is :" + puppyAge );
      return puppyAge;
   }

   public static void main(String []args) {
      /* Object creation */
      Puppy myPuppy = new Puppy( "tommy" );

      /* Call class method to set puppy's age */
      myPuppy.setAge( 2 );

      /* Call another class method to get puppy's age */
      myPuppy.getAge( );

      /* You can access instance variable as follows as well */
      System.out.println("Variable Value :" + myPuppy.puppyAge );
   }
}

如果我们编译并运行以上程序，它将产生以下结果 −

Name chosen is :tommy
Puppy's age is :2
Variable Value :2

Rules for using the Classes and Objects Concepts

现在，让我们了解源文件声明规则（使用 Java 类和对象方法）。在源文件中声明类、导入语句和包语句时，这些规则至关重要。

每个源文件只能有一个 public 类。
一个源文件可以有多个非 public 类。
public 类名也应该是源文件的名字，而且后面应该附加 .java。例如，类名为 public class Employee{}，则源文件也应该是 Employee.java。
如果类在包中定义，则包语句应该是源文件中的第一个语句。
如果存在 import 语句，则它们必须写在包语句和类声明之间。如果不存在包语句，则 import 语句应该是源文件中的第一行。
import 和包语句将适用于源文件中存在的所有类。不可能在源文件中对不同的类声明不同的 import 和/或包语句。

类有几个不同的访问级别，还有不同的类型，如抽象类、final 类等。我们将在访问修饰符章节中解释所有这些。

除了上述类型的类之外，Java 还有一些称为内部类和匿名类的特殊类。

More Examples on Java Classes and Objects

Example 1

Employee 类有四个实例变量：name、age、designation 和 salary。该类有一个明确定义的构造函数，它接受一个参数。

import java.io.*;
public class Employee {

   String name;
   int age;
   String designation;
   double salary;

   // This is the constructor of the class Employee
   public Employee(String name) {
      this.name = name;
   }

   // Assign the age of the Employee  to the variable age.
   public void empAge(int empAge) {
      age = empAge;
   }

   /* Assign the designation to the variable designation.*/
   public void empDesignation(String empDesig) {
      designation = empDesig;
   }

   /* Assign the salary to the variable	salary.*/
   public void empSalary(double empSalary) {
      salary = empSalary;
   }

   /* Print the Employee details */
   public void printEmployee() {
      System.out.println("Name:"+ name );
      System.out.println("Age:" + age );
      System.out.println("Designation:" + designation );
      System.out.println("Salary:" + salary);
   }
}

正如本教程中前面提到的，处理从 main 方法开始。因此，为了让我们运行这个 Employee 类，应该有一个 main 方法并且应该创建对象。我们为这些任务创建一个单独的类。

Example 2

以下是 EmployeeTest 类，它创建两个 Employee 类实例，并为每个对象调用方法来为每个变量分配值。

将以下代码保存在 EmployeeTest.java 文件中。

import java.io.*;
public class EmployeeTest {

   public static void main(String args[]) {
      /* Create two objects using constructor */
      Employee empOne = new Employee("James Smith");
      Employee empTwo = new Employee("Mary Anne");

      // Invoking methods for each object created
      empOne.empAge(26);
      empOne.empDesignation("Senior Software Engineer");
      empOne.empSalary(1000);
      empOne.printEmployee();

      empTwo.empAge(21);
      empTwo.empDesignation("Software Engineer");
      empTwo.empSalary(500);
      empTwo.printEmployee();
   }
}

现在，编译这两个类，然后运行 EmployeeTest 以查看结果，如下所示 −

C:\> javac Employee.java
C:\> javac EmployeeTest.java
C:\> java EmployeeTest
Name:James Smith
Age:26
Designation:Senior Software Engineer
Salary:1000.0
Name:Mary Anne
Age:21
Designation:Software Engineer
Salary:500.0