Java-对象和类 - 芒果文档

📌 相关文章

📜 Java-对象和类

📅 最后修改于: 2020-12-21 01:32:06 🧑 作者: Mango

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

多态性
遗产
封装形式
抽象化
班级
对象
实例
方法
讯息传递

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

对象-对象具有状态和行为。例如：一条狗有状态-颜色，名字，品种和行为-摇尾巴，吠叫，进食。对象是类的实例。
类-可以将类定义为描述其类型的对象支持的行为/状态的模板/蓝图。

Java中的对象

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

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

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

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

因此，在软件开发中，方法在对象的内部状态上运行，并且对象间的通信是通过方法进行的。

Java类

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

以下是一个类的示例。

例

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

   void barking() {
   }

   void hungry() {
   }

   void sleeping() {
   }
}

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

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

一个类可以具有许多方法来访问各种方法的值。在上面的示例中，barking()，hungry()和sleeping()是方法。

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

建设者

在讨论类时，最重要的子主题之一是构造函数。每个类都有一个构造函数。如果我们未为类明确编写构造函数，则Java编译器将为该类建立默认构造函数。

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

以下是构造函数的示例-

例

public class Puppy {
   public Puppy() {
   }

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

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

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

创建一个对象

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

从类创建对象时，需要三个步骤-

声明-具有对象类型的变量名称的变量声明。
实例化-‘new ‘关键字用于创建对象。
初始化-关键字’new’之后是对构造函数的调用。此调用将初始化新对象。

以下是创建对象的示例-

例

现场演示

public class Puppy {
   public Puppy(String name) {
      // This constructor has one parameter, name.
      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();

例

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

现场演示

public class Puppy {
   int puppyAge;

   public Puppy(String name) {
      // This constructor has one parameter, 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) {
      /* 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

源文件声明规则

作为本节的最后一部分，现在让我们研究源文件声明规则。在源文件中声明类， import语句和package语句时，这些规则至关重要。

每个源文件只能有一个公共类。
一个源文件可以具有多个非公共类。
公共类名称也应该是源文件的名称，并且应在末尾附加.java 。例如：类名是公共类Employee {}，则源文件应为Employee.java。
如果类是在包内定义的，则package语句应为源文件中的第一条语句。
如果存在import语句，则必须在package语句和类声明之间编写它们。如果没有包语句，则import语句应该是源文件中的第一行。
导入和打包语句将隐含到源文件中存在的所有类。不可能对源文件中的不同类声明不同的import和/或package语句。

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

除了上述类型的类之外，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应用程序时如何使用它们。