抽象类：
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");
}
}