抽象與封裝是面向對象程序設計的兩個重要概念。類將數據以及對數據的操作封裝在一個抽象數據類型中，為屬于該類的所有對象提供了同意的抽象描述。
理解抽象與封裝的概念，掌握JAVA中的類與對象的應用，能夠運用面向對象思想進行類的設計，正確設計類中的成員方法和成員變量，是我們學習的目標。
面向對象是一種新型的程序設計方法，或者說是一種心的程序設計規范，其基本思想是實用對象、類、繼承、封裝、消息等基本概念來進行程序設計。從顯示世界中客觀存在的事務（即對象）出發來構造軟件系統，并且在系統構建中盡可能運行人類的自然思維方式。
面向對象的設計方法用對象描述事物，而每個具體的對象又可以用兩個特征來描述：描述事物靜態屬性所需的數據結構以及對這些數據進行的有限操作。也就是說，把數據結構和對數據的操作放在一起構成一個整體，才能完整地反應實際問題。數據結構和對數據的操作實際上是相互以來不可分割的整體。
面向對象程序設計具有抽象、封裝、集成和多態4個特點。抽象去掉了被研究對象中與主旨無關的次要部分，而僅僅抽取出與研究工作有關的實質性的內容加以考慮。抽象有兩類：一類是過程抽象，另一類是數據抽象。
面向對象程序設計強調數據抽象，數據抽象把系統總需要處理的數據和這些數據上的操作結合在一起，根據功能、性質、作用等因素抽象成不同的抽象數據類型。每個抽象數據類型既包含數據，又包含針對這些數據的操作，是相對于過程抽象更為嚴格的抽象方法。
封裝
封裝就是利用抽象數據類型把數據和基于數據的操作封裝在一起，數據被保護在抽象數據類型的內部，系統的其他部分只有通過數據的操作，才能夠于這個抽象數據類型進行交互，封裝包含兩層含義。
第一，把對象的全部屬性及其行為結合在一起，形成一個不可分割的獨立單位（即對象）。
第二，信息隱蔽，即盡可能隱蔽對象的內部細節，對外形成一個邊界（或者說形成一道屏障），只保留有限的對外接口，使之與外部發生聯系。
封裝的原則在軟件上的反應是：對象以外的部分不能隨意存取對象的內部數據（屬性），從而有效地避免了外部錯誤對他的“交叉感染”，使軟件錯誤能夠局部化，大大減少查錯和排錯難度。
在面向對象的程序設計中，抽象數據類型是用“類”這種面向對象工具表示的，每個類里都防撞了相關的數據和操作。封裝性降低了程序開發過程的復雜性，提高了效率和質量，保證了數據的完整性和安全性。同時，封裝性提高了抽象數據類型的可重用性，使抽象數據類型稱為一個結構完整、能夠自行管理的有機整體。
類
把眾多的事物歸納、劃分成一些類，是人類在認識客觀世界時經常采用的思維方法。分類的原則是抽象。類是一組對象的集合，它為屬于該類的所有對象提供了統一的抽象描述，其內部包括屬性和服務兩個主要部分。在面向對象的編程語言中，類是一個獨立的程序單位行為。類的實例化結果就是對象，而對一類對象的抽象就是類。
類的定義
類是JAVA的核心和本質，想要在JAVA程序中實現的每個概念，都必須封裝自愛類中。類是具有共同屬性和行為的對象的抽象，屬性描述了對象的狀態，以數據的形式存在，在JAVA面向對象程序設計中又貝稱為變量。行為描述了對數據進行的操作，可引起對象狀態的改變。在JAVA面向對象程序設計中貝稱為方法。
JAVA中類的實現包括兩個部分：類頭和類體。類頭定義的格式如下：
[類定義修飾符] class <類名> [extends <父類名>] [implements <接口列表>]
類的定義主要包括關鍵詞 class 和類名。類名是JAVA語言合法的標識符，類名一般具有一定的含義。其中，CLASS為定義類的關鍵字，extends是用于繼承的關鍵字，implements是用于實現接口的關鍵字，有關類的修飾符后面將詳細闡述。
類體是類的主體部分，它包含了所有實現類功能的JAVA語言程序代碼，包括成員變量和成員方法。JAVA類除了繼承它的父類中的變量和方法外，一般仍會在類體中明確定義自己的變量和方法。程序中，變量說明應放在定義之前。類體要用{}括起來。類體的格式如下：
class <類名>{
[變量修飾符] <變量內省> <變量名>
[方法修飾符] <方法返回值類型> <方法名>([<參數列表>]){
方法體
}
}
其中，變量名是JAVA語言中的合法標識符，變量的類型可以是JAVA給定的任意數據類型或者用戶自定義類。用于說明變量和方法的訪問權限等屬性。
一個簡單的學生類：
//**********Student.java*********
//學生類的定義
import java.io.*; //加載系統輸入輸出類
public class Strdent{
/*類成員的定義*/
private String name; //成員變量
private String sex; //成員變量
rivate int number; //成員變量
void setValue(String a, String b, int c)//成員方法
{
name = a;
sex = b;
number = c;
}
public int getNumber() //成員方法
{
return number;
}
public static void main(String args[]) //成員方法
{
//打印輸出一行字符
System.out.println("這是一個學生類的定義！");
}
}// Student 類結束
//代表JAV語言中的單行注釋。
/* */ 之間的部分是多行注釋。
類的修飾符
類的修飾符說明類的性質和訪問權限，分為訪問控制符和非訪問控制符，包括
public 、protected 、 private 、abstract 和 final 。
1. public , protected 和 private
public , protected 和 private 說明類的訪問權限，屬于訪問控制符。
用public修飾的類，不僅能貝同一包中其他類訪問，還能貝包之外的類和對象使用。
protected 修飾的類為保護類，可貝同包類和異包子類訪問。
private 修飾符的類為似有類，外界無法訪問。
共有類的定義。
//*******TestPublic.java*******
//共有類的定義
import java.io.*; //加載系統輸入輸出類
public class TestPublic
{
/*每個類的main()方法是該程序的入口，而包含main方法的類是程序的主類。
main()方法的形式是 public static void main(String args[]) */
public static void main(String args[])
{
System.out.println("這是一個共有類");
}
}
下面定義一個名為TestProtectedAndPrivate的類來測試保護類和似有類。
保護類和似有類的定義：
//*************TestProtectedAndPrivate.java**********
//保護類和似有類的定義
import java.io.*; //加載系統輸入輸出類
public class TestProtectedAndPrivate{
//主方法
public static void main(String args[]){
//分別創建保護類和似有類的對象t1和t2
TestProtected t1 = new TestProtected();
TestPrivate t2 = new TestPrivate();
//打印輸出兩行字符
System.out.println(t1.toString());
System.out.println(t2.toString());
}
protected static class TestProtected //保護類
{
public String toString(){
return "保護類的定義：作為潛逃類的內部類";
}
}
private static class TestPrivate //似有類
{
public string toString(){
return "私有類的定義：作為嵌套類的內部類";
}
}
} // TestProtectedAndPrivate 類結束
aabstract
abstract 說明一個類為抽象類，所謂抽象類是指不能直接實例化對象的類。如果一個抽象類貝說明了，則這個類中將包括一個或幾個抽象方法。所謂抽象方法是指該方法只有方法說明卻沒有方法體，即沒有具體實現的代碼。抽象類本身不具備實際功能，它只用于衍生子類。定義抽象類和抽象方法的目的是建立抽象模型。抽象類中不一定包含抽象方法，但一旦某個類中說明了抽象方法，該類必須說明為抽象類。
不包含抽象方法的抽象類的定義。
//*************TestAbstract.java*************
//不包含抽象方法的抽象類
import java.io.*; //加載系統輸入輸出類
public abstract class TestAbstract{
//該類不包含抽象方法
//主方法
public static void main(String args]){
//打印輸出兩行字符
System.out.println("這是一個不包含抽象方法的抽象類！");
System.out.println("抽象類不能創建對象！");
}
} // TestAbstract 類結束
包含抽象方法的抽象類的定義。
//********** Mankind.java **********
//包含抽象方法的抽象類
import java.io.*; //加載系統輸入輸出類
public abstract class Mankind{
//定義4個抽象方法
public abstract void closing();
public abstract void food();
public abstract void shelter();
public abstract void transportation();
//主方法
public static void main(String args[]){
//打印輸出兩行字符
System.out.println("這是一個包含抽象方法的抽象類");
System.out.println("抽象方法沒有方法體");
}
}// Mankind 類結束
final
final 修飾的類又稱為最終類，是指該類不能被繼承，不能再有子類。它的目的是為了避免盲目繼承。一個final類無法貝繼承，意味著此類在一個繼承樹中是一個葉子類，并且此類的設計已貝認為很具體而不需要進行修改或擴展。對于final類中的成員變量，可以定義其為final，也可以不是final。而對于方法，由于所屬類為final的關系，自然也就成了final類型。也可以明確地給final類中的方法加上一個final關鍵字。下面定義一個名為TestFinal的最終類。
//************* TestFinal.java ***************
//最終類的定義
import java.io.*; //加載系統輸入輸出類
public final class TestFinal
{
//主方法
public static void main(String args[]){
//打印輸出一行字符
System.out.println("這是一個最終類，不能被繼承");
}
}//TestFinal類結束
因為抽象類的目的就是為了被繼承，而最終類的目的是不讓其貝繼承，所以一個類是不能用 abstract 和 final 同時修飾的。
對象
對象是具有某些特俗屬性（數據）和行為方式(操作)的實體。對象可以是有生命的個體，比如一個人或一只老虎；還可以是無生命的個體，比如一輛汽車或一臺計算機；也可以是一個抽象的概念，如天氣的變化或鼠標產生的事件。對象有兩個特征：屬性（property）和行為(Behavior)。例如，一個人的屬性有姓名、性別、年齡、身高、體重等；行為有唱歌、打球、騎車和學習等。
類是一個抽象的概念，而對象是一個具體的概念，是類實例化的結果。對象通過消息傳遞來進行交互。消息傳遞即激活指定的某個對象的方法以改變其狀態或讓它產生一定的行為。
對象的生命與引用
同基本內置類型一樣，為了聲明對象，首先必須寫出類型名，然后寫出該類型的所有變量的名字，中間用逗號隔開。下面舉例說明怎樣生命一個類的對象：
Student s1, s2, s3;
上面的生命表示s1\s2\s3是 Student 類型的引用變量，可以用來引用Student型的對象。引用變量的值將對應一個內存地址，這個地址標識的空間用來存放一個Student對象。
聲明對象的引用變量，并不等于創建對象，當然更沒有為對象分配存儲空間。這些需要通過 new 關鍵詞和對引用變量的賦值才能實現。
創建對象與定義構造方法
在JAVA語言中，一個JAVA對象是類的一個實力，創建對象的過程是對類的實例化過程，實例化對象就是創建一個對象。實例化對象意味著給對象分配必要的存儲空間，用來保存對象的變量和方法大媽。new 運算符用于創建一個類的實例并返回對象的引用，即用來實現對象的實例化。一般格式為:
<類名> <對象名> = new <類名>(<參數列表>);
創建對象與生命基本數據類型的變量相似，首先說明新建對象所屬的類名，然后說明該對象名，賦值號左邊的NEW 關鍵字是用于為新建對象開辟內存空間的運算符。與變量相比，對象占用的內存空間要大得多，因為對象既包含變量又包含方法，多數情況下，變量與方法還不止一個。例如前面定義的學生類 Strdent,假設有一個對象s1,則它就有3個屬性和2個方法： s1.name ,s1.sex, s1.number, s1.setValue(), s1.getNumber() 。這些變量和方法保存在一塊內存中，這塊內存就是對象s1 所占用的內存。如果在新建另一個 Strdent類的對象 s2，則s2對象將在內存中擁有自己的與s1對象不同的位置相同大小的內存空間。
創建對象的同時要調用這個對象的構造方法完成對象的初始化工作，JAVA語言中每一個類都有構造方法，該方法是一種特殊的方法，其特殊性主要體現在以下幾個方面。
(1) 構造方法的名稱與類的名稱相同。
(2) 構造方法不返回任何數據類型，也就沒有返回值。
(3) 構造方法的修飾符只能是訪問修飾符，即 public ,private,protected 中的任一個。
(4) 構造方法只能由 new 運算符調用，一般不能由編程人員顯式地直接調用。
(5) 構造方法不能從父類中繼承。而在構造方法中可以調用但前父類和其父類的另一個構造方法，調用語句必須是構造方法的第一條語句。使用當前類的構造方法用this來引用，使用其父類的構造方法用 super 來引用，在構造方法的實現中，可以進行方法的重載。
下面定義一個 Student 類，該類具有兩個構造方法，方法的名稱都是 Student,與類名相同。
public class Student{
//成員變量
private String name;
private String sex;
private int number;
//成員方法
Student() //構造方法
{
name = "NO name";
sex = "unknown";
number = 0;
}
Student(String a, String b, int c)//構造方法
{
name = a;
sex = b;
number = c;
}
}// Student 類結束
構造方法的重載。
//************* TestConstructor.java ***************
//構造方法的重載
import java.io.*; //加載系統輸入輸出類
class Constructor{
//成員變量
private int x;
private double y;
//沒有參數的構造方法
Constructor()
{
x = 0;
y = 0.0;
}
//一個參數的構造方法
Constructor(int x){
this.x = x; //使用 this 關鍵字標識成員變量，以區別于同名參數
}
//一個參數的構造方法，參數類型于前一個構造方法不同
Constructor(double y){
this.y = y;
}
//兩個參數的構造方法
Constructor(int x, double y){
this.x = x;
this.y = y;
}
// print() 方法顯示成員變量
void print()
{
System.out.println("x=" +x+" y="+y);
}
} // Constructor 類結束
// ConstructorTest 類
public class TestConstructor
{
//主方法
public static void main(String args[]){
//創建 Constructor 類的對象 c1 c2 c3 c4 分別使用了不同的構造方法
Constructor c1 = new Constructor();
Constructor c2 = new Constructor(53);
Constructor c3 = new Constructor(6.98);
Constructor c4 = new Constructor(5,7.8);
//在屏幕上輸出
c1.print();
c2.print();
c3.print();
c4.print();
}
} // TestConstructor 類結束
對象的使用
通過運算符“.”可以實現對對象中成員變量的訪問和成員方法的調用。可以通過設定成員變量和成員方法訪問權限來限制對它的訪問。
調用對象的成員變量的一般格式為：
<對象名>.<成員變量名>
其中，對象名是一個已生成的對象，也可以是能生成對象的表達式。
例如：
s1.name = "李明";
int num = new Student().number;
調用對象的成員方法的一般格式為：
<對象名>.<成員方法名>([<參數列表>])
其中，參數列表是可選項。在進行對象的方法引用時，方法中參數的個數、參數的數據類型與原方法中定義的要一致，否則編譯器會出錯。
對象的使用示例。
//************** Student2.java ***************
//對象的使用
import java.ioo.*;
public class Student2{
private String name; //姓名
private String sex; //性別
private int number; //學號
Student2() //無參構造方法
{
name = "No name";
sex = "unknown";
number = 0;
}
Student2(String a, String b, int c){
name = a;
sex = b;
number = c;
}
public void setName(String a){
name = a;
}
public void setSex(String b){
sex = b;
}
public void setNumber(int c){
number = c;
}
public String getName(){
return name;
}
public String getSex(){
return sex;
}
public int getNumber(){
return number;
}
public static void main(String args[]){
Student2 s1 = new Student2();
Student2 s2 = new Student2("李明","男",102305);
System.out.println("對象的使用");
System.out.println("-------------------------");
System.out.println("第一個學習的姓名："+s1.getName());
System.out.println("第一個學生的性別："+s1.getSex());
System.out.println("第一個學生的學號："+s1.getNumber());
System.out.println("-------------------------");
System.out.pringln("第二個學生的姓名："+s2.getName());
System.out.println("第二個學生的性別："+s2.getSex());
System.out.println("第二個學生的學號："+s2.getNumber());
}
} // Student2 類結束
在定義一個類時，類中的成員變量也可以是一個類，例2-9中包含2個類：Data類和Person類，Person類的成員變量birth為Data類型。
//************* Person.java **************
//對象作為類的成員變量
import java.io.*;
public class Date
{
int year;
int month;
int day;
Date(int year, int month, int day){
this.year = year; //用關鍵字this標識類成員變量，一面與同名參數混淆
this.month = month;
this.day = day;
}
void showDate(){
System.out.println(year+","+month+","+day);
}
}//Date類結束
public class Person
{
private String name;
private String sex;
private Date birth; //對象作為類的成員變量，默認初始值為null
void setValue(String s1, String s2, int y, int m, int d){
name = s1;
sex = s2;
birth = new Date(y,m,d);
}
void showValue(){
System.out.println("姓名："+name);
System.out.println("性別："+sex);
System.out.print("出生年月日：");
birth.showDate();
}
public static void main(String args[]){
Person per = new Person();
per.setValue("李明","男",1975,7,8);
per.showValue();
}
}//Person 類結束
finalize() 是銷毀一個對象用的
成員變量
成員變量是類和對象的數據屬性，其本身也有一些修飾符：訪問控制符 public private protected 以及非訪問控制符 static final transient volatile.這里主要探討常用的static 和final這兩個非訪問控制符。
靜態變量
使用關鍵字static 生命的成員變量稱為靜態變量。靜態變量也稱類變量（class variable）,它與類關聯，由類鐘的所有對象共享。無論生成多少個這種類的對象，靜態變量都只有一份，并且即使沒有生成任何對象，這種變量也存在。靜態變量之所以稱為類變量，是因為這種變量是屬于相應類的，而不是屬于特定對象的，他們在該類的全部對象中共享。靜態變量可以由任何該類的對象和類引用，當某個對象修改了靜態變量的值后，其他對象在訪問靜態變量時，取得的將是改變后的新值。
相對地，沒有用static修飾的普通成員變量稱為實例變量(instance variable)。在類中，實例變量與每個對象都唯一關聯，每個類的對象將擁有自己的一份實例變量的復制，并且賦予他自己的值。實例變量使一個對象與其他對象相互區別，使對象具有自己的個性。
下面定義一個學生 Student 類，其中包含2個靜態變量和3個實例變量。
public class Student
{
static String school = "黑龍江科技學院";
static String classNumber;
//實例變量
String name;
string sex;
int number;
Student(){
name = "No name";
sex = "unknown";
number = 0;
}
Strdent (String a,String b, int c) //構造方法
{
name = a;
sex = b;
number = c;
}
}//Student類結束
最終變量
使用關鍵字final聲明的成員變量稱為最終變量，更確切地說是常量。只不過為他們取了一個類似變量的標識符名字。用final修飾符聲明常量時，需要說明常量的數據類型并要初始化具體的數值。另外，因為所有類對象的常量數據成員數值都一樣，為了節省內存控件，常量通常聲明為static。 例如下面球體類中的常量PI：
public class Sphere
{
//常量
static final double PI = 3.14;
//變量
double xCenter;
double yCenter;
double zCenter;
double radius;
}// Sphere 類結束
成員方法
成員方法是類的行為，標志著類所具有的功能，是對類中成員變量的操作。JAVA中方法的一般格式如下：
[方法修飾符] [返回值類型] <方法名> ([<形式參數列表>]) [throws <異常列表>]
{
<方法體>
}
成員方法是具有相對獨立性的功能模塊，是一個類與外界進行通信的接口。成員方法也有一些修飾符：訪問修飾符public private procected 和非訪問控制符 static abstract final native synchronized 下面分別探討這幾個非訪問控制符
靜態方法
使用那個關鍵字static聲明的成員方法稱為靜態方法。靜態方法也稱為類方法(class method),它與類關聯，是屬于整個類的，即使類中一個對象也不存在，也可以執行該類的類方法。正式因為在沒有對象存在的情況下也可以執行類方法，因此它只能調用類變量，即靜態方法只能處理靜態變量，而不能處理類中的實例變量。很明顯，實例變量是屬于某個特定對象的，如果對象不存在，實例變量也就不存在，這時用類方法去操縱和處理一個可能不存在的變量肯定會出問題。實際上，JAVA編譯器根本就不允許做這樣的嘗試。如果在一個類方法中引用了一個實例變量，系統將拒絕編譯，從而出現出錯信息。
相對地，未用static 修飾的普通成員方法稱為實例方法(instance method)。實例方法只能針對特定的對象執行，因此如果任何對象都不存在，也就沒有可以執行的實例方法。
靜態方法實例：
//************** StaticFunction.java ***************
//靜態方法
import java.io.*; //加載系統輸入輸出類
public class StaticFunction
{
static int classVariable; //靜態變量，即類變量
int instanceVariable; //非靜態變量，即實例變量
// setClassVariable()方法為靜態方法，即類方法
static void setClassVariable(int i){
//this.classvar = i; 不能使用this
classvariable = i;
//instanceVar=i; 不能訪問實例變量
}
void setInstanceVar(int i){
instanceVariable = i;
classvariable = i;
}
//MAIN方法也為靜態方法
public static void main(String a[]){
StaticFunction sf = new StaticFunction();
/*
下面的語句不合法，main()方法是類方法，不能在類方法中直接調用實例方法
setInseranceVariable(58);
*/
sf.setInstanceVariable(58);//在類方法中只能通過實例對象訪問實例方法
sf.setInstanceVariable(58);
setInstanceVariable(58);
StaticFunction.setClassVariable(55);
System.out.println("靜態方法中不能直接調用實例方法，只能通過對象訪問實例方法");
}
}
抽象方法
使用關鍵字abstract聲明的成員方法稱為抽象方法。抽象方法只有方法頭，沒有方法體。抽象方法的聲明以一個分號結束。
抽象方法示例。
//*************** AbstractFunction.java**************
//抽象方法
import java.io.*;
abstract class Mankind
{
protected String type; //保護數據成員用于繼承
public abstract void closing(); //抽象方法
public abstract void food(); //抽象方法
public abstract void shelter(); //抽象方法
public abstract void transportation(); //抽象方法
public String toString(){
return "這是一個"+type;
}
}//Mankind類結束
abstract class people extends Mankind
{
//重寫Mankind類的抽象方法colsing()
public void closing(){
System.out.println("學會穿衣了!");
}
//重寫Mankind類的抽象方法food()
public void food(){
System.out.println("學會吃飯了");
}
}//People 類結束
class Person extends People{
//重寫People類的抽象方法shelter()
public void shelter(){
System.out.println("蓋房子用來居住");
}
//重寫people類的抽象方法transportation()
public void transportation(){
System.out.println("使用交通工具出行");
}
//構造方法
public Person(String aType){
type = new String(aType);
}
}// Person類結束
public class AbstractFunction{
//AbstractFunction類的主方法
public static void main(String args[]){
System.out.println("不能創建抽象類Mankind和People的對象!");
System.out.println("");
Person man = new Person("男人");
Person woman = new Person("女人");
System.out.println(man);
man.closing();
man.food();
man.shelter();
man.transportation();
System.out.println(" ");
System.out.println(woman);
woman.closing();
woman.food();
women.transportation();
}
}//AbstractFunction 類結束
最終方法
使用關鍵字final聲明的成員方法稱為最終方法。最終方法的功能和內部語句不能在被更改，也就是說該方法不能貝當前類的子類重新定義。最終方法使得子類不能重新定義與父類同名的方法，而只能使用從負累繼承來的方法，從而防止了子類對父類一些方法的錯誤定義，保證了程序的安全性和正確性。
本地方法
。。。。。。。。。。。。。。