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