java中抽象類

㈠ java: 為什麼要使用"抽象類" 使用"抽象類"有什麼好處

簡單來說吧
抽象類是在介面和實體類之間的一個橋梁
例如
做一個介面叫做飛行FlyAnimalAction，裡面定義一個方法叫做flying，再定義一個方法叫做eat
做一個類叫做蚊子實現介面，蚊子要實現flying方法，實現自己的eat方法
做一個類叫做蒼蠅實現介面，蒼蠅也要實現flying方法，實現自己的eat方法
你發現所有會飛的動物都要實現這個介面，很麻煩，不如
做一個抽象類FlyAnimal,然後實現上面的介面
在裡面實現flying這個方法，因為大部分的飛行動作是一樣的，而eat方法則繼續寫成抽象方法，因為大部分的動物吃東西是不一樣的
下面你再寫蚊子類就簡單了，可以直接繼承這個抽象類，然後實現自己的吃方法就行了
而且蒼蠅類的製作也是一樣，這個時候抽象類的功能就顯示出來了，當然抽象類的功能遠遠不是這些，只是初期理解到這里就夠了。
有興趣可以交流交流,Q:405960,註明:JAVA技術交流

㈡ java抽象類

具有關鍵字abstract ，在實現內容上沒有完全定義的類就叫抽象類。 抽象類和介面的區別如下： ① 在類來繼承抽象類時，只需實現部分具體方法和全部抽象方法，而實現介面則要實現裡面的全部方法。 ②在介面中無成員變數，而抽象類中可有成員變數。 在Java中引進介面主要是為了解決多繼承的問題。 1）介面中不能有非抽象方法，但抽象類中可以有。 2）一個類能實現多個介面，但只能有一個父類。 3）介面並不屬於繼承結構，它實際與繼承無關，因此無關的類也可以實現同一個介面。 抽象類和方法 在我們所有樂器（Instrument）例子中，基礎類Instrument內的方法都肯定是「偽」方法。若去調用這些方法，就會出現錯誤。那是由於Instrument的意圖是為從它衍生出去的所有類都創建一個通用介面。 之所以要建立這個通用介面，唯一的原因就是它能為不同的子類型作出不同的表示。它為我們建立了一種基本形式，使我們能定義在所有衍生類里「通用」的一些東西。為闡述這個觀念，另一個方法是把Instrument稱為「抽象基礎類」（簡稱「抽象類」）。若想通過該通用介面處理一系列類，就需要創建一個抽象類。對所有與基礎類聲明的簽名相符的衍生類方法，都可以通過動態綁定機制進行調用（然而，正如上一節指出的那樣，如果方法名與基礎類相同，但自變數或參數不同，就會出現過載現象，那或許並非我們所願意的）。 如果有一個象Instrument那樣的抽象類，那個類的對象幾乎肯定沒有什麼意義。換言之，Instrument的作用僅僅是表達介面，而不是表達一些具體的實施細節。所以創建一個Instrument對象是沒有意義的，而且我們通常都應禁止用戶那樣做。為達到這個目的，可令Instrument內的所有方法都顯示出錯消息。但這樣做會延遲信息到運行期，並要求在用戶那一面進行徹底、可靠的測試。無論如何，最好的方法都是在編譯期間捕捉到問題。 針對這個問題，Java專門提供了一種機制，名為「抽象方法」。它屬於一種不完整的方法，只含有一個聲明，沒有方法主體。下面是抽象方法聲明時採用的語法： abstract void X(); 包含了抽象方法的一個類叫作「抽象類」。如果一個類里包含了一個或多個抽象方法，類就必須指定成abstract（抽象）。否則，編譯器會向我們報告一條出錯消息。 若一個抽象類是不完整的，那麼一旦有人試圖生成那個類的一個對象，編譯器又會採取什麼行動呢？由於不能安全地為一個抽象類創建屬於它的對象，所以會從編譯器那裡獲得一條出錯提示。通過這種方法，編譯器可保證抽象類的「純潔性」，我們不必擔心會誤用它。 如果從一個抽象類繼承，而且想生成新類型的一個對象，就必須為基礎類中的所有抽象方法提供方法定義。如果不這樣做（完全可以選擇不做），則衍生類也會是抽象的，而且編譯器會強迫我們用abstract關鍵字標志那個類的「抽象」本質。 即使不包括任何abstract方法，亦可將一個類聲明成「抽象類」。如果一個類沒必要擁有任何抽象方法，而且我們想禁止那個類的所有實例，這種能力就會顯得非常有用。 介面 「interface」（介面）關鍵字使抽象的概念更深入了一層。我們可將其想像為一個「純」抽象類。它允許創建者規定一個類的基本形式：方法名、自變數列表以及返回類型，但不規定方法主體。介面也包含了基本數據類型的數據成員，但它們都默認為static和final。介面只提供一種形式，並不提供實施的細節。 介面這樣描述自己：「對於實現我的所有類，看起來都應該象我現在這個樣子」。因此，採用了一個特定介面的所有代碼都知道對於那個介面可能會調用什麼方法。這便是介面的全部含義。所以我們常把介面用於建立類和類之間的一個「協議」。有些面向對象的程序設計語言採用了一個名為「protocol」（協議）的關鍵字，它做的便是與介面相同的事情。 為創建一個介面，請使用interface關鍵字，而不要用class。與類相似，我們可在interface關鍵字的前面增加一個public關鍵字（但只有介面定義於同名的一個文件內）；或者將其省略，營造一種「友好的」狀態。 為了生成與一個特定的介面（或一組介面）相符的類，要使用implements（實現）關鍵字。我們要表達的意思是「介面看起來就象那個樣子，這兒是它具體的工作細節」。除這些之外，我們其他的工作都與繼承極為相似 http://hi..com/%B3%C2%C0%CB%CF%C9/blog/item/f8caaec3c21a3255b219a84c.html 這里講得更細一些

㈢ java 抽象類是 什麼

使用了關鍵詞abstract聲明的類叫作「抽象類」。如果一個類里包含了一個或多個抽象方法，類就必須指定成abstract（抽象）。「抽象方法」,屬於一種不完整的方法，只含有一個聲明，沒有方法主體。

抽象語法編輯

下面是抽象方法聲明時採用的語法：

abstract void f();

如果從一個抽象類繼承，而且想生成新類型的一個對象，就必須為基礎類中的所有抽象方法提供方法定義。

如果不這樣做（完全可以選擇不做），則衍生類也會是抽象的，而且編譯器會強迫我們用abstract 關鍵字標志那個類的「抽象」本質。

即使不包括任何abstract 方法，亦可將一個類聲明成「抽象類」。如果一個類沒必要擁有任何抽象方法，而且我們想禁止那個類的所有實例，這種能力就會顯得非常有用。

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

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

2對比介面編輯

語法定義層

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

編程層面

abstract class在Java語言中表示的是一種繼承關系，一個類只能使用一次繼承關系。但是，一個類卻可以實現多個interface。

設計理念層面

abstract class在Java語言中體現了一種繼承關系，要想使得繼承關系合理，父類和派生類之間必須存在"is a"關系，即父類和派生類在概念本質上應該是相同的。 對於interface 來說則不然，並不要求interface的實現者和interface定義在概念本質上是一致的，僅僅是實現了interface定義的契約（功能）而已。

四、抽象類的示例代碼

//: interfaces/music4/Music4.java

// Abstract classes and methods.

/* 抽象類的功能

* 使類的抽象性明確起來

*

*/

// 以下是 抽象類 的示例

package interfaces.music4;

import pets.Pet;

import polymorphism.music.Note;

import static net.mindview.util.Print.*;

/* 1. 抽象方法 abstract void f(); 抽象方法不能包含有任何方法的BODY 。

* 2. 如果一個類包含1個或者多個抽象方法， 則該類必須限定為抽象的。

* 需要在前面指定 abstract 關鍵字。

* （1）抽象類不能被實例化

* （2）包含抽象方法的類，必須標識 abstract

* 3. 如果從一個抽象類繼承， 必須對所有抽象方法進行覆蓋 , 否則導出類也是抽象的

* 4. 也可以考慮創建沒有任何抽象方法的抽象類 。

*

*/

abstract class Instrument {

// 抽象類中可以有非抽象方法。

private int i; // Storage allocated for each

public abstract void play(Note n);

public String what() { return "Instrument"; }

public abstract void adjust();

}

/*

（2）包含抽象方法的類，必須標識 abstract， 否則編譯器會報錯

class abc

{

public abstract void Demo();

}*/

class Wind extends Instrument {

public void play(Note n) {

print("Wind.play() " + n);

}

public String what() { return "Wind"; }

public void adjust() {}

}

class Percussion extends Instrument {

public void play(Note n) {

print("Percussion.play() " + n);

}

public String what() { return "Percussion"; }

public void adjust() {}

}

class Stringed extends Instrument {

public void play(Note n) {

print("Stringed.play() " + n);

}

public String what() { return "Stringed"; }

public void adjust() {}

}

class Brass extends Wind {

public void play(Note n) {

print("Brass.play() " + n);

}

public void adjust() { print("Brass.adjust()"); }

}

class Woodwind extends Wind {

public void play(Note n) {

print("Woodwind.play() " + n);

}

public String what() { return "Woodwind"; }

}

class TestAbsExt extends Instrument

{

public void play( Note n ) {

print ("TestAbsExt.play()" + n);

}

public String what()

{

return "TestAbsExt";

}

public void adjust()

{

}

}

// 不含任何抽象方法的抽象類

abstract class AbsClass

{

public void f1() {

print("f1()");

}

public void f2() {

print("f2()");

}

}

public class Music4 {

// Doesn't care about type, so new types

// added to the system still work right:

static void tune(Instrument i) {

// ...

i.play(Note.MIDDLE_C);

}

static void tuneAll(Instrument[] e) {

for(Instrument i : e)

tune(i);

}

public static void main(String[] args) {

// !抽象類不能被實例化

// 若使用以下語句 ， 將會收到報錯。

/* Exception in thread "main" java.lang.Error: Unresolved compilation problem:

Instructment cannot be resolved to a type

*/

// ! new Instructment();

// Upcasting ring addition to the array:

Instrument[] orchestra = {

new Wind(),

new Percussion(),

new Stringed(),

new Brass(),

new Woodwind()

};

tuneAll(orchestra);

}

} /* Output:

Wind.play() MIDDLE_C

Percussion.play() MIDDLE_C

Stringed.play() MIDDLE_C

Brass.play() MIDDLE_C

Woodwind.play() MIDDLE_C

*///:~

/*

* 抽象方法不能包含有任何方法的BODY 。

*/

/*

abstract class RodentAbs extends Pet {

abstract public Rodent(String name) { super(name); }

abstract public Rodent() { super(); }

} ///:~

*/

㈣ Java抽象類是什麼概念

JAVA的抽象類其實和她的普通類在表示實現概念的東西沒多大區別,不要因她帶有抽象這個形容詞就覺得比她的普通類理解起來復雜.
個人的理解是
所謂的抽象類呢,就是帶有抽象方法的類.
所謂的抽象方法就像是一種寫代碼的規范.
抽象方法沒有方法體
抽象方法可以有參數列表
抽象方法用abstract修飾
抽象方法的訪問修飾分別為 public、protected、default(預設 不用寫)
加深了解抽象類
/*理解JAVA抽象類
* 1.抽象類不能被實例化.
* 2.抽象類有構造器,且他的構造在他的子類被實例化時被調用的順序和普通類調用的順序是一樣的(先父後子).
* 3.抽象類內部的方法可以不是抽象方法,也就是說抽象類內部可以有具體的方法.
* 4.抽象類的抽象方法屬於一種不完整的方法，只含有聲明和定義，沒有方法主體.
* 5.如果抽象的某個子類是普通類(非abstract類型的類),那麼該子類必須Override抽象類中所有的抽象方法.
* 6.抽象類的子類也是抽象類的話,那麼該子類既可以Override父類中的方法,也可以不Override父類中的方法.
* 7.普通類中不能定義抽象方法.
* 8.static不能修飾抽象方法
* 備注:為了方便理解,所謂的普通是指如下形式定義的類
* public class X{} 或 class A XX{}
* */

㈤ java中抽象類和介面的區別

抽象類是用來捕捉子類的通用特性的 。它不能被實例化，只能被用作子類的超類。抽象類是被用來創建繼承層級里子類的模板。

介面是抽象方法的集合。如果一個類實現了某個介面，那麼它就繼承了這個介面的抽象方法。這就像契約模式，如果實現了這個介面，那麼就必須確保使用這些方法。介面只是一種形式，介面自身不能做任何事情。

(5)java中抽象類擴展閱讀：

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

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

抽象類是不完整的，它只能用作基類。在面向對象方法中，抽象類主要用來進行類型隱藏和充當全局變數的角色。

㈥ java中抽象類的存在的意義是什麼

java中抽象類更利於代碼的維護和重用。
抽象類往往用來表徵對問題領域進行分析、設計中得出的抽象概念，是對一系列看上去不同，但是本質上相同的具體概念的抽象。具體分析如下：
1.因為抽象類不能實例化對象，所以必須要有子類來實現它之後才能使用。這樣就可以把一些具有相同屬性和方法的組件進行抽象，這樣更有利於代碼和程序的維護。
比如本科和研究生可以抽象成學生，他們有相同的屬性和方法。這樣當你對其中某個類進行修改時會受到父類的限制，這樣就會提醒開發人員有些東西不能進行隨意修改，這樣可以對比較重要的東西進行統一的限制，也算是一種保護，對維護會有很大的幫助。
2.當又有一個具有相似的組件產生時，只需要實現該抽象類就可以獲得該抽象類的那些屬性和方法。
比如學校又新產生了專科生這類學生，那麼專科生直接繼承學生，然後對自己特有的屬性和方法進行補充即可。這樣對於代碼的重用也是很好的體現。
所以，Java中抽象類對於代碼的維護和重用有很好的幫助，也是Java面向對象的一個重要體現。

㈦ java抽象類

抽象類是不允許被實例化, 僅僅是限制抽象類不能創建自己的實例, 僅僅只是限定了不允許出現new A();方式創建一個 A 類的實例
並沒有限制 類型 A 的引用不可以指向任何 A 的直接或間接子類的具體實例的
父類型引用指向一個子類型的實例這是允許的,這就是里氏代換原則的描述

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

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

㈨ 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中的抽象類與介面有什麼異同

相同點：
（1）都不能被實例化
（2）介面的實現類或抽象類的子類都只有實現了介面或抽象類中的方法後才能實例化。
不同點：
（1）介面只有定義，不能有方法的實現，java 1.8中可以定義default方法體，而抽象類可以有定義與實現，方法可在抽象類中實現。
（2）實現介面的關鍵字為implements，繼承抽象類的關鍵字為extends。一個類可以實現多個介面，但一個類只能繼承一個抽象類。所以，使用介面可以間接地實現多重繼承。
（3）介面強調特定功能的實現，而抽象類強調所屬關系。
（4）介面成員變數默認為public static final，必須賦初值，不能被修改；其所有的成員方法都是public、abstract的。抽象類中成員變數默認default，可在子類中被重新定義，也可被重新賦值；抽象方法被abstract修飾，不能被private、static、synchronized和native等修飾，必須以分號結尾，不帶花括弧。
（5）介面被用於常用的功能，便於日後維護和添加刪除，而抽象類更傾向於充當公共類的角色，不適用於日後重新對立面的代碼修改。功能需要累積時用抽象類，不需要累積時用介面。