抽象類
抽象是一種概念，而不是如何實現，比如你的老板說，大家加油哈，將來發財了人人有份。又如，好好學，將來必成大牛，這些都可以理解成是一種抽象的，你也可以理解成所謂的抽象就是光說不做。
在Java中通過abstract關鍵字定義抽象類，如下
abstract class Base{
....
}
被定義為抽象的類，不能使用new關鍵字，首先我們得理解一件事，那就是抽象類，不是給你直接拿來用的，不然就不叫抽象了。
不僅類可以是抽象的，方法也同樣可以是抽象的，比如下面這段代碼
class Base{
abstract void hello(){
System.out.println("hello");
}
}
不過上面這段代碼是錯誤的，我們說抽象是光說不做的，而上面這個hello方法，把具體代碼給實現了，所以是通不過編譯器的，另外一點如果定義了抽象方法，類也必須是抽象的。下面這段代碼才是正確的
abstract class Base{
abstract void hello();
}
方法可以把大括號去掉，並且后面得加上分號。下面是一個實例
abstract class Base{
abstract void hello();
}
class A extends Base{
public void hello(){
System.out.println("hello A");
}
}
class B extends Base{
public void hello(){
System.out.println("hello B");
}
}
class app{
public static void main(String[] args){
A a = new A();
B b = new B();
a.hello();
b.hello();
}
}
------Output------
hello A
hello B
因為是抽象類所以我們必須在繼承它的子類中實現具體的方法。那么問題來了，既然都得自己去實現，那和下面這段代碼有什么區別嗎
class Base{
}
class A extends Base{
public void hello(){
System.out.println("hello A");
}
}
class B extends Base{
public void hello(){
System.out.println("hello B");
}
}
class app{
public static void main(String[] args){
A a = new A();
B b = new B();
a.hello();
b.hello();
}
}
------Output------
hello A
hello B
這樣肯定是沒有問題的，但是如果說我們想運用多態，就不太行了，我們將上面這段改為多態就會報錯，如下
class Base{
}
class A extends Base{
public void hello(){
System.out.println("hello A");
}
}
class B extends Base{
public void hello(){
System.out.println("hello B");
}
}
class app{
public static void main(String[] args){
Base a = new A(); // 注意引用類型
Base b = new B(); // 注意引用類型
a.hello();
b.hello();
}
}
報錯了
我們改成多態以后就報錯了，因為在運用多態時，Base類只認Base中有的方法，除非是子類覆蓋Base中的方法。比如下面這段代碼是可以的
class Base{
public void hello(){
System.out.println("hello Base");
}
}
class A extends Base{
public void hello(){
System.out.println("hello A");
}
}
class B extends Base{
public void hello(){
System.out.println("hello B");
}
}
class app{
public static void main(String[] args){
Base a = new A();
Base b = new B();
a.hello();
b.hello();
}
}
------Output------
hello A
hello B
雖然這樣可以運行，但是你有沒有發現，我們必須實現父類中的hello方法，而如果不實現就不行，像這個情況下，使用抽象類就比較合適了，代碼如下
abstract class Base{
abstract public void hello();
}
class A extends Base{
public void hello(){
System.out.println("hello A");
}
}
class B extends Base{
public void hello(){
System.out.println("hello B");
}
}
class app{
public static void main(String[] args){
Base a = new A();
Base b = new B();
a.hello();
b.hello();
}
}
------Output------
hello A
hello B
另外使用抽象類還有一個好處，我們一眼看過去就能知道，這是一個抽象類。而如果是下面這段代碼，就沒那么容易分辨了
class Base{
public void hello(){
System.out.println("hello Base");
}
}
class A extends Base{
public void hello(){
System.out.println("hello A");
}
}
class B extends Base{
public void hello(){
System.out.println("hello B");
}
}
class app{
public static void main(String[] args){
Base a = new A();
Base b = new B();
a.hello();
b.hello();
}
}
雖然在代碼少的情況下，也能很好的分辨，但是如果代碼多了，就沒那么容易分辨了。
抽象類在什么情況下比較適用
需要運用多態，並且某些方法在子類中必須重定義時。