Java 类和对象

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

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

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

Java 类

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

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

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

Java 类的属性

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

Java 类变量的类型

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

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

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

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

创建（声明）Java 类

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

创建 Java 类的语法

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

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

Java 类示例

在此示例中，我们创建一个类"Dog"。其中，类属性为 breed、age 和 color 。类方法有 setBreed()、setAge()、 setColor() 和 printDetails()。

//创建Java类
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 detials:");
    System.out.println(this.breed);
    System.out.println(this.age);
    System.out.println(this.color);
  }
}

Java 对象

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

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

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

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

创建（声明）Java 对象

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

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

  • 声明 - 带有对象类型的变量名称的变量声明。

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

  • 初始化 - 后面跟着'new'关键字通过调用构造函数。此调用初始化新对象。

创建 Java 对象的语法

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

Class_name object_name = new Class_name([parameters]);

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

创建 Java 对象的示例

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

//创建Java类
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 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) {
    //创建 Dog 类的对象
    Dog obj = new Dog();

    //设置属性
    obj.setBreed("Golden Retriever");
    obj.setAge(2);
    obj.setColor("Golden");

    //打印值
    obj.printDetails();
  }
}

输出

Dog detials:
Golden Retriever
2
Golden

访问实例变量和方法

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

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

/* 调用一个变量 */
ObjectReference.variableName;

/* 调用方法 */
ObjectReference.MethodName();

示例

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

public class Puppy {
   int puppyAge;

   public Puppy(String name) {
      //该构造函数有一个参数，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" );

      /* set age 方法 */
      myPuppy.setAge( 2 );

      /* get age方法 */
      myPuppy.getAge( );

      /* 打印 */
      System.out.println("Variable Value :" + myPuppy.puppyAge );
   }
}

输出

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

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

使用类和对象概念的规则

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

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

  • 一个源文件可以有多个非公共类。

  • 公共类名称应该是源文件的名称，如下所示那么应该在末尾附加 .java 。例如 - 类名称是 public class Employee{} 则源文件应为 Employee.java。

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

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

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

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

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

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

示例 1

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

import java.io.*;

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

示例 2

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

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

import java.io.*;
public class Employee {

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

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

   //将Employee的年龄赋给变量age。
   public void empAge(int empAge) {
      age = empAge;
   }

   /* 分配变量名.*/
   public void empDesignation(String empDesig) {
      designation = empDesig;
   }

   /* 分配变量名.*/
   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);
   }
}

输出

现在，编译类，然后运行 EmployeeTest 查看结果如下 

import java.io.*;
public class EmployeeTest {

   public static void main(String args[]) {
      /* 创建2个对象 */
      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();
   }
}