对象和类（Object & Classes）

优质

小牛编辑

119浏览

2023-12-01

Java是面向对象的语言。作为具有面向对象功能的语言，Java支持以下基本概念 -

Polymorphism
Inheritance
Encapsulation
Abstraction
Classes
Objects
Instance
Method
消息解析

在本章中，我们将研究概念 - 类和对象。

Object - 对象具有状态和行为。例如:一只狗的状态 - 颜色，名称，品种以及行为 - 摇尾巴，吠叫，吃东西。对象是类的实例。
Class - 可以将类定义为描述其类型对象支持的行为/状态的模板/蓝图。

Java中的对象

现在让我们深入了解什么是对象。如果我们考虑现实世界，我们可以在我们周围找到许多物体，汽车，狗，人等等。所有这些物体都有状态和行为。

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

如果将软件对象与实际对象进行比较，则它们具有非常相似的特征。

软件对象也具有状态和行为。软件对象的状态存储在字段中，行为通过方法显示。

因此，在软件开发中，方法对对象的内部状态进行操作，并且对象到对象的通信是通过方法完成的。

Java中的类

类是创建单个对象的蓝图。

以下是一个class的样本。

例子 (Example)

public class Dog {
   String breed;
   int age;
   String color;
   void barking() {
   }
   void hungry() {
   }
   void sleeping() {
   }
}

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

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

一个类可以有多种方法来访问各种方法的值。在上面的例子中，barking（），hungry（）和sleeping（）是方法。

以下是在查看Java语言类时需要讨论的一些重要主题。

构造函数 (Constructors)

在讨论类时，最重要的子主题之一是构造函数。每个类都有一个构造函数。如果我们没有为类显式编写构造函数，Java编译器会为该类构建一个默认构造函数。

每次创建新对象时，都将调用至少一个构造函数。构造函数的主要规则是它们应该与类具有相同的名称。一个类可以有多个构造函数。

以下是构造函数的示例 -

例子 (Example)

public class Puppy {
   public Puppy() {
   }
   public Puppy(String name) {
      // This constructor has one parameter, <i>name</i>.
   }
}

Java还支持Singleton Classes ，您只能创建一个类的实例。

Note - 我们有两种不同类型的构造函数。我们将在后续章节中详细讨论构造函数。

创建一个对象

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

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

Declaration - 具有变量名称和对象类型的变量声明。
Instantiation - 'new'关键字用于创建对象。
Initialization - 'new'关键字后跟对构造函数的调用。此调用初始化新对象。

以下是创建对象的示例 -

例子 (Example)

public class Puppy {
   public Puppy(String name) {
      // This constructor has one parameter, <i>name</i>.
      System.out.println("Passed Name is :" + name );
   }
   public static void main(String []args) {
      // Following statement would create an object myPuppy
      Puppy myPuppy = new Puppy( "tommy" );
   }
}

如果我们编译并运行上面的程序，那么它将产生以下结果 -

输出 (Output)

Passed Name is :tommy

访问实例变量和方法

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

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

此示例说明如何访问类的实例变量和方法。

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 );
   }
}

如果我们编译并运行上面的程序，那么它将产生以下结果 -

输出 (Output)

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

源文件声明规则

作为本节的最后一部分，我们现在来看一下源文件声明规则。在源文件中声明类， import语句和package语句时，这些规则是必不可少的。

每个源文件只能有一个公共类。
源文件可以有多个非公共类。
公共类名称也应该是源文件的名称，最后应该用.java附加。例如:类名是public class Employee{}那么源文件应该是Employee.java。
如果在包内定义了类，则package语句应该是源文件中的第一个语句。
如果存在import语句，则必须在package语句和类声明之间写入它们。如果没有package语句，则import语句应该是源文件中的第一行。
import和package语句将暗示源文件中存在的所有类。无法将不同的import和/或package语句声明为源文件中的不同类。

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

除了上面提到的类之外，Java还有一些叫做Inner类和Anonymous类的特殊类。

Java包

简单来说，它是一种对类和接口进行分类的方法。在用Java开发应用程序时，将编写数百个类和接口，因此必须对这些类进行分类，以使生活变得更加容易。

导入语句

在Java中，如果给出了包含包和类名的完全限定名称，则编译器可以轻松找到源代码或类。 Import语句是一种为编译器提供正确位置以查找特定类的方法。

例如，以下行将要求编译器加载目录java_installation/java/io中可用的所有类 -

import java.io.*;

一个简单的案例研究

对于我们的案例研究，我们将创建两个类。它们是Employee和EmployeeTest。

首先打开记事本并添加以下代码。请记住，这是Employee类，类是公共类。现在，使用名称Employee.java保存此源文件。

Employee类有四个实例变量 - 名称，年龄，名称和工资。该类有一个显式定义的构造函数，它接受一个参数。

例子 (Example)

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

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

将以下代码保存在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以查看结果如下 -

输出 (Output)

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

接下来是什么 (What is Next?)

在下一个会话中，我们将讨论Java中的基本数据类型以及在开发Java应用程序时如何使用它们。