认识达内从这里开始

Java对象和类有哪些？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也支持单例类，你可以只创建一个类的一个实例。

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

java中创建一个对象

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

从一个类创建一个对象有三个步骤-

声明（Declaration）-一个带有变量名称和对象类型的变量声明。

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

初始化-“新”关键字后面是对构造函数的调用。这个调用初始化新的对象。

以下是创建一个对象的例子-

例

 现场演示

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

源文件声明规则

作为本节的最后一部分，现在让我们看看源文件声明规则。在源文件中声明类，导入语句和包语句时，这些规则是必不可少的。

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

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

公共类名应该是源文件的名称，并且最后应该由.java附加。例如：类名是公共类Employee {}，那么源文件应该是Employee.java。

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

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

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

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

除了上面提到的类以外，Java还有一些特殊的类，叫做Inner classes和Anonymous classes。

Java包

简而言之，它是对类和接口进行分类的一种方法。在Java中开发应用程序时，将会编写数百个类和接口，因此对这些类进行分类是必须的，而且使生活变得更加容易。

进口报表

在Java中，如果给出了包含包和类名的完全限定名，那么编译器可以很容易地找到源代码或类。导入语句是为编译器提供适当位置以找到特定类的一种方式。

例如，以下代码行会要求编译器加载目录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);

  }

}

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

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