抽象類的方法如何定義

㈠ 什麼是抽象類和抽象方法

抽象類就是不能使用new方法進行實例化的類，即沒有具體實例對象的類。抽象類有點類似「模板」的作用，目的是根據其格式來創建和修改新的類。對象不能由抽象類直接創建，只可以通過抽象類派生出新的子類，再由其子類來創建對象。當一個類被聲明為抽象類時，要在這個類前面加上修飾符abstract。

在抽象類中的成員方法可以包括一般方法和抽象方法。抽象方法就是以abstract修飾的方法，這種方法只聲明返回的數據類型、方法名稱和所需的參數，沒有方法體，也就是說抽象方法只需要聲明而不需要實現。當一個方法為抽象方法時，意味著這個方法必須被子類的方法所重寫，否則其子類的該方法仍然是abstract的，而這個子類也必須是抽象的，即聲明為abstract。
抽象類中不一定包含抽象方法，但是包含抽象方法的類一定要被聲明為抽象類。抽象類本身不具備實際的功能，只能用於派生其子類。抽象類中可以包含構造方法，但是構造方法不能被聲明為抽象。
抽象類不能用final來修飾，即一個類不能既是最終類又是抽象類。
abstract不能與private、static、final、native並列修飾同一個方法。
程序舉例：abstract
class
Animal
//定義抽象類
abstract
void
eat();
//定義抽象方法}class
Horse
extends
Animal
//定義繼承Animal的子類
void
eat()
//重寫父類的抽象方法
}class
Dog
extends
Animal
void
eat()
}class
test}運行結果：
馬吃草料！
狗吃骨頭！
如果幫助到您，請記得採納為滿意答案哈，謝謝！祝您生活愉快！
vae.la

㈡ 什麼是抽象類

抽象類是包含一種或多種抽象方法的類，它本身不需要構造實例。定義抽象類後，其它類可以對它進行擴充並且通過實現其中的抽象方法，使抽象類具體化。

一個抽象類是一個沒有程序實現部分而需要由其子類去填充完整的類。

一個抽象類是被有意設計成未完成的樣子。它只定義了一個框架，不同的子類可以根據自己的情況去填充不同的內容。不同的現實子類（非抽象類）提供一組變體。

㈢ 什麼是抽象類，為什麼要寫抽象類

哥哥你發錯地方了=。=發到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的功能，那麼上述的定義方式就要反過來了。

㈣ 什麼是抽象類抽象類有什麼作用

抽象類往往用來表徵對問題領域進行分析、設計中得出的抽象概念，是對一系列看上去不同，但是本質上相同的具體概念的抽象。

作用：通常在編程語句中用 abstract 修飾的類是抽象類。在C++中，含有純虛擬函數的類稱為抽象類，它不能生成對象；在java中，含有抽象方法的類稱為抽象類，同樣不能生成對象。

抽象類裡面可以有非抽象方法但介面里只能有抽象方法 聲明方法的存在而不去實現它的類被叫做抽像類（abstract class），它用於要創建一個體現某些基本行為的類，並為該類聲明方法，但不能在該類中實現該類的情況。

不能創建abstract 類的實例。然而可以創建一個變數，其類型是一個抽像類，並讓它指向具體子類的一個實例。不能有抽像構造函數或抽像靜態方法。Abstract 類的子類為它們父類中的所有抽像方法提供實現，否則它們也是抽像類為。

(4)抽象類的方法如何定義擴展閱讀：

在使用抽象類時需要注意幾點：

1、抽象類不能被實例化，實例化的工作應該交由它的子類來完成，它只需要有一個引用即可。

2、抽象方法必須由子類來進行重寫。

3、只要包含一個抽象方法的抽象類，該方法必須要定義成抽象類，不管是否還包含有其他方法。

4、抽象類中可以包含具體的方法，當然也可以不包含抽象方法。

5、子類中的抽象方法不能與父類的抽象方法同名。

6、abstract不能與final並列修飾同一個類。

7、abstract不能與private、static、final或native並列修飾同一個方法。

㈤ 那位師傅給我講下java里的抽象類的定義方法

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

在 Visual Basic 中，抽象類用 MustInherit 關鍵字表示。在 C# 中，則使用 abstract 修飾符。任何所謂不變的方法都可以編碼至基類中，但在 Visual Basic 中，任何要實現的方法都用 MustOverride 修飾符標記。在 C# 中，這些方法標記為 abstract。

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
抽象方法和抽象類
面向對象程序通過類的分層結構構建起來. 在單重繼承語言如php中, 類的繼承是樹狀的. 一個根類有一個或更多的子類,再從每個子類繼承出一個或更多下一級子類. 當然,可能存在多個根類,用來實現不同的功能. 在一個良好設計的體系中,每個根類都應該有一個有用的介面, 可以被應用代碼所使用. 如果我們的應用代碼被設計成與根類一起工作,那麼它也可以和任何一個從根類繼承出來的子類合作.

抽象方法是就像子類中一般的方法的佔位符(占個地方但不起作用),它與一般方法不同—沒有任何代碼. 如果類中存在一個或更多抽象方法, 那麼這個類就成了抽象類. 你不能實例化抽象類. 你必須繼承它們,然後實例化子類. 你也可以把抽象類看成是子類的一個模板.

如果你覆寫所有的抽象方法, 子類就變成一個普通的類. 如果沒有覆寫所有方法, 子類仍是抽象的. 如果一個類中中包含有抽象方法(哪怕只有一個), 你必須聲明這個類是抽象的, 在class關鍵字前加上abstract.

聲明抽象方法的語法與聲明一般方法不同. 抽象方法的沒有像一般方法那樣包含在大括弧{}中的主體部份,並用分號;來結束.

在例子6.13中, 我們定義了一個含有getarea方法的類shape. 但由於不知道形狀不可能確定圖形的面積,確良我們聲明了getarea方法為抽象方法. 你不能實例化一個shape對象,但你可以繼承它或在一個表達式中使用它, 就像例6.13中那樣.

如果你建立了一個只有抽象方法的類,你就定義了一個介面(interface). 為了說明這種情況, php中有interface 和implements關鍵字. 你可以用interface來代替抽象類, 用implements來代替extends來說明你的類定義或使用一個介面. 例如, 你可以寫一個myclass implements myiterface. 這兩種方法可以依個人偏愛來選擇.

/*注:
兩種方法即指:
1. abstract class aaa{} (注意aaa中只有抽象方法,沒有一般方法)
class bbb extends aaa{} (在bbb中覆寫aaa中的抽象方法)
2. interface aaa{}
class bbb implements aaa{} (在bbb中覆寫aaa中的抽象方法)
*/

listing 6.13 abstract classes
<?php
//abstract root class 抽象根類
abstract class shape
{
abstract function getarea(); //定義一個抽象方法
}

//abstract child class 抽象子類
abstract class polygon extends shape //多邊形
{
abstract function getnumberofsides();
}

//concrete class 實體類 三角形類
class triangle extends polygon
{
public $base;
public $height;

public function getarea() //覆寫計算面積方法
{
return(($this->base * $this->height)/2);
}

public function getnumberofsides() //覆寫邊數統計方法
{
return(3);
}
}

//concrete class 實體類四邊形
class rectangle extends polygon
{
public $width;
public $height;

public function getarea()
{
return($this->width * $this->height);
}

public function getnumberofsides()
{
return(4);
}
}

//concrete class 實體類 圓形
class circle extends shape
{
public $radius;

public function getarea()
{
return(pi() * $this->radius * $this->radius);
}
}

//concrete root class 定義一個顏色類
class color
{
public $name;
}

$mycollection = array(); //建立形狀的集合,放入數組

//make a rectangle
$r = new rectangle;
$r->width = 5;
$r->height = 7;
$mycollection[] = $r;
unset($r);

//make a triangle
$t = new triangle;
$t->base = 4;
$t->height = 5;
$mycollection[] = $t;
unset($t);

//make a circle
$c = new circle;
$c->radius = 3;
$mycollection[] = $c;
unset($c);

//make a color
$c = new color;
$c->name = "blue";
$mycollection[] = $c;
unset($c);

foreach($mycollection as $s)
{
if($s instanceof shape) //如果$s是shape類的實例
{
print("area: " . $s->getarea() .
"<br>n");
}

if($s instanceof polygon)
{
print("sides: " .
$s->getnumberofsides() .
"<br>n");
}

if($s instanceof color)
{
print("color: $s->name<br>n");
}

print("<br>n");
}

㈥ 在抽象類中定義抽象方法需要用abstract聲明，但是在介面中定義的抽象方法是不是可以不用abstract聲明

可以，在介面中默認方法都是抽象的（abstract）,不管是否使用public
abstract，都一樣，所以可以省略不寫。

㈦ java里的抽象方法是怎麼定義的

1 用abstract關鍵字來修飾一個類時，這個類叫做抽象類；用abstract來修飾一個方法時，該方法叫做抽象方法。例如 ：
abstract class Animal { //用abstract來定義一個Animal為抽象類
}

public abstract void enjoy(); //用abstract來定義一個抽象方法"enjoy"

㈧ 如何用c#定義一個抽象類

1、聲明一個抽象方法使用abstract關鍵字。
2、一個類中可以包含一個或多個抽象方法。
3、抽象類中可以存在非抽象的方法。
4、抽象類不能被直接被實例化。
5、實現抽象類用「:」（冒號），實現抽象方法用override關鍵字。
6、抽象類可以被抽象類所繼承，結果仍是抽象類。
7、抽象方法被實現後，不能更改修飾符。
DEMO:
public abstract class Person
{
public abstract void SayHello();
public void about()
{
Console.WriteLine("Abstract Demo");
}
}

public class Student : Person
{
public override void SayHello()
{
Console.WriteLine("SayHello");
}
}
class MainClass
{
public static void Main()
{
new Student().SayHello();
}
}

㈨ java 父類中抽象方法如何定義

用abstract修飾的方法即為抽象方法，

如：public abstract void method();

知識要注意，抽象方法不能有實現，包含抽象方法的類，必須也是抽象類

㈩ 抽象類的概念理解

在面向對象的概念中，所有的對象都是通過類來描繪的，但是反過來，並不是所有的類都是用來描繪對象的，如果一個類中沒有包含足夠的信息來描繪一個具體的對象，這樣的類就是抽象類。
抽象類往往用來表徵對問題領域進行分析、設計中得出的抽象概念，是對一系列看上去不同，但是本質上相同的具體概念的抽象。
比如，在一個圖形編輯軟體的分析設計過程中，就會發現問題領域存在著圓、三角形這樣一些具體概念，它們是不同的，但是它們又都屬於形狀這樣一個概念，形狀這個概念在問題領域並不是直接存在的，它就是一個抽象概念。而正是因為抽象的概念在問題領域沒有對應的具體概念，所以用以表徵抽象概念的抽象類是不能夠實例化的。 抽象類表示該類中可能已經有一些方法的具體定義，但是介面就僅僅只能定義各個方法的界面（方法名，參數列表，返回類型），並不關心具體細節。
介面是引用類型的，和抽象類的相似之處有三點： 不能實例化； 包含未實現的方法聲明； 派生類必須實現未實現的方法，抽象類是抽象方法，介面則是所有成員（不僅是方法包括其他成員）。 抽象類與介面緊密相關。然而介面又比抽象類更抽象，這主要體現在它們的差別上： 類可以實現無限個介面，但僅能從一個抽象（或任何其他類型）類繼承，從抽象類派生的類仍可實現介面，從而得出介面是用來解決多重繼承問題的。 抽象類當中可以存在非抽象的方法，可介面不能，且它裡面的方法只是一個聲明必須用public來修飾沒有具體實現的方法。 抽象類中的成員變數可以被不同的修飾符來修飾，可介面中的成員變數默認的都是靜態常量（static final）。 抽象類是對象的抽象，然而介面是一種行為規范。 抽象類裡面可以有非抽象方法但介面里只能有抽象方法 聲明方法的存在而不去實現它的類被叫做抽像類（abstract class），它用於要創建一個體現某些基本行為的類，並為該類聲明方法，但不能在該類中實現該類的情況。不能創建abstract 類的實例。然而可以創建一個變數，其類型是一個抽像類，並讓它指向具體子類的一個實例。不能有抽像構造函數或抽像靜態方法。Abstract 類的子類為它們父類中的所有抽像方法提供實現，否則它們也是抽像類為。取而代之，在子類中實現該方法。知道其行為的其它類可以在類中實現這些方法。介面（interface）是抽像類的變體。在介面中，所有方法都是抽像的。多繼承性可通過實現這樣的介面而獲得。介面中的所有方法都是抽像的，沒有一個有程序體。介面只可以定義static final成員變數。介面的實現與子類相似，除了該實現類不能從介面定義中繼承行為。當類實現特殊介面時，它定義（即將程序體給予）所有這種介面的方法。然後，它可以在實現了該介面的類的任何對像上調用介面的方法。由於有抽像類，它允許使用介面名作為引用變數的類型。通常的動態聯編將生效。引用可以轉換到介面類型或從介面類型轉換，instanceof 運算符可以用來決定某對象的類是否實現了介面