• Java 视频教程

Java - 对象和类

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

  • 多态性
  • 遗产
  • 封装
  • 抽象
  • 课程
  • 对象
  • 实例
  • 方法
  • 消息传递

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

  • 对象- 对象具有状态和Behave。示例：狗有状态 - 颜色、名称、品种以及Behave - 摇尾巴、吠叫、吃东西。对象是类的实例。

  • 类- 类可以定义为模板/蓝图，描述其类型的对象支持的Behave/状态。

Java 中的对象

现在让我们深入了解一下什么是对象。如果我们考虑现实世界，我们可以发现我们周围有很多物体，汽车、狗、人等等。所有这些物体都有状态和Behave。

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

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

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

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

Java 中的类

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

以下是一个类的示例。

例子

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

   void barking() {
   }

   void hungry() {
   }

   void sleeping() {
   }
}

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

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

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

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

一个类可以有任意数量的方法来访问各种方法的值。在上面的例子中，barking()、hungry() 和 sleep() 都是方法。

以下是研究 Java 语言的类时需要讨论的一些重要主题。

构造函数

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

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

以下是构造函数的示例 -

例子

public class Puppy {
   public Puppy() {
   }

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

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

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

创建对象

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

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

  • 声明- 具有变量名和对象类型的变量声明。

  • 实例化-“new”关键字用于创建对象。

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

以下是创建对象的示例 -

例子

在此示例中，我们创建了一个名为 Puppy 的类。在 Puppy 类构造函数中，会打印 puppy 名称，以便在创建对象时打印其名称。在 main 方法中，使用 new 运算符创建对象。

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

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

输出

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

例子

在此示例中，我们创建了一个名为 Puppy 的类。在 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 。例如 - 类名称是public class Employee{}那么源文件应该是 Employee.java。

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

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

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

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

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

Java包

简而言之，它是一种对类和接口进行分类的方法。在使用 Java 开发应用程序时，将编写数百个类和接口，因此对这些类进行分类是必须的，并且可以使工作变得更加轻松。

进口声明

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

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

import java.io.*;

一个简单的案例研究

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

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

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

下面是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

下一步是什么？

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