28.接口基本定义.docx

1、 课程名称：接口的基本定义

2、 知识点
2.1、上次课程主要内容
1、抽象类的设计是在普通类之上的抽象类；
2、抽象类关键的问题就是约定了子类必须要覆写的抽象方法；
3、抽象类的使用原则：
· 抽象类必须有子类，子类利用extends 关键字来继承抽象类，一个 子类只能继承一个父类；
· 抽象类的子类（如果不是抽象类），那么必须要覆写抽象类中的全部抽象方法；
· 抽象类可以利用对象的向上转型机制，通过子类对象进行实例化操作；
2.2、本次预计讲解的 知识点
1、接口的基本定义以及使用形式：
2、与接口有关的设计模式的初步认识；
3、接口与抽象类的区别；
3、具体内容（ ）
接口与抽象类相比，接口的使用几率是最高的，所有的设计几乎都是围绕着接口进行的，但是要想把接口彻底弄明白，需要很长一段时间。
3.1、接口的基本概念
接口是一种特殊的类，但是在接口里面的组成与类不同，比类的组成部分简单，主要是由抽象方法与全局常量所组成。而接口使用interface关键字来定义。
范例：定义一个接口
interface A
{//定义了一个接口
public static final String MSG = "Hello World.";
public abstract void print();
}
当一个接口定义完成之后，需要遵循如下的步骤进行接口的使用：
· 接口一定要定义子类，子类利用implements 关键字来实现接口，一个子类可以同时实现多个接口；
|-秒杀抽象类的单继承局限，一个抽象类只能够被一子类所继承；
· 接口的 子类(如果不是抽象类)，那么必须覆写接口中的 全部抽象方法；
· 接口的对象利用子类对象的向上转型进行实例化操作；
范例：使用接口
interface A
{//定义了一个接口
public static final String MSG = "Hello World.";
public abstract void print();
}

interface B
{
public abstract void fun();
}
class X implements A,B
{//此时的X子类同时实现了A和B两个父接口
public void print(){
System.out.println("你好，嗨皮吗");
}
public void fun(){
System.out.println(MSG);
}
}
public class TestDemo
{
public static void main(String args[]){
X x = new X();//实例化子类对象
A a = x;//子类为父接口实例化
B b = x; //子类为父接口实例化
a.print();
b.fun();
}
}

但是这个时候会有这样一种比较神奇的操作。
范例：神奇XX操作
public class TestDemo
{
public static void main(String args[]){
A a = new X();//X子类为父接口A实例化
B b = (B)a;//我也不理解
b.fun();

}
}
B和A鸟关系都没有，但是可以转换，是因为X是子类。
注意：关于接口的组成描述
接口里面在定义的时候就已经明确的给出了开发要求：抽象方法和全局常量，所以以下两种接口的定义从本质上讲是完全一样的。
完整定义：
简化定义：
interface A
{//定义了一个接口
public static final String MSG = "Hello World.";
public abstract void print();
}
interface A
{//定义了一个接口
String MSG = "Hello World.";
void print();
}
如果在定义接口方法的时候没有使用pulic,那么本质上也不是default权限，而默认就是public。
很多时候为了防止一些开发者概念不清晰，所以以后建议大家在定义接口的时候永远都写上public，但是一般都去写abstract.
interface A
{//定义了一个接口
String MSG = "Hello World.";
Public void print();
}
现在程序之中出现有类、抽象类、接口，这几者之间的联系就需要注意了。
一个普通类如果要实现接口又要继承抽象类，则一定采用先extends继承抽象类，再implements实现接口，格式：
Class 子类 extends 抽象类 implements 接口 1，接口2,…{}
范例：观察子类的多继承
interface A
{//定义了一个接口
String MSG = "Hello World.";
void print();
}
abstract class B
{
public abstract void fun();
}

class X extends B implements A
{
public void print(){};
public void fun(){};
}
另外出了以上的结构之外，一个抽象还可以直接实现接口。
范例：抽象类直接实现接口
interface A
{//定义了一个接口
String MSG = "Hello World.";
void print();
}
abstract class B implements A//这个时候抽象类有两个抽象方法
{
public abstract void fun();
}

class X extends B
{
public void print(){};
public void fun(){};
}
现在一定要知道，抽象类可以实现接口，但是反过来，接口可不能够继承抽象类，但是一 个接口却可以使用extends关键字继承多个父接口。
范例：接口多继承
interface A
{//定义了一个接口
public void printA();
}
interface B
{
public void printB();
}
interface C extends A,B//C是A与B的子接口
{
public void printC();
}
class X implements C
{
public void printA(){};
public void printB(){};
public void printC(){};
}
虽然接口本身只能够有抽象方法和全局常量，但是内部的结构是不受到限制的 ,一个接口的内部可以继续定义内部类、内部抽象类、内部接口。如果一个内部接口上使用了static定义，那么之个内部接口就属于外部接口。
范例：使用static定义内部接口
interface A
{
static interface B
{
public void print();

}
}

class X implements A.B
{
public void print(){}
}
总之对于接口的使用可以发现有如下几点：
· 接口避免了单继承局限，一个子类可以实现多个接口；
· 接口中的权限统一为public,方法都是抽象方法，90%情况下接口中很少定义全局常量；
· 所有的内部类结构都不受到定义语法的限制，static定义的一个内部接口就是外部接口；
实际开发中接口的三个使用原则：
· 制订操作标准；
· 表示一种能力；
· 将服务器的远程方法视图提供给客户端；
3.2、接口的实际应用---标准
现实生活对于接口这个名词应该不陌生，USB接口、PCI接口、VGA接口、HDMI接口、DVI接口。以USB设备为主。描述一下接口的实际作用。

范例：首先要定义出的就是接口
interface USB
{

public void start();
public void stop();
}
不管什么样的USB设备只要一连接到电脑上，那么就需要默认执行固定的操作。
范例：电脑上提供有支持USB的操作插入点
class Computer//电脑
{
public void plugin(USB usb){
usb.start();
usb.stop();

}
}
不管有多少个设备，电脑的 plugin()方法里面只接收的是接口实例，那么操作的步骤就是固定的。
范例：定义USB的子类

class Flash implements USB
{
public void start(){
System.out.println("开始使用U盘进行操作。");
}
public void stop(){
System.out.println("U盘停止工作了。");
}
}
范例：键盘子类
class Keyboard implements USB
{
public void start(){
System.out.println("开始使用键盘输入信息。");
}
public void stop(){
System.out.println("键盘停止工作了。");
}
}
现在的子类是按照严格的操作标准使用着。
范例：程序调用处
public class TestDemo
{
public static void main(String args[]){
Computer c = new Computer();
c.plugin(new Flash());//传递U盘对象
c.plugin(new Keyboard());//传递键盘对象

}
}

此时如果有了接口标准，即便有几千万个子类，也是可以在一个接口上使用的。所以接口是定义我们的标准。如果说得再高级一点：
接口可以连接两个不同的层。

3.3、接口的应用---工厂设计模式（Factory,背）
下面编写一段简单的代码，来一起观察一下为什么会存在有工厂设计模式。
范例：观察程序定义
interface Fruit
{//水果
public void eat();//吃
}
class Apple implements Fruit
{
public void eat(){
System.out.println("吃苹果。");
}
}
public class TestDemo
{
public static void main(String args[]){
Fruit f = new Apple();
f.eat();

}
}
代码有问题吗？这个代码没有语法错误，但是有一个设计上的缺失,如果说现在假设fruit增加了一个子类，并且主类想使用这个主类。
interface Fruit
{//水果
public void eat();//吃
}
class Apple implements Fruit
{
public void eat(){
System.out.println("吃苹果。");
}
}

class Cherry implements Fruit
{
public void eat(){
System.out.println("吃樱桃。");
}
}

public class TestDemo
{
public static void main(String args[]){
Fruit f = new Cherry();
f.eat();

}
}
此时发现，如果要扩充程序却影响了客户端的执行，这样的设计就非常的不好了，那么如果要想解决这个问题，可以参加java可以移植性的原理：
· 不可移植性：程序 操作系统；
· 可移植性：程序 JVM 操作系统；
范例：可以在客户端与接口之间引入一个中间层
面试题：请编写一个Factory程序
interface Fruit
{//水果
public void eat();//吃
}
class Apple implements Fruit
{
public void eat(){
System.out.println("吃苹果。");
}
}

class Cherry implements Fruit
{
public void eat(){
System.out.println("吃樱桃。");
}
}

class Factory
{
public static Fruit getInstance(String className){//直接取得中间实例
if("apple".equals(className)){
return new Apple();
}else if("cherry".equals(className)){
return new Cherry();
}else{
return null;
}
}
}
public class TestDemo
{
public static void main(String args[]){//为了方便模拟调用
Fruit f = Factory.getInstance(args[0]);
if(f!=null){
f.eat();
}

}
}
执行苹果操作：java TestDemo apple
执行婴桃操作：java TestDemo cherry
如果现在要想增加新的子类，那么不需要修改客户端，直接修改工厂类即可。
3.4、接口的应用---代理设计模式（Proxy,背）
所谓的代理结构指的是在接口上的 一种应用，一个接口有一个核心的操作主题，但是整个操作的过程之中，如果指依靠核心的操作主题是无法完成所需要功能的，那么需要有一个代理的主题。代理主题完成所有的与核心主题有关的概念。

范例：还原代码
interface Subject
{//核心操作主题
public void get();//核心操作
}

class RealSubject implements Subject
{
public void get(){
System.out.println("陶大爷取回了被强行霸占的1.5亿。");
}
}

class ProxySubject implements Subject
{
private Subject subject;//代理的真实主题
public ProxySubject(Subject subject){
this.subject = subject;
}
public void prepare(){
System.out.println("【追讨前的准备】皮鞭、蜡烛、钉子、辣椒水...");
}
public void get(){
this.prepare();
this.subject.get();//真实主题的讨债
this.destroy();
}
public void destroy(){
System.out.println("【追讨后的收尾】分尸、藏匿...");
}
}

public class TestDemo
{
public static void main(String args[]){//为了方便模拟调用
Subject sub = new ProxySubject(new RealSubject());
sub.get();

}
}
3.5、抽象类与接口的区别（面试题）
到现在为止已经学习过了这么几个概念：抽象类、类、对象、接口，这些概念从开发上来讲什么关系呢？

所有类的抽象使用的就是接口，而且接口避免了单继承的局限。
面试 题：抽象类与接口的一个区别？
No.
区别
抽象类
接口
1
定义关键字
Abstract class
interface
2
组成
属性、常量、抽象方法、构造方法、普通方法
抽象方法与全局常量
3
权限
可以使用各种权限
只能够是public
4
子类实现
利用extends关键字可以继承一个抽象类
利用implements关键字可以实现多人接口
5
关系
抽象类可以实现多个接口
接口不能够继承抽象类，接口却可以利用extends关键字实现接口的多继承
6
对象实例化
依靠子类对象的向上转型实现抽象类或接口对象的实例化操作。
7
设计模式
模版设计模式
工厂设计模式、代理设计模式
8
操作局限
单继承局限
没有单继承局限
通过以上几点比较可以发现，抽象类与接口实际上都可以限制子类必须要棋覆写的一个访法要求，但是抽象类本身具有单继承局限，所以日后开发过程之中，如果发现抽象类与接口都可以同时使用的时候，优先考虑接口，而且抽象类在实际的应用中往往是作为接口与普通类之间的过渡类使用。
4、总结
1、接口利用interface关键字定义，接口中定义方法的情况居多。
2、接口利用对象向上转型实现接口对象的实例化操作，调用的方法是每个子类所覆写的方法；
3、接口应用:标准（连接不同的两种类）、工厂设计模式、代理设计模式。