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中，關鍵字 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("Passed Name 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 ); 
   }
}

如果我們編譯並運行上麵的程序，那麼這將產生以下結果：

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

源文件中聲明的規則：

正如本節的最後部分現在讓我們看看到源文件中聲明的規則。聲明類，import語句和包聲明在源文件時，這些規則是必不可少的。

• 隻能有一個有public類在每一個源文件。

• 源文件可以有多個非公共類。

• 公共類名應該是源文件，以及應當由 .java 在末尾附加的名稱。例如：類名是 public class Employee{} 將源文件應為 Employee.java。

• 如果類在包中定義，那麼 package 語句應該是在源文件中的第一條語句。

• 如果 import 語句都存在，那麼它們必須寫 package 語句和類聲明之間。如果冇有包（package）語句，那麼import語句應該是源文件中的第一行。

• 導入和包語句將意味著對所有現有的源文件中的類。不可能的聲明不同的 import和/或包語句不同類的源文件中。

類有幾個訪問級彆，有不同類型的類，抽象類，final類等將在訪問修飾符章解釋這些。

除了上述類型的類，Java也有一些特殊的類稱為內部類和匿名類。

Java包：

簡單地，它是分類的類和接口的方式。在開發Java應用程序中，數以百計的類和接口將會被寫入，因此，分類這些類是必須的。

import語句：

在Java中，如果一個完全合格的名稱，其中包括包和類名，變量的話，編譯器可以很容易地找到源代碼或類。 import語句是給予適當的位置，是編譯器發現，特定的類的方法。

例如，下麵的行會要求編譯器來加載所有目錄中 java安裝/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 :> vi EmployeeTest.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應用程序時使用它們。