java中的抽象類abstract怎麼使用？
抽象類概述
當編寫一個類時，我們往往會為該類定義一些方法，這些方法是用來描述該類的功能具體實現方式，那麼這些方法都有具體的方法體。
但是有的時候，某個父類只是知道子類應該包含怎麼樣的方法，但是無法準確知道子類如何實現這些方法。比如一個圖形類應該有一個求周長的方法，但是不同的圖形求周長的演算法不一樣。那該怎麼辦呢？
分析事物時，發現了共性內容，就出現向上抽取。會有這樣一種特殊情況，就是方法功能宣告相同，但方法功能主體不同。那麼這時也可以抽取，但只抽取方法宣告，不抽取方法主體。那麼此方法就是一個抽象方法。
1 、 案例程式碼 :
package com.itheima_01;
/*
* abstract: 關鍵字，用於修飾方法和類
* 抽象方法：不同類的方法是相似，但是具體內容又不太一樣，所以我們只能抽取他的宣告，沒有具體的方法體，沒有具體方法體的方法就是抽象方法
* 抽象類：有抽象方法的類必須是抽象類
*
* 注意：一個類繼承了抽象類需要重寫他所有的抽象方法 , 否則這個類就得是抽象類
*/
public class AbstractDemo {
}
abstract class Animal1 {
public abstract void eat();
// 非抽象方法子類可以不重寫
public void run() {
}
}
class Cat1 extends Animal1 {
@Override
public void eat() {
System.out.println(" 貓吃魚 ");
}
/*public void eat() {
System.out.println(" 貓吃魚 ");
}*/
}
abstract class Dog1 extends Animal1 {
/*public void eat() {
System.out.println(" 狗吃屎 ");
}*/
}
2 、 抽象類的特點
抽象類的特點：
抽象方法只能在抽象類裡面
抽象類和抽象方法必須被 abstract 修飾
抽象類不能建立物件（不能例項化）
抽象類中可以有非抽象的方法
抽象類和類的關係也是繼承
一個類繼承了抽象類要麼重寫所有的抽象方法，要麼他自己是抽象類
案例程式碼:
package com.itheima_01;
/*
* 抽象類的特點：
* 抽象方法只能在抽象類裡面
* 抽象類和抽象方法必須被abstract 修飾
* 抽象類不能建立物件（不能例項化）
* 抽象類中可以有非抽象的方法
* 抽象類和類的關係也是繼承
* 一個類繼承了抽象類要麼重寫所有的抽象方法，要麼他自己是抽象類
*/
public class AbstractDemo2 {
public static void main(String[] args) {
//Animal a = new Animal();
}
}
abstract class Animal2 {
public abstract void eat();
public void run() {
}
}
class Cat2 extends Animal2 {
@Override
public void eat() {
// TODO Auto-generated method stub
}
}
3 、抽象類的成員的特點
A: 抽象類的成員特點：
成員變數
可以有成員變數
可以有常量
成員方法
可以有抽象方法
可以有非抽象方法
構造方法
可以有構造方法的，需要對抽象類的成員變數進行初始化
案例程式碼:
package com.itheima_01;
/*
* 抽象類的成員特點：
* 成員變數
* 可以有成員變數
* 可以有常量
* 成員方法
* 可以有抽象方法
* 可以有非抽象方法
* 構造方法
* 可以有構造方法的，需要對抽象類的成員變數進行初始化
*
* final: 修飾類、成員變數、成員方法
*/
public class AbstractDemo3 {
public static void main(String[] args) {
Dog d = new Dog();
d.barking();
}
}
abstract class Animal {
String name = " 哮天犬 ";
final int num = 10;
public Animal() {
System.out.println(" 我是抽象類的構造方法 ");
}
public abstract void eat();
public void run() {}
}
class Dog extends Animal {
public void barking() {
System.out.println(name);
System.out.println(num);
}
@Override
public void eat() {
// TODO Auto-generated method stub
}
}
4 、抽象類的細節
A: 抽象類關鍵字 abstract 可以和哪些關鍵字共存 ?
1.private ：
私有的方法子類是無法繼承到的，也不存在覆蓋，而abstract 和 private 一起使用修飾方法， abstract 既要子類去實現這個方法，而 private 修飾子類根本無法得到父類這個方法。互相矛盾。
2.final:
抽象類不能和 final 共存 , 因為抽象類自身無法建立物件 , 我們需要通過子類建立物件 , 一旦抽象類使用 final 關鍵字 , 那麼抽象類就沒有子類
抽象方法不能和 final 共存 , 因為抽象方法後期需要被子類重寫 , 一旦加 final 無法重寫
3.static:
抽象方法不能和 static 關鍵字共存 , 因為一旦加 static 我們就可以通過類名直接訪問抽象方法 , 由於抽象方法沒有方法體 , 沒有任何意義 , 也不允許這樣做
B: 抽象類中是否可以不定義抽象方法 ?
是可以的，那這個抽象類的存在到底有什麼意義呢？不讓該類建立物件, 方法可以直接讓子類去使用
C: 抽象類是否有建構函式 ?
有, 抽象類的建構函式 , 是由子類的 super 語句來呼叫 , 用於給抽象類中的成員初始化
用關鍵字abstract 修飾的方法稱為抽象方法。
對於抽象方法，只允許宣告，不允許實現（沒有方法體），而且不允許finnal 和 abstract 修飾同一方法或類，也不允許 static 修飾 abstr 方法，即 abstract 方法必須是實列方法。
abstra 類不能用 new 運算子建立物件
abstract 類的子類必需重寫 abstra 類中的方法
abstra 類的物件作為上轉型物件
abstract class GirlFriend {
abstract void speak();
abstract void cooking();
}
class ChinaGirlFriend extends GirlFriend {
void speak() {
System.out.println(" 你好 ");
}
void cooking() {
System.out.println(" 水煮魚 ");
}
}
class AmericanGirlFriend extends GirlFriend {
void speak() {
System.out.println("Hello!");
}
void cooking() {
System.out.println("Roast beef");
}
}
class Boy {
GirlFriend friend;
void SetGirFriend(GirlFriend f) {
friend = f;
}
void showGirlFriend() {
friend.speak();
friend.cooking();
}
}
public class Test {
public static void main(String[] args) {
GirlFriend girl = new ChinaGirlFriend(); //girl is Upper Transition Object
Boy boy = new Boy();
boy.SetGirFriend(girl);
boy.showGirlFriend();
girl = new AmericanGirlFriend();
boy.SetGirFriend(girl);
boy.showGirlFriend();
}
}
面向抽象程式設計
在程式設計中我們經常會使用abstra 類，因為它只關心操作，而不在意具體實現細節。
所謂的面向抽象程式設計，是指設計某種重要的類時，不讓該類面向具體的類，而是面向抽象類。
import java.awt.*;
public class Test {
public static void main(String[] args) {
double a,b;
Pillar pillar;
Geometry bottom=null;
pillar=new Pillar(bottom,100);
System.out.println(" 體積 "+pillar.getVolume());
bottom=new Rectangle(12,22);
pillar=new Pillar(bottom,58);
System.out.println(" 體積 "+pillar.getVolume());
bottom=new Circle(10);
pillar=new Pillar(bottom,58);
System.out.println(" 體積 "+pillar.getVolume());
}
}
abstract class Geometry {
abstract double getArea();
}
class Pillar {
Geometry bottom; //bottom is a variable by the abstract class geometry
double height;
Pillar(Geometry bottom, double height) {
this.bottom = bottom;
this.height = height;
}
public double getVolume() {
if (bottom == null) {
System.out.println(" 沒有底，無法計算面積！ ");
return -1;
}
return bottom.getArea() * height; //Bottom can call the getArea method that the subclass overrides
}
}
class Circle extends Geometry {
double r;
Circle(double r) {
this.r = r;
}
public double getArea() {
return (3.14 * 3.14 * r);
}
}
class Rectangle extends Geometry{
double a, b;
Rectangle(double a, double b) {
this.a = a;
this.b = b;
}
double getArea() {
return a * b;
}
}
為什麼使用抽象類
首先做一個分析如下：
1 ：定義 Dog 類
有顏色屬性和叫的方法
2 ：定義 Bird 類
有顏色屬性和叫的方法
3 ：定義其父類 Animal
1 ：抽取共性顏色屬性和叫的方法
1 ：顏色的屬性可以使用預設初始化值。
2 ：叫的方法在父類中如何定義？
1 ：狗是旺旺
2 ：鳥是嘰嘰喳喳
3 ：可以將父類的方法定義為狗叫讓鳥繼承父類重寫叫的方法
1 ：鳥怎麼確定是否要重寫父類方法。
2 ：不重寫，編譯和執行都沒有問題，只是執行鳥叫的方法就會出現狗叫
4 ：父類的方法很難確定。
上方描述程式碼如下：
function(){ //外匯返傭：http://www.kaifx.cn/
class Animal {
String color;
void shout(){
// 如何定義呢 ? 是旺旺還是嘰嘰喳喳 ?
}
}
class Dog extends Animal {
void shout() {
System.out.println(" 旺旺 ");
}
}
class Bird extends Animal {
void shout() {
System.out.println(" 嘰嘰喳喳 ");
}
}
那麼此時使用abstract 能夠解決這個問題 。
4 ：抽象類
1 ：當描述一個類的時候，如果不能確定功能函式如何定義，那麼該類就可以定義為抽象類，功能函式應該描述為抽象函式。
5 ：抽象類的實現方式
1 ：定義 animal 類
1 ：定義叫的方法，無法確定方法體，不寫方法體
1 ： public void shout (); 編譯失敗
2 ：根據提示在 shout 的方法加入 abstract 修飾
1 ：編譯失敗，有新的提示
3 ：根據提示將類加入 abstract 修飾
1 ：編譯通過
abstract class Animal {
String color;
abstract void shout();
}
class Dog extends Animal {
void shout() {
System.out.println(" 旺旺 ");
}
}
class Bird extends Animal {
void shout() {
System.out.println(" 嘰嘰喳喳 ");
}
}
6 ：抽象類的特點
1 ：有抽象函式的類，該類一定是抽象類。
2 ：抽象類中不一定要有抽象函式。
3 ：抽象類不能使用 new 建立物件
1 ：建立物件，使用物件的功能，抽象類的方法，沒有方法體。
4 ：抽象類主要為了提高程式碼的複用性，讓子類繼承來使用。
5 ：編譯器強制子類實現抽象類父類的未實現的方法。
1 ：可以不實現，前提是子類的也要宣告為抽象的。
7 ：抽象的優點
1 ：提高程式碼複用性
2 ：強制子類實現父類中沒有實現的功能
3 ：提高程式碼的擴充套件性，便於後期的程式碼維護
8 ：抽象類不能建立物件，那麼抽象類中是否有建構函式？
抽象類中一定有建構函式。主要為了初始化抽象類中的屬性。通常由子類實現。
9 ： final 和 abstract 是否可以同時修飾一個類？
一定不能同時修飾。
abstract class Animal {
String name;
// 抽象類可以有建構函式
Animal() {
}
Animal(String name) {
this.name = name;
}
abstract void shout();
}
class Dog extends Animal {
Dog() {
}
Dog(String name) {
super(name);
}
void shout() {
System.out.println(" 旺旺 ");
}
}
class Demo3 {
public static void main(String[] args) {
// 抽象類不能建立物件
// Animal a=new Animal();
Dog d = new Dog(" 旺財 ");
System.out.println();
}
}
來自 “ ITPUB部落格 ” ，連結：http://blog.itpub.net/69946279/viewspace-2657918/，如需轉載，請註明出處，否則將追究法律責任。
相關文章
- TypeScript abstract 抽象類TypeScript抽象
- 介面和抽象類 (abstract)抽象
- PHP中的 抽象類（abstract class）和 介面（interface）PHP抽象
- C++中的抽象基類(Abstract Base Class)C++抽象
- java中的抽象類與介面Java抽象
- java中抽象類和介面Java抽象
- Java 抽象類Java抽象
- Java中的介面與抽象類詳解Java抽象
- Java的抽象類 & 介面Java抽象
- JavaSE第三章 物件導向 抽象類 abstractJava物件抽象
- 什麼是抽象類?怎麼定義?抽象
- Java中的基本型別包裝類 Integer 類該怎麼使用？Java型別
- Java —— 流的抽象基類Java抽象
- Java中的抽象Java抽象
- Java中的介面與抽象類設計原則Java抽象
- Java中抽象類和介面的區別Java抽象
- Java中抽象類與介面的區別Java抽象
- 抽象語法樹 Abstract syntax tree抽象語法樹
- 走進C# abstract，瞭解抽象類與介面的異同C#抽象
- Java 的抽象類, 介面以及內部類Java抽象
- [JAVA] Java物件導向之final、abstract抽象、和變數生命週期Java物件抽象變數
- Java的抽象類與介面理解Java抽象
- 淺談Java抽象類Java抽象
- python中calss(類)的使用，類的教程，類中的函式怎麼呼叫。Python函式
- JAVA物件導向--抽象類Java物件抽象
- 關於Java中的物件、類、抽象類、介面、繼承之間的聯絡Java物件抽象繼承
- Java 介面和抽象類是什麼，有什麼區別Java抽象
- PHP 抽象類繼承抽象類時的注意點PHP 抽象類繼承抽象類時的注意點PHP抽象繼承
- JAVA 中interface 和 abstract 區別Java
- Java集合為什麼設計為：實現類繼承了抽象類，同時實現抽象類實現的介面Java繼承抽象
- Abstract Factory（抽象工廠）——物件建立型模式抽象物件模式
- java介面和抽象類的簡單理解Java抽象
- Java中的Reference類使用Java
- Java總結-抽象類與介面Java抽象
- Java基礎-抽象類和介面Java抽象
- Java抽象類和介面 小白版Java抽象
- Java之繼承和抽象類Java繼承抽象
- Java 8 中的抽象類和介面到底有啥區別？Java抽象