java抽象類例子

⑴ java 抽象類，求個範例

抽象類與介面緊密相關，它們不能實例化，並且常常部分實現或根本不實現。抽象類和介面之間的一個主要差別是：類可以實現無限個介面，但僅能從一個抽象（或任何其他類型）類繼承。從抽象類派生的類仍可實現介面。可以在創建組件時使用抽象類，因為它們使您得以在某些方法中指定不變級功能，但直到需要該類的特定實現之後才實現其他方法。抽象類也制定版本，因為如果在派生類中需要附加功能，則可以將其添加到基類而不中斷代碼。

在實現抽象類時，必須實現該類中的每一個抽象方法，而每個已實現的方法必須和抽象類中指定的方法一樣，接收相同數目和類型的參數，具有同樣的返回值。
抽象類不能被實例化，也就是不能用new關鍵字去產生對象
抽象方法只需聲明，而不需實現
抽象類的子類必須覆蓋所有的抽象方法後才能被實例化，否則這個子類還是個抽象類.

以下來自：http://..com/question/43824606.html?si=1&wtp=wk

理解抽象類

abstract class和interface在Java語言中都是用來進行抽象類（本文中的抽象類並非從abstract class翻譯而來，它表示的是一個抽象體，而abstract class為Java語言中用於定義抽象類的一種方法，請讀者注意區分）定義的，那麼什麼是抽象類，使用抽象類能為我們帶來什麼好處呢？

在面向對象的概念中，我們知道所有的對象都是通過類來描繪的，但是反過來卻不是這樣。並不是所有的類都是用來描繪對象的，如果一個類中沒有包含足夠的信息來描繪一個具體的對象，這樣的類就是抽象類。抽象類往往用來表徵我們在對問題領域進行分析、設計中得出的抽象概念，是對一系列看上去不同，但是本質上相同的具體概念的抽象。比如：如果我們進行一個圖形編輯軟體的開發，就會發現問題領域存在著圓、三角形這樣一些具體概念，它們是不同的，但是它們又都屬於形狀這樣一個概念，形狀這個概念在問題領域是不存在的，它就是一個抽象概念。正是因為抽象的概念在問題領域沒有對應的具體概念，所以用以表徵抽象概念的抽象類是不能夠實例化的。

在面向對象領域，抽象類主要用來進行類型隱藏。我們可以構造出一個固定的一組行為的抽象描述，但是這組行為卻能夠有任意個可能的具體實現方式。這個抽象描述就是抽象類，而這一組任意個可能的具體實現則表現為所有可能的派生類。模塊可以操作一個抽象體。由於模塊依賴於一個固定的抽象體，因此它可以是不允許修改的；同時，通過從這個抽象體派生，也可擴展此模塊的行為功能。熟悉OCP的讀者一定知道，為了能夠實現面向對象設計的一個最核心的原則OCP(Open-Closed Principle)，抽象類是其中的關鍵所在。

從語法定義層面看abstract class和interface

在語法層面，Java語言對於abstract class和interface給出了不同的定義方式，下面以定義一個名為Demo的抽象類為例來說明這種不同。

使用abstract class的方式定義Demo抽象類的方式如下：

abstract class Demo ｛
abstract void method1();
abstract void method2();
…
｝

使用interface的方式定義Demo抽象類的方式如下：

interface Demo {
void method1();
void method2();
…
}

在abstract class方式中，Demo可以有自己的數據成員，也可以有非abstarct的成員方法，而在interface方式的實現中，Demo只能夠有靜態的不能被修改的數據成員（也就是必須是static final的，不過在interface中一般不定義數據成員），所有的成員方法都是abstract的。從某種意義上說，interface是一種特殊形式的abstract class。

從編程的角度來看，abstract class和interface都可以用來實現"design by contract"的思想。但是在具體的使用上面還是有一些區別的。

首先，abstract class在Java語言中表示的是一種繼承關系，一個類只能使用一次繼承關系。但是，一個類卻可以實現多個interface。也許，這是Java語言的設計者在考慮Java對於多重繼承的支持方面的一種折中考慮吧。

其次，在abstract class的定義中，我們可以賦予方法的默認行為。但是在interface的定義中，方法卻不能擁有默認行為，為了繞過這個限制，必須使用委託，但是這會 增加一些復雜性，有時會造成很大的麻煩。

在抽象類中不能定義默認行為還存在另一個比較嚴重的問題，那就是可能會造成維護上的麻煩。因為如果後來想修改類的界面（一般通過abstract class或者interface來表示）以適應新的情況（比如，添加新的方法或者給已用的方法中添加新的參數）時，就會非常的麻煩，可能要花費很多的時間（對於派生類很多的情況，尤為如此）。但是如果界面是通過abstract class來實現的，那麼可能就只需要修改定義在abstract class中的默認行為就可以了。

同樣，如果不能在抽象類中定義默認行為，就會導致同樣的方法實現出現在該抽象類的每一個派生類中，違反了"one rule，one place"原則，造成代碼重復，同樣不利於以後的維護。因此，在abstract class和interface間進行選擇時要非常的小心。

從設計理念層面看abstract class和interface

上面主要從語法定義和編程的角度論述了abstract class和interface的區別，這些層面的區別是比較低層次的、非本質的。本小節將從另一個層面：abstract class和interface所反映出的設計理念，來分析一下二者的區別。作者認為，從這個層面進行分析才能理解二者概念的本質所在。

前面已經提到過，abstarct class在Java語言中體現了一種繼承關系，要想使得繼承關系合理，父類和派生類之間必須存在"is a"關系，即父類和派生類在概念本質上應該是相同的（參考文獻〔3〕中有關於"is a"關系的大篇幅深入的論述，有興趣的讀者可以參考）。對於interface 來說則不然，並不要求interface的實現者和interface定義在概念本質上是一致的，僅僅是實現了interface定義的契約而已。為了使論述便於理解，下面將通過一個簡單的實例進行說明。

考慮這樣一個例子，假設在我們的問題領域中有一個關於Door的抽象概念，該Door具有執行兩個動作open和close，此時我們可以通過abstract class或者interface來定義一個表示該抽象概念的類型，定義方式分別如下所示：

使用abstract class方式定義Door：

abstract class Door {
abstract void open();
abstract void close()；
}

使用interface方式定義Door：

interface Door {
void open();
void close();
}

其他具體的Door類型可以extends使用abstract class方式定義的Door或者implements使用interface方式定義的Door。看起來好像使用abstract class和interface沒有大的區別。

如果現在要求Door還要具有報警的功能。我們該如何設計針對該例子的類結構呢（在本例中，主要是為了展示abstract class和interface反映在設計理念上的區別，其他方面無關的問題都做了簡化或者忽略）？下面將羅列出可能的解決方案，並從設計理念層面對這些不同的方案進行分析。

解決方案一：

簡單的在Door的定義中增加一個alarm方法，如下：

abstract class Door {
abstract void open();
abstract void close()；
abstract void alarm();
}

或者

interface Door {
void open();
void close();
void alarm();
}

那麼具有報警功能的AlarmDoor的定義方式如下：

class AlarmDoor extends Door {
void open() { … }
void close() { … }
void alarm() { … }
}

或者

class AlarmDoor implements Door ｛
void open() { … }
void close() { … }
void alarm() { … }
｝

這種方法違反了面向對象設計中的一個核心原則ISP（Interface Segregation Priciple），在Door的定義中把Door概念本身固有的行為方法和另外一個概念"報警器"的行為方法混在了一起。這樣引起的一個問題是那些僅僅依賴於Door這個概念的模塊會因為"報警器"這個概念的改變（比如：修改alarm方法的參數）而改變，反之依然。

解決方案二：

既然open、close和alarm屬於兩個不同的概念，根據ISP原則應該把它們分別定義在代表這兩個概念的抽象類中。定義方式有：這兩個概念都使用abstract class方式定義；兩個概念都使用interface方式定義；一個概念使用abstract class方式定義，另一個概念使用interface方式定義。

顯然，由於Java語言不支持多重繼承，所以兩個概念都使用abstract class方式定義是不可行的。後面兩種方式都是可行的，但是對於它們的選擇卻反映出對於問題領域中的概念本質的理解、對於設計意圖的反映是否正確、合理。我們一一來分析、說明。

如果兩個概念都使用interface方式來定義，那麼就反映出兩個問題：1、我們可能沒有理解清楚問題領域，AlarmDoor在概念本質上到底是Door還是報警器？2、如果我們對於問題領域的理解沒有問題，比如：我們通過對於問題領域的分析發現AlarmDoor在概念本質上和Door是一致的，那麼我們在實現時就沒有能夠正確的揭示我們的設計意圖，因為在這兩個概念的定義上（均使用interface方式定義）反映不出上述含義。

如果我們對於問題領域的理解是：AlarmDoor在概念本質上是Door，同時它有具有報警的功能。我們該如何來設計、實現來明確的反映出我們的意思呢？前面已經說過，abstract class在Java語言中表示一種繼承關系，而繼承關系在本質上是"is a"關系。所以對於Door這個概念，我們應該使用abstarct class方式來定義。另外，AlarmDoor又具有報警功能，說明它又能夠完成報警概念中定義的行為，所以報警概念可以通過interface方式定義。如下所示：

abstract class Door {
abstract void open();
abstract void close()；
}
interface Alarm {
void alarm();
}
class AlarmDoor extends Door implements Alarm {
void open() { … }
void close() { … }
void alarm() { … }
}

這種實現方式基本上能夠明確的反映出我們對於問題領域的理解，正確的揭示我們的設計意圖。其實abstract class表示的是"is a"關系，interface表示的是"like a"關系，大家在選擇時可以作為一個依據，當然這是建立在對問題領域的理解上的，比如：如果我們認為AlarmDoor在概念本質上是報警器，同時又具有Door的功能，那麼上述的定義方式就要反過來了。
能不能明白看你自己了，那個調味品類你自己寫吧，呵呵

⑵ 編寫一個Java代碼，在其中您將擁有一個帶有一個抽象方法的抽象類。然後將抽象類擴展為兩個具體的子類

比較基礎，給你個例子的思路：
1、創建抽象動物類：AbstractAnimal.java：public AbstractAnimal{...}，其中包含屬性String name;（自行設置getter和setter），包含抽象方法public void walk();
2、創建狗類Dog.java，繼承抽象動物類：public Dog extends AbstractAnimal{...}，同時必須重寫行走方法：
@Override
public void walk(){
System.out.println(super.name + "用四條腿走路");
}
3、創建人類People.java，繼承抽象動物類：public Peopleextends AbstractAnimal{...}，同時必須重寫行走方法：
@Override
public void walk(){
System.out.println(super.name + "用兩條腿走路");
}
4、編寫測試類
private static void main(String[] args){
AbstractAnimal dog = new God();
dog.setName("來福");
dog.walk();
AbstractAnimal people = new People();
people.setName("張三");
people.walk();
}

⑶ java中抽象類的作用是什麼

抽象類比較像普通類和介面的結合，因為抽象類可以像普通類那樣在類中實現方法，也可以像介面一樣，只聲明，不實現。下面的一個抽象類的實例：
public abstract class TravelTool{ //抽象類需在類的關鍵字class前加上關鍵字abstract。
//抽象方法沒有方法體，需在方法返回值前加上關鍵字abstract，並以分號結尾。
public abstract String drive(int i);
}
抽象類可以有抽象方法，如果它的子類是抽象類，那麼子類不必實現抽象類的抽象方法；如果子類不是抽象類，那麼子類必須實現抽象類的抽象方法。需要注意的是，不能實例化抽象類對象。若子類為非抽象類那麼子類可以實例化對象。
如果你還是不太明白抽象類。你可以上秒秒學了解下，上面說的比較形象。

⑷ 用java定義一個抽象類Person,包括

身份證上有的都可以。姓名年齡地址電話性別等等。

⑸ java請設計一個使用抽象類或介面的示例代碼

//介面
publicinterfaceBankCard{
	
	publicvoidnorm();
}

//工商銀行實現類
{

	@Override
	publicvoidnorm(){
		//TODO銀行規范

	}

	publicvoidsaveMoney(intmoney){
		//TODO執行存錢動作
	}
	
	publicvoidtransfer(Stringaccount,intmoney){
		//TODO執行轉賬動作
	}
}

//交通銀行實現類
{

	
	@Override
	publicvoidnorm(){
		//TODO銀行規范

	}

	publicvoidsaveMoney(intmoney){
		//TODO執行存錢動作
	}
	
	publicvoidtransfer(Stringaccount,intmoney){
		//TODO執行轉賬動作
	}
}

上面的例子只是申明了通用的規范，如果想讓實現類都能實現存錢和轉賬功能，可以在介面裡面聲明這兩個方法，寫一個通用的實現類，實現這些方法，然後具體的子類繼承該通用類，這樣可以直接繼承父類方法，如果不同的銀行具體實現不同，可以復寫父類中的兩個方法。

⑹ java介面和抽象類的理解以及例子

雖然大多數中國人學習喜歡下定義，不太提倡，但是你這樣完全不看定義去理解就是意淫了。這個例子很好但是要跟在解釋了介面之後說，現在關於介面的什麼也沒記，就記了一個特殊的故事，讓你寫你抓的住重點么？
1 介面是100%的抽象類，不管你寫不寫abstract
2 介面只允許有抽象方法，不允許有實體方法
3 介面中的方法是默認的public abstract 寫不寫都是
4 介面中必須是常量，不顯示的public static final（意思是寫不寫都是）
5 實現介面的類本身可以是抽象類（意思是不完全實現）
6 一個合法的非抽象的實現類，必須：
1）它提供全部介面方法的實現（可以繼承父類的實現）
2）正確的重寫規則重寫（實現）這些方法
3）它不能為實現方法聲明任何新的異常檢查
4）它不能擴大介面中的方法聲明的異常檢查范圍做聲明
5）可以聲明runtime異常，不管介面聲明與否
6）方法名和返回類型必須保持（單不必聲明介面中定義的異常）
再來說抽象類，其實你可以從抽象方法開始理解，什麼是抽象方法就是你只有功能需求，沒有實際怎麼做的方法。比如你上面的消費。有了這個方法，你的類也必須是個抽象類，所以類 抽象類 介面是個級別一個比一個抽象的關系。
幹了來的：
抽象類可以有普通方法，也可以沒有，抽象類不能被實例，但是卻有構造方法（介面絕對沒有）

⑺ JAVA中的抽象類

抽象是java的特性之一,也是處理對象復雜性的一種技術!它是指只關注對象的重要細節,忽略次要細節!
在抽象類中定義的抽象方法,是由子類去實現，而不是去覆蓋,因為在父類中沒有具體的實現!
舉一個例子:
父類:
abstract
class
MyClass
{
abstract
void
display(String
str);
}
子類:
abstract
class
MyChild
extends
MyClass
{
void
display(String
str)
{
.....
}
void
method1()
{
....
}
void
method2()
{
....
}
........
}
這個時候我需要用到display方法,其他的都不用!我們可以這樣做:
MyClass
mc
=
new
MyChild();
mc.display();
我們聲明的是一個父類類型的引用,只需要記住父類中有這個方法的聲明,不用管它子類怎麼去實現,而且看都不用看method1,method2...我們可以把精力都集中在父類!如果只有一個單純的子類,很可能需要去看他的其他方法,尤其是當display與其他方法有關聯的時候!有了這樣一個抽象的父類,就可以省去這些精力,只需要知道父類有這個方法就行了!(或許這些在小程序中體現得並不很明顯)
以上都是個人的理解,有不對的地方,還希望大家指正!

⑻ java抽象類裡面可以有實現嗎

有抽象方法的類一定是抽象類。但是抽象類中不一定都是抽象方法，也可以全是具體方法。
abstract修飾符在修飾類時必須放在類名前。
abstract修飾方法就是要求其子類覆蓋（實現）這個方法。調用時可以以多態方式調用子類覆蓋（實現）後的方法，也就是說抽象方法必須在其子類中實現，除非子類本身也是抽象類。
注意：父類是抽象類，其中有抽象方法，那麼子類繼承父類，並把父類中的所有抽象方法都實現（覆蓋）了，子類才有創建對象的實例的能力，否則子類也必須是抽象類。抽象類中可以有構造方法，是子類在構造子類對象時需要調用的父類（抽象類）的構造方法。
舉個簡單的例子下面有一個抽象類
abstract
class
e{
public
abstract
void
show();//public
abstract
可以省略
}
然後其它類如果繼承它通常為了實現它裡面的方法
class
f
extends
e{
void
show(){
//寫具體實現的代碼
}
}
最後再主方法裡面定義一個父類引用指向子類對象,就會發生多態現象,比如
e
e=new
f();
e.show();
實際調用了子類裡面的show()方法

⑼ java中abstract怎麼使用啊，說的詳細點。舉幾個有代表的例子

使用abstract（抽象）修飾符，可以修飾類和方法。

1、abstract修飾類，會使這個類成為一個抽象類，這個類將不能生成對象實例，但可以做為對象變數聲明的類型，也就是編譯時類型，抽象類就像當於一類的半成品，需要子類繼承並覆蓋其中的抽象方法。

2、abstract修飾方法，會使這個方法變成抽象方法，也就是只有聲明（定義）而沒有實現，實現部分以"；"代替。需要子類繼承實現（覆蓋）。

注意：有抽象方法的類一定是抽象類。但是抽象類中不一定都是抽象方法，也可以全是具體方法。

abstract修飾符在修飾類時必須放在類名前。

abstract修飾方法就是要求其子類覆蓋（實現）這個方法。調用時可以以多態方式調用子類覆蓋（實現）後的方法，也就是說抽象方法必須在其子類中實現，除非子類本身也是抽象類。

注意：父類是抽象類，其中有抽象方法，那麼子類繼承父類，並把父類中的所有抽象方法都實現（覆蓋）了，子類才有創建對象的實例的能力，否則子類也必須是抽象類。抽象類中可以有構造方法，是子類在構造子類對象時需要調用的父類（抽象類）的構造方法。

舉個簡單的例子下面有一個抽象類：

abstract class E{

public abstract void show();//public abstract 可以省略

}

然後其它類如果繼承它通常為了實現它裡面的方法：

class F extends E{

void show(){

//寫具體實現的代碼

}

}

最後再主方法裡面定義一個父類引用指向子類對象,就會發生多態現象，比如 ：

E e=new F();

e.show();

實際調用了子類裡面的show()方法 。

(9)java抽象類例子擴展閱讀：

Java中的abstract方法和abstract類的問題：

當知道一個類的子類將不同的實現某個方法時，把該類聲明為抽象類很有用，可以共用相同的父類方法，不必再定義。

抽象類和抽象方法的關系：含有抽象方法的類一定是抽象類，抽象類里不一定含有抽象方法。

抽象類存在的意義是用來被繼承的。一個類繼承了一個抽象類，必須實現抽象類裡面所有的抽象方法，否則，此類也是抽象類。

1：用abstract修飾的類表示抽象類，抽象類位於繼承樹的抽象層，抽象類不能被實例化。

2：用abstract修飾的方法表示抽象方法,抽象方法沒有方法體。抽象方法用來描述系統具有什麼功能，但不提供具體的實現。

abstract的規則：

1：抽象類可以沒有抽象方法，但是有抽象方法的類必須定義為抽象類，如果一個子類繼承一個抽象類，子類沒有實現父類的所有抽象方法，那麼子類也要定義為抽象類，否則的話編譯會出錯的。

2：抽象類沒有構造方法，也沒有抽象靜態方法。但是可以有非抽象的構造方法。

3：抽象類不能被實例化，但是可以創建一個引用變數，類型是一個抽象類，並讓它引用非抽象類的子類的一個實例。

4：不能用final 修飾符修飾。

⑽ Java中的抽象類是什麼

使用了關鍵詞abstract聲明的類叫作「抽象類」。
如果一個類中沒有包含足夠的信息來描繪一個具體的對象，這樣的類就是抽象類。
如果一個類里包含了一個或多個抽象方法，類就必須指定成abstract（抽象）。「抽象方法」,屬於一種不完整的方法，只含有一個聲明，沒有方法主體