抽象类和接口

抽象类

抽象类一般用来做父类，功能的实现由继承的子类来做

public abstract class Pet { //抽象类
    public abstract void toHospital() ;//抽象方法
}

抽象类和普通类的区别

抽象类不能被实例化
但可以创建一个引用变量，其类型是一个抽象类，指向非抽象的子类实例–父类的引用指向子类的对象
普通类可以被实例化
有无方法体

抽象类与抽象方法的使用

抽象类中可以没有抽象方法，但包含了抽象方法的类必须被定义为抽象类
如果子类没有实现父类的所有抽象方法，子类必须被定义为抽象类
没有抽象构造方法（初始化对象，但抽象类不能实例化），也没有抽象静态方法（1、类方法 类名.方法 不需要实例化 2、抽象方法可以被重写，但是静态方法不能被重写）
抽象类中可以有非抽象的构造方法，创建子类的实例时可能调用

接口

接口表示一种能力–体现在接口的方法上

实现防盗门的功能
防盗门是一个门 is-a的关系
防盗门有一个锁 has-a的关系
能力：上锁、开锁
将门定义为抽象类，锁定义为接口
防盗门继承门，实现锁的接口

public abstract class Door {//抽象类 门
    public abstract void open();//开门关门方法
    public abstract void close();
}
public interface Lock {//接口定义
    //使用类名.属性
    public static final int I=0;//接口中的属性默认是公共静态常量
    void lockUp();//上锁开锁的能力
    void lockDown();//接口中所有方法都是默认公共抽象方法
}
public class SafeDoor extends Door implements Lock {//继承门实现锁的接口
    @Override
    public void open() {//重写关门开门上锁开锁方法
        System.out.println("推一下门开了");
    }

    @Override
    public void close() {
        System.out.println("拉一下门关了");
    }

    @Override
    public void lockUp() {
        System.out.println("钥匙扭一扭，锁开了");
    }

    @Override
    public void lockDown() {
        System.out.println("钥匙扭一扭，锁上了");
    }
}

实现类

public class Owner {
    private String name;
    private SafeDoor door=new SafeDoor();
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    public void getIn(){
        System.out.println(name+"来到门前");
        door.lockUp();
        door.open();
        System.out.println(name+"进入房间");
    }
    public void getOut(){
        System.out.println(name+"走出房间");
        door.close();
        door.lockDown();
        System.out.println(name+"收好钥匙，跑路");
    }
}

public class TestOwn {
    public static void main(String[] args) {
        Owner o = new Owner();
        o.setName("包租婆");
        o.getIn();
        o.getOut();
    }
}

接口定义和特性

定义
public interface MyInterface {
}
特性
1、接口不可以被实例化–都是抽象方法 只是一种约定和能力
2、实现类必须实现接口的所有方法
3、实现类可以实现多个接口（implements、多个接口使用逗号隔开 ）
4、接口中的变量都是静态常量（public static final）
5、所有方法默认都是：public abstract

演示USB接口

USB接口本身没有实现任何功能
USB接口规定了数据传输的要求

public interface USB {//相当于父类 近似继承
    //定义属性标准
    public static final int SIZE=10;
    public static final double ELECTRIC=3.0;
    public abstract void work();//方法根据需求规定
}

USB接口可以被多种USB设备实现

public class USBFan implements USB {
    @Override
    public void work() {
        if (10==SIZE) {//实现了接口 相当于"继承"了接口 这个判断其实没有意义
            System.out.println("连接到USB接口上，风扇开始转");
        }
    }
}
public class USBMouse implements USB {
    @Override
    public void work() {
        System.out.println("鼠标连接到USB上，游戏操作0-5");
    }
}
public class USBFlash implements USB {
    @Override
    public void work() {
        System.out.println("u盘连接到电脑上");
    }
}

实现类–模拟实现使用者使用usb设备的场景

public class User {
    public void use(USB usb){//多态
        usb.work();
    }

    public static void main(String[] args) {
        User user = new User();
        USBFlash disk=new USBFlash();
        //USB disk=new USBFlash(); 效果一样
        user.use(disk);
    }
}

接口是一种约定

有些接口只有名称
程序设计时面向接口的约定而不考虑具体实现

开发打印机
墨盒：彩色、黑白
纸张类型：A4、B5
墨盒和纸张都不是打印机厂商提供的
打印机厂商要兼容市场上的墨盒、纸张

墨盒和纸张的规格是一种约定
打印机需要遵守这些约定
用面向接口编程的方式开发
制定墨盒、纸张的约定或标准
其他厂商按照墨盒、纸张的标准生产墨盒、纸张
打印机厂商使用墨盒、纸张的标准开发打印机

public interface InkBox {//墨盒约定 只有名称 声明类型
}
public interface Paper {//纸张的约定
}
public interface BlackInkBox extends InkBox {//接口之间可以多继承 具体实现标准
    public static final String COLOR="black";
}
public interface A4Paper extends Paper {
    String SIZE="A4";
}

public abstract class Printer implements InkBox,Paper {
	//打印机类需要有墨盒纸张的对应接口
    public abstract void print();
}
public class NormalPrinter extends Printer implements BlackInkBox,A4Paper{//子类具体实现何种接口
    @Override
    public void print() {
        System.out.println("使用"+COLOR+"色的墨盒在"+SIZE+"大小的纸张");
    }
}

接口使用

接口中的成员变量
默认都是public static final的，必须显式初始化
接口中的方法
默认都是public abstract的
接口没有构造方法，不能被实例化
一个接口不能实现另一个接口，但可以继承多个其他接口
一个类必须实现接口抽象方法（implements），除非这个类也是抽象类

抽象类与接口

相同点
代表系统的抽象层
都不能被实例化
都能包含抽象方法
用于描述系统提供的服务，不必提供具体实现
不同点
在抽象类中可以为部分方法提供默认实现，而接口中只能包含抽象方法
抽象类便于复用，接口便于代码维护
一个类只能继承一个直接的父类，但可以实现多个接口
使用原则
接口做系统与外界交互的窗口
接口提供服务
接口本身一旦制定，就不允许随意修改
抽象类可完成部分功能实现，还有部分功能可作为系统的扩展点