📜  Java-对象和类

📅  最后修改于: 2020-11-15 04:13:04             🧑  作者: 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应用程序时如何使用它们。