面向对象（6）接口

接口：
什么是接口
接口的特性
借口不可以被实例化
实现类必须实现接口的·所有方法
实现类可以实现多接口
接口中变量都是静态常量

接口的实现：
根据需求设计方法
实现所有方法
用多态的方式使用

例如
实现USB接口工作原理
第一步设计接口

public interface UsbInterface {
    void service();
}

设计一个服务的抽象方法

第二步设计一个USB的类并继承于接口用关键字implements

public class UDisk implements UsbInterface {
    public void service() {
        System.out.println("连接USB口，开始传输数据。");
    }
}

第三步编写测试类

UsbInterface uDisk = new UDisk();
uDisk.service();

接口是一种能力，体现在接口的方法上

面向接口编程

关心实现类有何能力
而不关心实现细节

面向接口的约定而不考虑接口的具体实现

例如：实现防盗门功能
分析
防盗门是一个门 is a
防盗门有一个锁 has a
能力为：上锁开锁

设计抽象类门类并设计抽象方法开和关

public abstract class Door {
    public abstract void open();
    public  abstract void close();

}

设计锁的接口并设计上锁开锁方法

public interface Lock {
    void openlock();
    void onlock();
}

设计防盗门类
继承父类门和接口锁

public class Fdoor extends Door implements Lock {
    @Override
    public void open() {
        System.out.println("门开了");
    }

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

    @Override
    public void openlock() {
        System.out.println("锁开了");
    }

    @Override
    public void onlock() {
        System.out.println("上了锁");
    }
}

编写测试类来实现防盗门的工作原理

public class Test {
    public static void main(String[] args) {
        Fdoor fdoor=new Fdoor();
        fdoor.openlock();
        fdoor.open();
        fdoor.onlock();
        fdoor.close();
    }
}

扩展防盗门功能给它加个门铃
需要在设计一个门铃接口
设计抽象方法门铃响
并用防盗门继承

public interface Doorbell {
    void cry();
}

面向接口的进阶

开发打印机

要求：
墨盒：彩色 黑白
纸张：A4 B5
墨盒和纸张都不是打印机厂商提供的
打印机厂商要兼容市场上的墨盒，纸张
分析：
定义墨盒接口InkBox
定义纸张接口Paper
实现墨盒与纸张接口

纸张接口：

public interface Paper {
    public String getSize();
}

A4类：

public class A4Paper implements Paper {
    @Override
    public String getSize() {
        return "A4";
    }
}

继承纸张接口返回值为A4

B5类

public class B5Paper implements Paper {
    @Override
    public String getSize() {
        return "B5";
    }
}

和A4类一样继承纸张接口返回值为B5

墨盒接口：

public interface InkBox {
    String color();
}

彩色类继承墨盒接口

public class Color implements InkBox {
    @Override
    public String color() {
        return "彩色";
    }
}

黑白类继承墨盒接口

public class White implements InkBox {
    @Override
    public String color() {
        return "黑白";
    }
}

设计打印机类
方法有打印
因为墨盒和纸张都是在打印机中的，所以用实体类创建变量用get 和set实现赋值

public class Print {
    private InkBox inkBox;
    private Paper paper;
    public void print(){
        System.out.println(inkBox.color()+"在"+paper.getsize()+"上打印");
    }

    public InkBox getInkBox() {
        return inkBox;
    }

    public void setInkBox(InkBox inkBox) {
        this.inkBox = inkBox;
    }

    public Paper getPaper() {
        return paper;
    }

    public void setPaper(Paper paper) {
        this.paper = paper;
    }
}

测试类实现打印机的打印

public class TestPrint {
    public static void main(String[] args) {


        Print print = new Print();
        InkBox color = new Color();
        Paper A4 = new A4();
        print.setInkBox(color);
        print.setPaper(A4);
        print.print();

    }

}

这里我选的是彩色和A4

抽象类与接口的相同点

相同点
代表系统的抽象层
都不能被实例化
都能包含抽象方法
用于描述系统·提供的服务，不必提供具体实现

不同点：
在抽象类中可以为部分方法提供默认实现，而接口中只能包含抽象方法

一个类只能继承一个直接父类，但可以实现多接口

使用原则：接口做系统与外界交互的窗口
接口提供服务

接口本身一旦制定，就不允许随意更改
抽象类可完成部分功能实现，还有部分功能可作为系统的扩展点

操作题利用面向接口来实现在组装计算机
计算机由CPU
硬盘和内存组成
分析
定义三个接口CPU内存和硬盘分别返回他们的品牌CPU要返回主频内存和硬盘返回容量

CPU接口

public interface CPU {
    String CPUbrand();
    String zhupin();

}

里面有返回品牌和主频的方法

public class Intel implements CPU {
    @Override
    public String CPUbrand() {
        return "CPU品牌是：Intel";
    }

    @Override
    public String zhupin() {
        return " 主频是：3.8GHz";
    }
}

实体化一个类为intel

public class Imd implements CPU {
    @Override
    public String CPUbrand() {
        return "CPU品牌是：AMD";
    }

    @Override
    public String zhupin() {
        return "主频是：3.2GHz";
    }
}

实体化一个类为AMD

硬盘接口和CPU一样实体化两个类

public interface Yingpan {
    String brand();
    String size();
}

西部数据

public class Xbsj implements Yingpan {
    @Override
    public String brand() {
        return "硬盘的品牌是西部数据";
    }

    @Override
    public String size() {
        return "硬盘容量为4000GB";
    }
}

金士顿

public class Jsd implements Yingpan {
    @Override
    public String brand() {
        return "硬盘的品牌是金士顿";
    }

    @Override
    public String size() {
        return "硬盘容量为5000GB";
    }
}

内存如上一样

public interface NeiCun {
    String brand();
    String size();
}

华硕

public class HuaShuo implements NeiCun {
    @Override
    public String brand() {
        return "内存品牌为华硕";
    }

    @Override
    public String size() {
        return "内存容量为16GB";
    }
}

三星

public class SanXing implements NeiCun {
    @Override
    public String brand() {
        return "内存品牌为三星";
    }

    @Override
    public String size() {
        return "内存容量为4GB";
    }
}

编写电脑类

因为电脑包括CPU内存和硬盘所以建立三个变量

public class Computer {
    private CPU cpu;
    private Yingpan yingpan;
    private NeiCun neiCun;

    public Yingpan getYingpan() {
        return yingpan;
    }

    public void setYingpan(Yingpan yingpan) {
        this.yingpan = yingpan;
    }

    public NeiCun getNeiCun() {
        return neiCun;
    }

    public void setNeiCun(NeiCun neiCun) {
        this.neiCun = neiCun;
    }


    public CPU getCpu() {
        return cpu;
    }

    public void setCpu(CPU cpu) {
        this.cpu = cpu;
    }
    public void show(){
        System.out.println("计算机信息如下");
        System.out.println(cpu.CPUbrand()+"\t"+cpu.zhupin());
        System.out.println(yingpan.brand()+"\t"+yingpan.size());
        System.out.println(neiCun.brand()+"\t"+neiCun.size());

    }

}

编写测试类来实现电脑组装

public class TestComputer {
    public static void main(String[] args) {
        Computer computer=new Computer();
        CPU cpu=new Intel();
        Yingpan yingpan=new Xbsj();
        NeiCun neiCun=new SanXing();
        computer.setCpu(cpu);
        computer.setYingpan(yingpan);
        computer.setNeiCun(neiCun);
        computer.show();
    }
}

这里选择的是CPU为intel
硬盘为西部数据
内存为三星