Java - 对象和类

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

  • Polymorphism

  • 继承

  • 封装

  • 抽象

  • 课程

  • 对象

  • 实例

  • 方法

  • 消息传递

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

  • 对象 : 对象具有状态和行为.例如:一只狗的状态 - 颜色,名称,品种以及行为 - 摇尾巴,吠叫,吃东西.对象是类的实例.

  • 类 : 可以将类定义为模板/蓝图,描述其类型对象支持的行为/状态.

Java中的对象

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

如果我们考虑一只狗,然后它的状态是 - 名称,品种,颜色,行为是 - 吠叫,摇尾巴,跑步.

如果你将软件对象与真实世界的对象进行比较,具有非常相似的特征.

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

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

Java中的类

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

以下是一个班级的样本.

示例

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

   void barking() {
   }

   void hungry() {
   }

   void sleeping() {
   }
}

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

  • 本地变量 : 在方法,构造函数或块中定义的变量称为局部变量.变量将在方法中声明和初始化,并且当方法完成时变量将被销毁.

  • 实例变量&minus ;实例变量是类中的变量,但在任何方法之外.在实例化类时初始化这些变量.可以从该特定类的任何方法,构造函数或块内部访问实例变量.

  • 类变量 : 类变量是在类中,在任何方法之外使用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.

  • 如果class在包内定义,然后package语句应该是源文件中的第一个语句.

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

  • 导入和包语句将暗示存在的所有类在源文件中.无法向源文件中的不同类声明不同的import和/或package语句.

类具有多个访问级别,有不同类型的课程;我们将在访问修饰符章节中解释所有这些.

除了上面提到的类类型,Java还有一些叫做Inner类的特殊类.和匿名类.

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应用程序时如何使用它们.