抽象類：
1. 抽象的概念：籠統、模糊、不具體
2. 特點：方法只有聲明沒有實現時，該方法就是抽象方法，需要被abstract關鍵字修飾，抽象方法
必須定義在抽象類中，該類也必須被abstract修飾
3. 抽象類不可以被實例化。因爲調用抽象方法沒意義，無方法體
4. 抽象類必須有其子類覆蓋了所有的抽象方法後，該子類才能被實例化，否則、子類還是抽象類。
抽象類有構造函數嗎？
有、用於給子類對象進行初始化
抽象類可以不定義抽象方法嗎？
可以、但是很少見，目的就是不讓該類創建對象，AWT的適配器對象就是這樣的；通常這個抽象類中的方法有方法體，但是卻沒有內容。
抽象關鍵字不可以和哪些關鍵字共存？
1. Private 因爲抽象類中的方法必須被覆蓋，如果私有化，就不能被覆蓋，因此不能和private共存
2. Static 一旦靜態化，意味着直接使用類名就可以調用，不需要對象，但是抽象方法沒有具體
實現，沒有意義。
3. Final 一旦final化，意味着不能被覆蓋或繼承，與抽象類必須被覆蓋衝突
抽象類和一般類的異同點？
相同點：抽象類和一般類都是用來描述事物的，都在內部定義了成員
不同點：
1. 一般類有足夠的信息描述事務；抽象類描述事務的信息有可能不足
2. 一般類中不能定義抽象方法，只能定義非抽象方法；抽象類中可定義抽象方法，同時也可
以定義非抽象方法
3. 一般類可以被實例化；抽象類不能被實例化
抽象類一定是個父類嗎？
是的，因爲需要子類覆蓋其方法後纔可以對子類實例化
僱員示例 ：
/*
僱員示例：
要求：公司中程序員有姓名，工號，薪水，工作內容
項目經理除了有姓名，工號，薪水，還有獎金，工作內容
對給出的需求進行數據建模
分析：
在這個問題領域中，先找出涉及的對象
通過名詞提煉法
程序員：
屬性：姓名、工號、薪水
行爲：工作
經理：
屬性：姓名，工號，薪水，獎金
行爲：工作
程序員和經理不存在直接的繼承關係
但是程序員和經理卻具有共性內容
可以進行抽取，因爲他們都是公司的僱員
可以將程序員和經理進行抽取，建立體系
*/
//描述僱員
abstract class Employee
{
private String name;
private String id;
private double pay;
Employee(String name, String id, double pay)
{
this.name = name;
this.id = id;
this.pay = pay;
}
public abstract void work();
}
class Programer extends Employee
{
Programer(String name, String id, double pay)
{
super(name,id,pay);
}
public void work()
{
System.out.println("code ...");
}
}
class Manager extends Employee
{
private int bonus;
Manager(String name, String id, double pay,int bonus)
{
super(name,id,pay);
this.bonus = bonus;
}
public void work()
{
System.out.println("manager ...");
}
}
class AbstractTest
{
public static void main(String[] args)
{
Programer p1 = new Programer("keyman","1",1000);
p1.work();
Manager m1 = new Manager("keyman","2",10000,2000);
m1.work();
//System.out.println("Hello World!");
}
}
接口：
1. 格式：interface {}
2. 接口中的成員修飾符是固定的
成員常量：public static final
成員函數：public abstract
接口中的成員都是public的
3. 接口的出現將“多繼承”通過另一種形式體現出來，即“多實現”。
當一個抽象類中的方法都是抽象的時候，這時可以將該抽象類用另一種形式定義和表示，就是 接口 interface。
定義接口使用的關鍵字不是class，是interface：
interface Demo
{
public static final int NUMBER = 10;
public abstract void show1();
public abstract void show2();
}
類與類之間是繼承關係；類與接口之間是實現關係
接口不可以實例化。只能由實現了接口的子類並覆蓋了接口中所有的抽象方法後，該子類纔可以實例化，否則，這個子類就是一個抽象類
interface Demo
{
public static final int NUMBER = 10;
public abstract void show1();
public abstract void show2();
}
class InterfaceDemo
{
public static void main(String[] args)
{
//System.out.println("Hello World!");
DemoImpl d = new DemoImpl();
System.out.println(d.NUMBER);
System.out.println(Demo.NUMBER);
System.out.println(DemoImpl.NUMBER);
}
}
class DemoImpl implements Demo
{
public void show1(){
System.out.println("show1 run");
}
public void show2(){
System.out.println("show2 run");
}
}
在java中不直接支持多繼承，因爲會出現調用的不確定性，所以java將多繼承機制進行改良，在java中變成 接口多實現
一個類可以實現多個接口。
interface DemoA
{
public static final int NUMBER = 20;
public abstract void show1();
public abstract void show();
}
interface DemoB
{
public static final int NUMBER = 10;
public abstract void show2();
public abstract void show();
}
class InterfaceDemo
{
public static void main(String[] args)
{
/*此處代碼運行失敗，因爲對於d.NUMBER以及DemoImpl.NUMBER兩種方式的調用將出現調用的不確定性*/
DemoImpl d = new DemoImpl();
System.out.println(d.NUMBER);
System.out.println(DemoA.NUMBER);
System.out.println(DemoImpl.NUMBER);
}
}
class DemoImpl implements DemoA,DemoB
{
public void show1(){
System.out.println("show1 run");
}
public void show2(){
System.out.println("show2 run");
}
public void show(){
System.out.println("show run");
}
}
一個類在繼承另一個類的同時，還可以實現多個接口。
接口的出現避免了單繼承的侷限性
接口與接口之間是繼承關係，而且接口可以多繼承
interface A
{
public abstract void show();
}
interface B
{
public abstract int add(int x,int y);
}
interface C extends A,B
{
public abstract int mul(int x, int y);
}
class D
{
public int static NUMBER=0;
}
class Demo extends D implements C
{
public void show(){}
public int add(int x, int y){}
public int mul(int x, int y){}
}
class DemoRun
{
public static void main(String[] args)
{
new Demo().show();
}
}
接口特點：
1. 是對外暴漏的規則
2. 是程序的功能擴展
3. 接口的出現降低耦合性
4. 接口可以用來多實現
5. 類與接口之間是實現關係，而且類可以繼承一個類的同時實現多個接口
6. 接口與接口之間是繼承關係
接口與抽象類的異同:
相同點：都是不斷的向上抽取而來，並且都是描述不具體。
不同點：
1. 抽象類需要被繼承，而且只能單繼承；接口需要被實現，而且可以多實現
2. 抽象類中可以定義抽象方法和非抽象方法，子類繼承後可以直接使用非抽象方法；接口中只能定義抽象方法，必須由子類實現
3. 抽象類的繼承是 is a 關係，在定義該體系的基本共性內容；接口的實現是 like a 關係，是在定義體系額外功能
例如：犬按功能分有導盲犬、搜爆犬。
Abstract Class 犬
{
Abstract Void 吼叫();
}
Class 導盲犬
{
Public void 吼叫(){}
Public void 導盲(){}
}
Class 搜爆犬
{
Public void 吼叫(){}
Public void 搜爆(){}
}
等同於
Abstract class 犬
{
Abstract void 吼叫();
}
Interface 導盲
{
Abstract void 導盲();
}
Class 導盲犬 extends 犬 implements 導盲
{
Public void 吼叫(){}
Public void 導盲(){}
}
下例展示了接口類型的引用
interface USB
{
abstract public void open();
abstract public void close();
}
class BookPC
{
public static void main(String[] args)
{
useUSB(new UPan);
//System.out.println("Hello World!");
}
public static void useUSB(USB u) //接口類型的引用，用於接收（指向）接口的子類對象
{
u.open();
u.close();
}
}
class UPan implements USB
{
public void open()
{
System.out.println("upan open");
}
public void close()
{
System.out.println("upan close");
}
}