3．1 面向對象技術基礎
3．1．1 面向對象的基本概念
面向對象的基本思想
面向對象是一種新興的程序設計方法,或者是一種新的程序設計規範(paradigm),其基本思想是使用對象、類、繼承、封裝、消息等基本概念來進行程序設計。從現實世界中客觀存在的事物（即對象）出發來構造軟件系統，並且在系統構造中儘可能運用人類的自然思維方式。開發一個軟件是爲了解決某些問題，這些問題所涉及的業務範圍稱作該軟件的問題域。其應用領域不僅僅是軟件，還有計算機體系結構和人工智能等。
1． 對象的基本概念
對象是系統中用來描述客觀事物的一個實體，它是構成系統的一個基本單位。一個對象由一組屬性和對這組屬性進行操作的一組服務組成。從更抽象的角度來說，對象是問題域或實現域中某些事物的一個抽象，它反映該事物在系統中需要保存的信息和發揮的作用；它是一組屬性和有權對這些屬性進行操作的一組服務的封裝體。客觀世界是由對象和對象之間的聯繫組成的。
主動對象是一組屬性和一組服務的封裝體，其中至少有一個服務不需要接收消息就能主動執行（稱作主動服務）。
2． 類的基本概念
把衆多的事物歸納、劃分成一些類是人類在認識客觀世界時經常採用的思維方法。分類的原則是抽象。類是具有相同屬性和服務的一組對象的集合，它爲屬於該類的所有對象提供了統一的抽象描述，其內部包括屬性和服務兩個主要部分。在面向對象的編程語言中，類是一個獨立的程序單位，它應該有一個類名幷包括屬性說明和服務說明兩個主要部分。類與對象的關係就如模具和鑄件的關係，類的實例化結果就是對象，而對一類對象的抽象就是類。
3． 消息
消息就是向對象發出的服務請求，它應該包含下述信息：提供服務的對象標識、服務標識、輸入信息和回答信息。服務通常被稱爲方法或函數。
3．1．2 面向對象的基本特徵
1．封裝性
封裝性就是把對象的屬性和服務結合成一個獨立的相同單位，並儘可能隱蔽對象的內部細節，包含兩個含義：
◇ 把對象的全部屬性和全部服務結合在一起，形成一個不可分割的獨立單位（即對象）。
◇ 信息隱蔽，即儘可能隱蔽對象的內部細節，對外形成一個邊界〔或者說形成一道屏障〕，只保留有限的對外接口使之與外部發生聯繫。
封裝的原則在軟件上的反映是：要求使對象以外的部分不能隨意存取對象的內部數據（屬性），從而有效的避免了外部錯誤對它的"交叉感染"，使軟件錯誤能夠局部化，大大減少查錯和排錯的難度。
2．繼承性
特殊類的對象擁有其一般類的全部屬性與服務，稱作特殊類對一般類的繼承。例如，輪船、客輪；人、大人。一個類可以是多個一般類的特殊類，它從多個一般類中繼承了屬性與服務，這稱爲多繼承。例如，客輪是輪船和客運工具的特殊類。在java語言中，通常我們稱一般類爲父類（superclass,超類），特殊類爲子類(subclass)。
3．多態性
對象的多態性是指在一般類中定義的屬性或服務被特殊類繼承之後，可以具有不同的數據類型或表現出不同的行爲。這使得同一個屬性或服務在一般類及其各個特殊類中具有不同的語義。例如："幾何圖形"的"繪圖"方法，"橢圓"和"多邊形"都是"幾何圖"的子類，其"繪圖"方法功能不同。
3．1．3 面向對象程序設計方法
OOA－Object Oriented Analysis 面向對象的分析
OOD－Object Oriented Design 面向對象的設計
OOI－Object Oriented Implementation 面向對象的實現
3．2 Java語言的面向對象特性
3．2．1 類
類是java中的一種重要的複合數據類型，是組成java程序的基本要素。它封裝了一類對象的狀態和方法，是這一類對象的原形。一個類的實現包括兩個部分：類聲明和類體。
1．類聲明：
[public][abstract|final] class className [extends superclassName] [implements interfaceNameList]
{……}
其中，修飾符public,abstract,final 說明了類的屬性，className爲類名，superclassName爲類的父類的名字，interfaceNameList爲類所實現的接口列表。
2．類體
類體定義如下：
class className
{[public | protected | private ] [static]
[final] [transient] [volatile] type
variableName; //成員變量
[public | protected | private ] [static]
[final | abstract] [native] [synchronized]
returnType methodName([paramList]) [throws exceptionList]
{statements} //成員方法
}
3．成員變量
成員變量的聲明方式如下：
[public | protected | private ] [static]
[final] [transient] [volatile] type
variableName; //成員變量
其中，
static: 靜態變量（類變量）；相對於實例變量
final: 常量
transient: 暫時性變量，用於對象存檔
volatile: 貢獻變量，用於併發線程的共享
4．成員方法
方法的實現包括兩部分內容：方法聲明和方法體。
[public | protected | private ] [static]
[final | abstract] [native] [synchronized]
returnType methodName([paramList])
[throws exceptionList] //方法聲明
{statements} //方法體
方法聲明中的限定詞的含義：
static: 類方法，可通過類名直接調用
abstract: 抽象方法，沒有方法體
final: 方法不能被重寫
native: 集成其它語言的代碼
synchronized: 控制多個併發線程的訪問
◇ 方法聲明
方法聲明包括方法名、返回類型和外部參數。其中參數的類型可以是簡單數據類型，也可以是複合數據類型（又稱引用數據類型）。
對於簡單數據類型來說，java實現的是值傳遞，方法接收參數的值，但不能改變這些參數的值。如果要改變參數的值，則用引用數據類型，因爲引用數據類型傳遞給方法的是數據在內存中的地址，方法中對數據的操作可以改變數據的值。
例3-1說明了簡單數據類型與引用數據的區別。
【例3-1】
import java.io.*;
public class PassTest{
float ptValue;
public static void main(String args[]) {
int val;
PassTest pt=new PassTest();
val=11;
System.out.println("Original Int Value is:"+val);
pt.changeInt(val); //值參數
System.out.println("Int Value after Change is:" +val); /*值參數
值的修改，沒有影響值參數的值*/
pt.ptValue=101f;
System.out.println("Original ptValue is:"+pt.ptValue);
pt.changeObjValue(pt); //引用類型的參數
System.out.println("ptValue after Change is:"+pt.ptValue);/* 引用參數值的修改，改變了引用參數的值*/
}
public void changeInt(int value){
value=55; //在方法內部對值參數進行了修改
}
public void changeObjValue(PassTest ref){
ref.ptValue=99f; //在方法內部對引用參數進行了修改
}
}
運行結果
| c:\>java PassTest Original Int Value is : 11 Int Value after Change is: 11 Original ptValue is: 101.0 ptValue after Change is : 99.0 |
◇ 方法體
方法體是對方法的實現，它包括局部變量的聲明以及所有合法的Java指令。方法體中聲明的局部變量的作用域在該方法內部。若局部變量與類的成員變量同名，則類的成員變量被隱藏。
例3-2 說明了局部變量z和類成員變量z的作用域是不同的。
【例3-2】
import java.io.*;
class Variable{
int x=0,y=0,z=0; //類的成員變量
void init(int x,int y) {
this.x=x; this.y=y;
int z=5; //局部變量
System.out.println("** in init**");
System.out.println("x="+x+" y="+y+" z="+z);
}
}
public class VariableTest{
public static void main(String args[]){
Variable v=new Variable();
System.out.println("**before init**");
System.out.println("x="+v.x+" y="+ v.y+" z="+v.z);
v.init(20,30);
System.out.println("**after init**");
System.out.println("x="+v.x+ " y="+ v.y+" z="+v.z);
}
}
運行結果
| c:\>java VariableTest **before init** x=0 y=0 z=0 ** in init ** x=20 y=30 z=5 **after init** x=20 y=30 z=0 |
上例中我們用到了this，這是因爲init()方法的參數名與類的成員變量x,y的名字相同，而參數名會隱藏成員變量，所以在方法中，爲了區別參數和類的成員變量，我們必須使用this。this-----用在一個方法中引用當前對象，它的值是調用該方法的對象。返回值須與返回類型一致，或者完全相同，或是其子類。當返回類型是接口時，返回值必須實現該接口。
5．方法重載
方法重載是指多個方法享有相同的名字，但是這些方法的參數必須不同，或者是參數的個數不同，或者是參數類型不同。返回類型不能用來區分重載的方法。
參數類型的區分度一定要足夠，例如不能是同一簡單類型的參數，如int與long。
【例3-3】
import java.io.*;
class MethodOverloading{
void receive(int i) {
System.out.println("Receive one int data");
System.out.println("i="+i);
}
void receive(int x, int y) {
System.out.println("Receive two int datas");
System.out.println("x="+x+" y="+y);
}
}
public class MethodOverloadingTest{
public static void main(String args[]) {
MethodOverloading mo=new MethodOverloading();
mo.receive(1);
mo.receive(2,3);
}
}
運行結果(編譯器會根據參數的個數和類型來決定當前所使用的方法)
| c:\>java MethodOverloadingTest Receive one int data i=1 Receive two int datas x=2 y=3 |
6． 構造方法
◇ 構造方法是一個特殊的方法。Java 中的每個類都有構造方法，用來初始化該類的一個對象。
◇ 構造方法具有和類名相同的名稱，而且不返回任何數據類型。
◇ 重載經常用於構造方法。
◇ 構造方法只能由new運算符調用
【例3-4】
class Point{
int x,y;
Point(){
x=0; y=0;
}
Point(int x, int y){
this.x=x;
this.y=y;
}
}
3．2．2 對象
類實例化可生成對象，對象通過消息傳遞來進行交互。消息傳遞即激活指定的某個對象的方法以改變其狀態或讓它產生一定的行爲。一個對象的生命週期包括三個階段：生成、使用和消除。
1. 對象的生成
對象的生成包括聲明、實例化和初始化。
格式爲：
type objectName=new type([paramlist]);
◇ 聲明：type objectName
聲明並不爲對象分配內存空間，而只是分配一個引用空間；對象的引用類似於指針，是32位的地址空間，它的值指向一箇中間的數據結構，它存儲有關數據類型的信息以及當前對象所在的堆的地址，而對於對象所在的實際的內存地址是不可操作的，這就保證了安全性。
◇ 實例化：運算符new爲對象分配內存空間，它調用對象的構造方法，返回引用；一個類的不同對象分別佔據不同的內存空間。
◇ 生成：執行構造方法，進行初始化；根據參數不同調用相應的構造方法。
2. 對象的使用
通過運算符"."可以實現對變量的訪問和方法的調用。變量和方法可以通過設定訪問權限來限制其它對象對它的訪問。
◇調用對象的變量
格式：objectReference.variable
objectReference是一個已生成的對象，也可以是能生成對象的表達式
例： p.x= 10;
tx=new Point( ).x;
◇調用對象的方法
格式：objectReference.methodName([paramlist]);
例如：p.move(30,20);
new Point( ).move(30,20);
3. 對象的清除
當不存在對一個對象的引用時，該對象成爲一個無用對象。Java的垃圾收集器自動掃描對象的動態內存區，把沒有引用的對象作爲垃圾收集起來並釋放。
System.gc( );
當系統內存用盡或調用System.gc( )要求垃圾回收時，垃圾回收線程與系統同步運行。
3．2．3 面向對象特性
java語言中有三個典型的面向對象的特性：封裝性、繼承性和多態性，下面將詳細闡述。
1． 封裝性
java語言中，對象就是對一組變量和相關方法的封裝，其中變量表明瞭對象的狀態，方法表明了對象具有的行爲。通過對象的封裝，實現了模塊化和信息隱藏。通過對類的成員施以一定的訪問權限，實現了類中成員的信息隱藏。
◇ 類體定義的一般格式：
class className
{ [public | protected | private ] [static]
[final] [transient] [volatile] type
variableName; //成員變量
[public | protected | private ] [static]
[final | abstract] [native] [synchronized]
returnType methodName([paramList])
[throws exceptionList]
{statements} //成員方法
}
◇ java類中的限定詞
java語言中有四種不同的限定詞，提供了四種不同的訪問權限。
1） private
類中限定爲private的成員，只能被這個類本身訪問。
如果一個類的構造方法聲明爲private,則其它類不能生成該類的一個實例。
2） default
類中不加任何訪問權限限定的成員屬於缺省的（default）訪問狀態，可以被這個類本身和同一個包中的類所訪問。
3） protected
類中限定爲protected的成員，可以被這個類本身、它的子類（包括同一個包中以及不同包中的子類）和同一個包中的所有其他的類訪問。
4） public
類中限定爲public的成員，可以被所有的類訪問。
表3-1列出了這些限定詞的作用範圍。
【表3-1】 java中類的限定詞的作用範圍比較
|
同一個類
|
同一個包
|
不同包的子類
|
不同包非子類
|
|
|
private
|
*
|
|||
|
default
|
*
|
*
|
||
|
protected
|
*
|
*
|
*
|
|
|
public
|
*
|
*
|
*
|
*
|
2． 繼承性
通過繼承實現代碼複用。Java中所有的類都是通過直接或間接地繼承java.lang.Object類得到的。繼承而得到的類稱爲子類，被繼承的類稱爲父類。子類不能繼承父類中訪問權限爲private的成員變量和方法。子類可以重寫父類的方法，及命名與父類同名的成員變量。但Java不支持多重繼承，即一個類從多個超類派生的能力。
◇ 創建子類
格式：
class SubClass extends SuperClass {
…
}
◇ 成員變量的隱藏和方法的重寫
子類通過隱藏父類的成員變量和重寫父類的方法，可以把父類的狀態和行爲改變爲自身的狀態和行爲。
例如：
class SuperClass{
int x; …
void setX( ){ x=0; } …
}
class SubClass extends SuperClass{
int x; //隱藏了父類的變量x
…
void setX( ) { //重寫了父類的方法 setX()
x=5; } ….
}
注意：子類中重寫的方法和父類中被重寫的方法要具有相同的名字，相同的參數表和相同的返回類型，只是函數體不同。
◇ super
java中通過super來實現對父類成員的訪問，super用來引用當前對象的父類。Super 的使用有三種情況：
1）訪問父類被隱藏的成員變量，如：
super.variable;
2）調用父類中被重寫的方法，如：
super.Method([paramlist]);
3）調用父類的構造函數，如：
super([paramlist]);
【例3-5】
import java.io.*;
class SuperClass{
int x;
SuperClass( ) {
x=3;
System.out.println("in SuperClass : x=" +x);
}
void doSomething( ) {
System.out.println("in SuperClass.doSomething()");
}
}
class SubClass extends SuperClass {
int x;
SubClass( ) {
super( ); //調用父類的構造方法
x=5; //super( ) 要放在方法中的第一句
System.out.println("in SubClass :x="+x);
}
void doSomething( ) {
super.doSomething( ); //調用父類的方法
System.out.println("in SubClass.doSomething()");
System.out.println("super.x="+super.x+" sub.x="+x);
}
}
public class Inheritance {
public static void main(String args[]) {
SubClass subC=new SubClass();
subC.doSomething();
}
}
運行結果
| c:\> java Inheritance in SuperClass: x=3 in SubClass: x=5 in SuperClass.doSomething() in SubClass.doSomething() super.x=3 sub.x=5 |
3． 多態性
在java語言中，多態性體現在兩個方面：由方法重載實現的靜態多態性（編譯時多態）和方法重寫實現的動態多態性（運行時多態）。
1） 編譯時多態
在編譯階段，具體調用哪個被重載的方法，編譯器會根據參數的不同來靜態確定調用相應的方法。
2） 運行時多態
由於子類繼承了父類所有的屬性（私有的除外），所以子類對象可以作爲父類對象使用。程序中凡是使用父類對象的地方，都可以用子類對象來代替。一個對象可以通過引用子類的實例來調用子類的方法。
◇ 重寫方法的調用原則：java運行時系統根據調用該方法的實例，來決定調用哪個方法。對子類的一個實例，如果子類重寫了父類的方法，則運行時系統調用子類的方法；如果子類繼承了父類的方法（未重寫），則運行時系統調用父類的方法。
在例3-6中，父類對象a引用的是子類的實例，所以，java運行時調用子類B的callme方法。
【例3-6】
import java.io.*;
class A{
void callme( ) {
System.out.println("Inside A's callme()method");
}
}
class B extends A{
void callme( ) {
System.out.println("Inside B's callme() Method");
}
}
public class Dispatch{
public static void main(String args[]) {
A a=new B();
a.callme( );
}
}
運行結果
| c:\> java Dispatch Inside B's callme() method |
◇ 方法重寫時應遵循的原則：
1）改寫後的方法不能比被重寫的方法有更嚴格的訪問權限（可以相同）。
2）改寫後的方法不能比重寫的方法產生更多的例外。
4． 其它
◇ final 關鍵字
final 關鍵字可以修飾類、類的成員變量和成員方法，但final 的作用不同。
1） final 修飾成員變量：
final修飾變量,則成爲常量，例如
final type variableName;
修飾成員變量時，定義時同時給出初始值，而修飾局部變量時不做要求。
2） final 修飾成員方法：
final修飾方法，則該方法不能被子類重寫
final returnType methodName(paramList){
…
}
3） final 類：
final修飾類，則類不能被繼承
final class finalClassName{
…
}
◇ 實例成員和類成員
用static 關鍵字可以聲明類變量和類方法，其格式如下：
static type classVar;
static returnType classMethod({paramlist}) {
…
}
如果在聲明時不用static 關鍵字修飾，則聲明爲實例變量和實例方法。
1） 實例變量和類變量
每個對象的實例變量都分配內存，通過該對象來訪問這些實例變量，不同的實例變量是不同的。
類變量僅在生成第一個對象時分配內存，所有實例對象共享同一個類變量，每個實例對象對類變量的改變都會影響到其它的實例對象。類變量可通過類名直接訪問，無需先生成一個實例對象，也可以通過實例對象訪問類變量。
2） 實例方法和類方法
實例方法可以對當前對象的實例變量進行操作，也可以對類變量進行操作，實例方法由實例對象調用。
但類方法不能訪問實例變量，只能訪問類變量。類方法可以由類名直接調用，也可由實例對象進行調用。類方法中不能使用this或super關鍵字。
例3-7 是關於實例成員和類成員的例子。
【例3-7】
class Member {
static int classVar;
int instanceVar;
static void setClassVar(int i) {
classVar=i;
// instanceVar=i; // 類方法不能訪問實例變量
}
static int getClassVar()
{ return classVar; }
void setInstanceVar(int i)
{ classVar=i; //實例方法不但可以訪問類變量，也可以實例變量
instanceVar=i; }
int getInstanceVar( )
{ return instanceVar; }
}
public class MemberTest{
public static void main(String args[]) {
Member m1=new member();
Member m2=new member();
m1.setClassVar(1);
m2.setClassVar(2);
System.out.println("m1.classVar="+m1.getClassVar()+"
m2.ClassVar="+m2.getClassVar());
m1.setInstanceVar(11);
m2.setInstanceVar(22);
System.out.println("m1.InstanceVar="+m1.getInstanceVar
()+" m2.InstanceVar="+m2.getInstanceVar());
}
}
運行結果
| c:\> java MemberTest m1.classVar=2 m2.classVar=2 m1.InstanceVar=11 m2.InstanceVar=22 |
◇ 類java.lang.Object
類java.lang.Object處於java開發環境的類層次的根部，其它所有的類都是直接或間接地繼承了此類。該類定義了一些最基本的狀態和行爲。下面，我們介紹一些常用的方法。
equals() ：比較兩個對象(引用)是否相同。
getClass()：返回對象運行時所對應的類的表示，從而可得到相應的信息。
toString()：用來返回對象的字符串表示。
finalize()：用於在垃圾收集前清除對象。
notify(),notifyAll(),wait()：用於多線程處理中的同步。
3．2．4抽象類和接口
1． 抽象類
java語言中，用abstract 關鍵字來修飾一個類時，這個類叫做抽象類，用abstract 關鍵字來修飾一個方法時，這個方法叫做抽象方法。格式如下：
abstract class abstractClass{ …} //抽象類
abstract returnType abstractMethod([paramlist]) //抽象方法
抽象類必須被繼承，抽象方法必須被重寫。抽象方法只需聲明，無需實現；抽象類不能被實例化，抽象類不一定要包含抽象方法。若類中包含了抽象方法，則該類必須被定義爲抽象類。
2． 接口
接口是抽象類的一種，只包含常量和方法的定義，而沒有變量和方法的實現，且其方法都是抽象方法。它的用處體現在下面幾個方面：
◇ 通過接口實現不相關類的相同行爲,而無需考慮這些類之間的關係。
◇ 通過接口指明多個類需要實現的方法。
◇ 通過接口瞭解對象的交互界面,而無需瞭解對象所對應的類。
1）接口的定義
接口的定義包括接口聲明和接口體。
接口聲明的格式如下：
[public] interface interfaceName[extends listOfSuperInterface] { … }
extends 子句與類聲明的extends子句基本相同，不同的是一個接口可有多個父接口，用逗號隔開，而一個類只能有一個父類。
接口體包括常量定義和方法定義
常量定義格式爲：type NAME=value; 該常量被實現該接口的多個類共享; 具有public ,final, static的屬性。
方法體定義格式爲：(具有 public和abstract屬性)
returnType methodName([paramlist])；
2）接口的實現
在類的聲明中用implements子句來表示一個類使用某個接口，在類體中可以使用接口中定義的常量，而且必須實現接口中定義的所有方法。一個類可以實現多個接口,在implements子句中用逗號分開。
3） 接口類型的使用
接口作爲一種引用類型來使用。任何實現該接口的類的實例都可以存儲在該接口類型的變量中，通過這些變量可以訪問類所實現的接口中的方法。
3．2．5 內部類
1． 內部類的定義和使用：
內部類是在一個類的內部嵌套定義的類，它可以是其它類的成員，也可以在一個語句塊的內部定義，還可以在表達式內部匿名定義。
內部類有如下特性：
◇ 一般用在定義它的類或語句塊之內,在外部引用它時必須給出完整的名稱.名字不能與包含它的類名相同。
◇ 可以使用包含它的類的靜態和實例成員變量,也可以使用它所在方法的局部變量。
◇ 可以定義爲abstract。
◇ 可以聲明爲private或protected。
◇ 若被聲明爲static,就變成了頂層類,不能再使用局部變量。
◇ 若想在Inner Class中聲明任何static成員,則該Inner Class必須聲明爲static。
例3-8 是一個說明內部類如何使用的例子，其中，定義了兩個內部類：MouseMotionHandler和MouseEventHandler，分別用來處理鼠標移動事件和鼠標點按事件。
【例3-8】
import java.awt.*;
import java.awt.event.*;
public class TwoListenInner {
private Frame f;
private TextField tf;
public static void main(String args[]) {
TwoListenInner that=new TwoListenInner();
that.go();
}
public void go() {
f=new Frame("Two listeners example");
f.add("North",new Label("Click and drag the mouse"));
tf=new TextField(30);
f.add("South",tf);
f.addMouseMotionListener(new MouseMotionHandler());
f.addMouseListener(new MouseEventHandler());
f.setSize(300,300);
f.setVisible(true);
}
public class MouseMotionHandler extends MouseMotionAdapter {
public void mouseDragged(MouseEvent e){
String s="Mouse dragging:X="+e.getX()+"Y="+e.getY();
tf.setText(s);
}
}
public class MouseEventHandler extends MouseAdapter {
public void mouseEntered(MouseEvent e){
String s="The mouse entered";
tf.setText(s);
}
public void mouseExited(MouseEvent e){
String s="The mouse left the building";
tf.setText(s);
}
}
}
同學們可以運行一下這個程序，看一看它的運行結果。當你將鼠標移入frame時，文本框中會出現："The mouse entered"；當你在frame中拖曳鼠標時，文本框中會出現："Mouse dragging:X=64 Y=117"；當鼠標離開文本框時，文本框中出現："The mouse left the building"。
2． 匿名類的定義和使用：
匿名類是一種特殊的內部類，它是在一個表達式內部包含一個完整的類定義。通過對例6-7中go()部分語句的修改，我們可以看到匿名類的使用情況。
public void go() {
f=new Frame("Two listeners example");
f.add("North",new Label("Click and drag the mouse"));
tf=new TextField(30);
f.add("South",tf);
f.addMouseMotionListener(new MouseMotionHandler(){
/*定義了一個匿名類，類名沒有顯式地給出，只是該類是
MouseMotionHandler類的子類*/
public void mouseDragged(MouseEvent e){
String s="Mouse dragging:X="+e.getX()+"Y
="+e.getY();
tf.setText(s);
}
});
f.addMouseListener(new MouseEventHandler());
f.setSize(300,300);
f.setVisible(true);
}
3． 內部類的優缺點：
◇ 優點:節省編譯後產生的字節碼文件的大小
◇ 缺點:使程序結構不清楚
【本講小結】
類是Java語言面向對象編程的基本元素，它定義了一個對象的結構和功能。 Java類中包含成員變量和成員方法。成員變量有兩種，用static 關鍵字修飾的變量爲類變量，無static 修飾的變量爲實例變量。相應地，成員方法也有兩種，用static 修飾的爲類方法，無static修飾的爲實例方法。實例方法不僅可以對當前對象的實例變量進行操作，也可以對類變量進行操作；但類方法只能訪問類變量。實例變量和實例方法必須由實例對象來調用，而類變量和類方法不僅可由實例對象來調用，還可由類名直接調用。Java通過在類定義的大括號裏聲明變量來把數據封裝在一個類裏，這裏的變量稱爲成員變量。爲了解決類名可能相同的問題，java
中提供包來管理類名空間。
封裝性、繼承性和多態性是java語言中面向對象的三個特性。接口是java 語言中特有的數據類型，由於接口的存在，解決了java語言不支持多重繼承的問題。內部類是指在一個類的內部嵌套定義的類。
