Java - 类和对象

---

---

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

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

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

什么是 Java 类？

一个类是一个蓝图，从中创建单个对象（或者，我们可以说类是对象类型的一种数据类型）。在 Java 中，一切都是与类和对象相关的。每个类都有其可以方法和属性，可以通过对象访问和操作。

例如，如果您想为学生创建一个类。在这种情况下，“学生”将是一个类，而学生记录（如student1、student2 等）将是对象。

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

Java 类的属性

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

类变量的类型

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

• 局部变量 - 在方法、构造函数或块内定义的变量称为局部变量。变量将在方法中声明和初始化，并且当方法完成时变量将被销毁。

• 实例变量 - 实例变量是类中的变量，但在任何方法之外。当类被实例化时，这些变量被初始化。实例变量可以从该特定类的任何方法、构造函数或块中访问。

• 类变量 - 类变量是在类中声明的变量，在任何方法之外，使用 static 关键字。

创建（声明）Java 类

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

创建 Java 类的语法

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

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

Java 类的示例

在这个例子中，我们创建了一个名为`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);
  }
}

什么是Java对象？

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

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

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

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

创建（声明）Java对象

如前所述，类为对象提供了蓝图。因此，基本上，对象是由类创建的。在Java中，`new`关键字用于创建新对象。

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

• 声明——声明一个变量，该变量具有对象类型和变量名。

• 实例化——使用'new'关键字创建对象。

• 初始化——'new'关键字后跟对构造函数的调用。此调用初始化新对象。

创建Java对象的语法

考虑以下在Java中创建类对象的语法：

Class_name object_name = new Class_name([parameters]);

注意：参数是可选的，在使用类中的构造函数时可以使用。

创建Java对象的示例

在这个例子中，我们创建了一个名为`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

访问实例变量和方法

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

/* 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();

示例

在这个例子中，我们创建了一个名为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

使用类和对象概念的规则

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

• 每个源文件只能包含一个公共类。

• 源文件可以包含多个非公共类。

• 公共类名也应该与源文件名相同，并在末尾附加.java。例如：类名为public class Employee{}，则源文件应为Employee.java。

• 如果类在包内定义，则包语句应为源文件中的第一条语句。

• 如果存在导入语句，则必须将它们写在包语句和类声明之间。如果没有包语句，则导入语句应为源文件中的第一行。

• 导入和包语句将应用于源文件中存在的所有类。不可能对源文件中的不同类声明不同的导入和/或包语句。

类具有多个访问级别，并且存在不同类型的类；抽象类、最终类等。我们将在访问修饰符章节中解释所有这些。

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

更多关于Java类和对象的示例

示例1

Employee类有四个实例变量——姓名、年龄、职位和薪水。该类有一个显式定义的构造函数，它接受一个参数。

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方法，并且应该创建对象。我们将为这些任务创建一个单独的类。

示例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