抽象类和接口

一、抽象类

抽象：笼统，模糊，看不懂！不具体

抽象类的由来:举个栗子说明

抽象类的由来

抽象类：当一个类在描述事物时，没有足够的信息去描述这个事物，就叫抽象类

抽象类的特点

1、方法只有声明没有实现时，该方法就是抽象方法，需要被abstract修饰
抽象方法必须定义在抽象类中。该类也必须被abstract修饰。
2、抽象类不可以被实例化。因为调用抽象方法没意义。
3、抽象类必须有其子类覆盖所有的抽象方法后，该子类才可以实例化，否则这个子类还是抽象类。

通过5个问题来细说抽象类

1、抽象类中有构造函数吗？

有，用于给子类对象初始化

2、抽象类可以不定义抽象方法吗？

可以，很少见
目的就是不让该类创建对象。有方法体，却没有内容。
eg：AWT的适配器

3、抽象关键字不可以和哪些关键字共存？

private 不行 抽象方法要被覆盖，私有了子代都不知道去哪覆盖？！
static 不行 抽象方法不需要对象，因为方法体内没有内容
final 不行 我要覆盖abstract，final不让覆盖，那不打架了么，共存个屁！

不能共存关键字编译

4、抽象类和一般类的异同点。

相同点：都是描述事物，都在内部定义了成员
不同点：一般类有足够的信息描述信息；但抽象类描述事物的信息不足。
       一般类中不能定义抽象方法；而抽象类中可以定义抽象方法也可以定义非抽象方法
       一般类可以被实例化；抽象类不能被实例化

5、抽象类一定是一个父类吗？

是！
因为需要子类覆盖其方法后才可以对子类实例化

用抽象类来举个栗子：

雇员：
需求：公司中程序员有姓名，工号，薪水，工作内容。
项目经理除了姓名，工号，薪水，工作内容，还有奖金。
对给出需求进行数据建模

//分析：先找出涉及的对象：程序员，项目经理
//程序员
//     属性：姓名，工号，薪水。
     //行为：工作
//项目经理
     //属性：姓名，工号，薪水，奖金。
     //行为：工作
//程序员和项目经理不存在这直接继承关系
//但他们都是公司的雇员，可以将程序员和项目经理进行抽取，建立关系


//描述雇员
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 Programmer extends Employee
{
    Programmer(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("manage");
    }
}

二：接口（interface）

接口的由来：当抽象类中的方法都是抽象的时候，这时可以将该抽象类用另一种形式定义和表示，就是接口
就好像四条边相等的长方形叫正方形一样

定义接口:关键字是interface不是class

interface Demo
{
}

接口中常见成员

全局常量

public static final

抽象方法

public abstract

由此看出接口中的成员都是公共的

由于接口里的都是抽象的，所以不用继承叫实现！

类与类之间叫继承，类与接口之间叫实现！

接口不可以实例化
只能由实现了接口的子类并覆盖了接口中所有的抽象方法后，该子类才可以实例化。否则这个子类就是一个抽象类。

来个栗子说明

interface Demo
{
       public static final int NUM = 4;
       public abstract void show1();
       public abstract void show2();
}
class DemoImp1 implements Demo//翻译过来是：这个Demolmp1类实现了Demo这个接口
{
public void show1()
{}
public void show2()
{
}
}
class InerfaceDemo
{
       public static void main(String[] args)
     {
          DemoImp1 d = new DemoImp1();  //不可以有 d.NUM = 3; 因为NUM的值是final
          System.out.println(d.NUM);     //对象
          System.out.println(DemoImp1.NUM);    //子类调用NUM成员
          System.out.println(Demo.NUM);    //接口Demo调用NUM成员
     }
}

运行结果

面向对象中说过Java中不直接支持多继承，因为会出现调用的不确定性。
所以Java将多继承机制改良，变成了多实现

一个类可以实现多个接口

多实现的体现

interface A
{
       public abstract void show();
}
interface B
{
       public abstract void show();
}
class Test implements A,B//多实现
{
    public void show()  //及覆盖了A的中的show又覆盖了B中的show
    {
        
    }
}
class InerfaceDemo
{
       public static void main(String[] args)
     {
         Test t = new Test();
         t.show();
     }
}

一个类在继承另一个类的同时，还可以实现多个接口。接口的出现避免了单继承的局限性

interface A
{
       public abstract void show();
}
interface B
{
       public abstract void show();
}
class Q
{
    public void method()
    {}
}
class Test2 extends Q implements A,B   //test2继承了Q 但还需要其他功能,
                                          //所以通过接口实现其他功能
                                        //先继承再实现
{
    
}

接口和接口之间是继承关系

总结一下：接口的特点

1、接口是对外暴露的规则  例如USB口
2、接口是程序的功能扩展  
3、接口的出现降低耦合性
4、接口可以用来多实现
5、接口和接口之间是继承关系
6、类和接口是实现关系，而且类可以继承一个类的同时实现多个接口

三、抽象类和接口的异同点

相同点：都是不断向上抽取而来的

不同点：
1、抽象类需要被继承，而且只能单继承
接口需要被实现，而且可以多实现
2、抽象类中可以定义抽象方法和非抽象方法，子类继承后，可直接使用非抽象方法
接口中只能定义抽象方法，必须由子类去实现
3、抽象类的继承，是is a关系。在定义该体系的基本共性内容。
接口的实现是 like a关系。在定义体系额外功能。