java的抽象類
① java中什麼是抽象類和抽象方法創建有何作用
使用了關鍵詞abstract聲明的類叫作"抽象類"。如果一個類里包含了一個或多個抽象方法,類就必須指定成abstract(抽象)。"抽象方法",屬於一種不完整的方法,只含有一個聲明,沒有方法主體。
java抽象類的作用:
1、通過繼承它實現多態,後期綁定,可以為將來要實現的東西做好介面,實現重用性。
2、介面就是更純粹的抽象類。
② 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中抽象類的存在的意義是什麼
java中抽象類更利於代碼的維護和重用。
抽象類往往用來表徵對問題領域進行分析、設計中得出的抽象概念,是對一系列看上去不同,但是本質上相同的具體概念的抽象。具體分析如下:
1.因為抽象類不能實例化對象,所以必須要有子類來實現它之後才能使用。這樣就可以把一些具有相同屬性和方法的組件進行抽象,這樣更有利於代碼和程序的維護。
比如本科和研究生可以抽象成學生,他們有相同的屬性和方法。這樣當你對其中某個類進行修改時會受到父類的限制,這樣就會提醒開發人員有些東西不能進行隨意修改,這樣可以對比較重要的東西進行統一的限制,也算是一種保護,對維護會有很大的幫助。
2.當又有一個具有相似的組件產生時,只需要實現該抽象類就可以獲得該抽象類的那些屬性和方法。
比如學校又新產生了專科生這類學生,那麼專科生直接繼承學生,然後對自己特有的屬性和方法進行補充即可。這樣對於代碼的重用也是很好的體現。
所以,Java中抽象類對於代碼的維護和重用有很好的幫助,也是Java面向對象的一個重要體現。
⑤ java中抽象類的作用是什麼
抽象類比較像普通類和介面的結合,因為抽象類可以像普通類那樣在類中實現方法,也可以像介面一樣,只聲明,不實現。下面的一個抽象類的實例:
public abstract class TravelTool{ //抽象類需在類的關鍵字class前加上關鍵字abstract。
//抽象方法沒有方法體,需在方法返回值前加上關鍵字abstract,並以分號結尾。
public abstract String drive(int i);
}
抽象類可以有抽象方法,如果它的子類是抽象類,那麼子類不必實現抽象類的抽象方法;如果子類不是抽象類,那麼子類必須實現抽象類的抽象方法。需要注意的是,不能實例化抽象類對象。若子類為非抽象類那麼子類可以實例化對象。
如果你還是不太明白抽象類。你可以上秒秒學了解下,上面說的比較形象。
⑥ JAVA: 為什麼要使用"抽象類" 使用"抽象類"有什麼好處
簡單來說吧
抽象類是在介面和實體類之間的一個橋梁
例如
做一個介面叫做飛行FlyAnimalAction,裡面定義一個方法叫做flying,再定義一個方法叫做eat
做一個類叫做蚊子實現介面,蚊子要實現flying方法,實現自己的eat方法
做一個類叫做蒼蠅實現介面,蒼蠅也要實現flying方法,實現自己的eat方法
你發現所有會飛的動物都要實現這個介面,很麻煩,不如
做一個抽象類FlyAnimal,然後實現上面的介面
在裡面實現flying這個方法,因為大部分的飛行動作是一樣的,而eat方法則繼續寫成抽象方法,因為大部分的動物吃東西是不一樣的
下面你再寫蚊子類就簡單了,可以直接繼承這個抽象類,然後實現自己的吃方法就行了
而且蒼蠅類的製作也是一樣,這個時候抽象類的功能就顯示出來了,當然抽象類的功能遠遠不是這些,只是初期理解到這里就夠了。
有興趣可以交流交流,Q:405960,註明:JAVA技術交流
⑦ 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中的抽象類
抽象是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(抽象)。「抽象方法」,屬於一種不完整的方法,只含有一個聲明,沒有方法主體
⑩ java抽象類
抽象類是不允許被實例化, 僅僅是限制抽象類不能創建自己的實例, 僅僅只是限定了不允許出現new A();方式創建一個 A 類的實例
並沒有限制 類型 A 的引用不可以指向任何 A 的直接或間接子類的具體實例的
父類型引用指向一個子類型的實例這是允許的,這就是里氏代換原則的描述