以下內容引用自http://wiki.jikexueyuan.com/project/java/object-classes.html：

一、概述

Java是一種面向對象的語言。作為一種具有面向對象特征的語言，Java包括以下幾項基本概念：

• 多態性
• 繼承性
• 封裝性
• 抽象性
• 類
• 對象
• 實例
• 消息解析

什麽是類和對象：

• 對象：對象具有狀態和行為。比如現實世界的：小汽車，狗，人類等等。所有這些對象都具有狀態和行為。
• 類：類可以被定義為描述對象支持類型的行為、狀態的的模板、藍圖。

二、Java中的對象

如果考慮一條狗，那麽它的狀態就是：名字，品種，顏色，它的行為就是汪汪，搖尾巴，跑。

如果將軟件中的對象和現實世界中的對象對比，那麽會發現他們有很多相似的特征。軟件中的對象也具有狀態和行為。軟件的狀態被儲存在文件中，它的行為通過方法來表現。

因此，在軟件發展過程中方法控制對象的內在狀態並且對象和對象間的交流是通過方法來完成的。

三、Java中的類

類是有獨立的對象創造出的藍圖。

下面給出了一個類的例子：

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

   void barking(){
   }

   void hungry(){
   }

   void
 
 sleeping(){
   }
}

類可以包括以下的變量類型：

• 局部變量：在方法，構造器或區域中定義的變量成為局部變量。變量將會在方法內產生和發展，然後當方法結束變量就會破壞。
• 實例變量：實例變量是在類內，但是在方法外的變量。這些變量是當類被裝載時被實體化的。實例變量可以是從特定類的任何方法，構造器，區域中存取。
• 類變量：類變量是在類中聲明的變量，它處在任何方法之外，有靜態關鍵字。

類可以由任意數量的方法來存取不同種類方法的值。在上面的例子中，barking()，hungry()和sleeping()是方法。

四、構造器

每一個類都有一個構造器。如果不單獨為一個類編寫構造器那麽Java的編譯器將會給這個類建立一個默認的構造器。

每當一個新的對象被創建，至少一個構造器將會被調用。構造器的一個最主要的原則就是他們必須和類有同樣的名字。一個類可以有不止一個構造器。並且沒有返回值。

下面給出了一個構造器的例子：

public class Puppy{
   public Puppy(){
   }

   public Puppy(String name){
   }
}

在需要只創建一個類的實例的時，Java也支持單例。

五、創造一個對象

如前所述，類為對象提供了藍圖。因此基本來說一個對象是從一個類中創造出來的。在Java中，新的關鍵詞被用來創造新的對象。創建類的步驟如下：

• 聲明：變量聲明可以聲明其所代表的對象類型。
• 實例化：“新的”關鍵詞用來創造對象。
• 初始化：“新的”關鍵詞伴隨著一個構造器的啟用，這個將新的對象初始化。

下面給出了一個創造對象的例子：

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

七、源文件聲明規則

當在源文件中聲明類，輸入和打包語法時，這些規則是十分重要的。

• 每個源文件中只能有一個公共類。
• 一個源文件可以有很多非公共類。
• 公共類的名稱必須是源文件的名稱同時也要以.java為後綴。舉例來說：類的名稱是public class Employee{}，那麽源文件就應該是Employee.java。
• 如果類是在一個程序包中定義的，那麽程序包的聲明必須是源文件的第一個聲明。
• 如果輸入聲明出現那麽他們必須被寫在封裝聲明和類聲明之間。如果沒有封裝聲明那麽輸入聲明必須在源文件的第一行。
• 輸入和打包聲明會暗示所有源文件中的存在的類。在源文件中很難為不同的類區分輸入和封裝聲明。
  類有不同的訪問級別並且有很多不同的類；抽象的類，最終的類等等。
  除了以上提到的類的類型之外，Java也有像內部類和匿名類這樣的特殊類。

八、Java程序包

簡而言之，就是一種對類和接口進行分類的一種方法。當用Java開發程序時，數百個類和接口會被編寫，因此對這些類進行分類是必須的，而且也會使問題變得容易。

九、Import語法

在Java中，如果給出包括封裝和類的名稱的全限定名，那麽編譯器很容易定位到源類和源代碼。Import語法是給編譯器尋找特定類的適當位置的一種方法。

舉例來說，下面這行語句將會要求編譯器去裝載java_installation/java/io路徑下的所有可用的類:

import java.io.*;

十、一個簡單的案例

下面將創建兩個類：Employee和EmployeeTest。

這個Employee類包括四個實體變量姓名（name），年齡（age），職位（designation）和薪水（salary）。這個類有一個確定的且需要參數的構造器。

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類的實例，並且為每個對象調用方法從而給每個變量賦值。

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

測試工程：https://github.com/easonjim/5_java_example/tree/master/javabasicstest/test2

Java的對象和類