Java 类和对象

Java 是一种面向对象的编程语言。在 Java 中，类和对象是面向对象编程系统的基本且重要的特性，Java 支持以下基本的 OOPs 概念：

类
对象
继承
多态性
封装
抽象
实例
方法
消息传递

在本教程中，我们将学习 Java 中的类和对象，类和对象的创建，以及如何访问类的方法等。

什么是 Java 类？

类是个体对象创建的蓝图（或者说类是对象类型的数据类型）。在 Java 中，一切事物都与类和对象有关。每个类都有其可以通过对象访问和操控的方法和属性。

例如，如果你想创建一个学生类。那么，“学生”就是一个类，而学生的记录（如 student1, student2 等）就是对象。

我们也可以认为类是一个工厂（用户定义的蓝图）来生产对象。

Java 类的特性

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

创建（声明）Java 类

要创建（声明）一个类，你需要使用访问修饰符后跟 class 关键字和类名。

创建 Java 类的语法：

access_modifier class class_name{
  数据成员;
  构造函数;
  方法;
  ...
}

Java 类的例子

在这个例子中，我们创建了一个名为 "Dog" 的类。类的属性是 breed, age 和 color。类的方法是 setBreed(), setAge(), setColor() 和 printDetails()。

class Dog {
  String breed;
  int age;
  String color;

  public void setBreed(String breed) {
    this.breed = breed;
  }
  public void setAge(int age) {
    this.age = age;
  }
  public void setColor(String color) {
    this.color = color;
  }

  public void printDetails() {
    System.out.println("Dog details:");
    System.out.println(this.breed);
    System.out.println(this.age);
    System.out.println(this.color);
  }
}

什么是 Java 对象？

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

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

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

如果你将软件对象与现实世界中的对象进行比较，它们具有非常相似的特点。软件对象也有状态和行为。软件对象的状态存储在字段中，并通过方法显示行为。因此，在软件开发中，方法操作对象的内部状态，对象间的通信是通过方法完成的。

创建（声明）Java 对象

如前所述，类提供了对象的蓝图。所以基本上，对象是从类创建的。在 Java 中，使用 new 关键字创建新对象。

从类创建对象有三个步骤：

声明 — 使用带有对象类型的变量名进行声明。
实例化 — 使用 'new' 关键字创建对象。
初始化 — 在 'new' 关键字后调用构造函数初始化新对象。

创建 Java 对象的语法：

Class_name object_name = new Class_name([参数]);

Java 对象的例子

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

class Dog {
  String breed;
  int age;
  String color;

  public void setBreed(String breed) {
    this.breed = breed;
  }
  public void setAge(int age) {
    this.age = age;
  }
  public void setColor(String color) {
    this.color = color;
  }

  public void printDetails() {
    System.out.println("Dog details:");
    System.out.println(this.breed);
    System.out.println(this.age);
    System.out.println(this.color);
  }
}

public class Main {
  public static void main(String[] args) {
    Dog obj = new Dog();
    obj.setBreed("Golden Retriever");
    obj.setAge(2);
    obj.setColor("Golden");
    obj.printDetails();
  }
}

输出结果：

Dog details:
Golden Retriever
2
Golden

访问实例变量和方法

实例变量和方法是通过创建的对象访问的。要访问一个实例变量，以下是完整的路径：

/* 首先创建一个对象 */
ObjectReference = new Constructor();

/* 现在按照如下方式调用变量 */
ObjectReference.variableName;

/* 现在你可以按照如下方式调用类的方法 */
ObjectReference.MethodName();

示例

在这个示例中，我们创建了一个名为 Puppy 的类。在 Puppy 类的构造函数中打印出小狗的名字，以便当对象创建时，它的名字会被打印出来。添加了一个实例变量 puppyAge 并使用 getter/setter 方法来操纵年龄。在 main 方法中，使用 new 操作符创建一个对象。使用 setAge() 方法更新年龄，并使用 getAge() 打印年龄。

public class Puppy {
   int puppyAge;

   public Puppy(String name) {
      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) {
      Puppy myPuppy = new Puppy("tommy");
      myPuppy.setAge(2);
      myPuppy.getAge();
      System.out.println("Variable Value :" + myPuppy.puppyAge);
   }
}

输出结果：

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

使用类和对象概念的规则

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

每个源文件只能有一个公共类。
源文件可以包含多个非公共类。
公共类名应该是源文件的名称，并且应该以 .java 结尾。例如，如果类名为 public class Employee{}，那么源文件应为 Employee.java。
如果类定义在一个包内，则包声明应为源文件中的第一条语句。
如果存在导入语句，则它们必须写在包声明和类声明之间。如果没有包声明，则导入语句应为源文件的第一行。
导入和包声明适用于源文件中的所有类。不可能为源文件中的不同类声明不同的导入和/或包声明。
类有不同的访问级别并且有不同类型如抽象类、最终类等。我们将在访问修饰符章节中解释所有这些。
除了上述类型的类外，Java 还有一些特殊的类称为内部类和匿名类。

下面给出的是两个关于 Java 类和对象的具体示例。

示例 1

Employee 类拥有四个实例变量——name, age, designation 和 salary。类中定义了一个构造器，它接受一个参数。

import java.io.*;

public class Employee {

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

    // 这是 Employee 类的构造器
    public Employee(String name) {
        this.name = name;
    }

    // 分配员工的年龄到变量 age
    public void empAge(int empAge) {
        age = empAge;
    }

    // 分配职称到变量 designation
    public void empDesignation(String empDesig) {
        designation = empDesig;
    }

    // 分配工资到变量 salary
    public void empSalary(double empSalary) {
        salary = empSalary;
    }

    // 打印员工详情
    public void printEmployee() {
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
        System.out.println("Designation: " + designation);
        System.out.println("Salary: " + salary);
    }
}

如本教程前面所述，处理从主方法开始。因此，为了运行此 Employee 类，需要有一个主方法并且应创建对象。我们将为这些任务创建一个单独的类。

示例 2

下面是 EmployeeTest 类，它创建了 Employee 类的两个实例，并调用每个对象的方法来为每个变量赋值。

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

import java.io.*;

public class EmployeeTest {

    public static void main(String args[]) {
        // 使用构造器创建两个对象
        Employee empOne = new Employee("James Smith");
        Employee empTwo = new Employee("Mary Anne");

        // 调用每个创建的对象的方法
        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

这个例子展示了如何创建类、定义构造器、设置实例变量以及通过实例对象调用方法来获取输出。通过 EmployeeTest 类中的 main 方法创建了两个 Employee 对象，并且分别为它们分配了不同的属性值，最后打印出了每个员工的信息。