Java基础-面向接口（interface）编程

　　　　　　　　　　　　　　　　Java基础-面向接口（interface）编程

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　作者：尹正杰

版权声明：原创作品，谢绝转载！否则将追究法律责任。

一.接口的概念

　　接口是功能的集合，同样可看做是一种数据类型，是比抽象类更为抽象的“类”。

　　接口是抽象的一种机制，现实事物的共性抽取成类，将不同类中的同名方法抽象成抽象方法，形成抽象类，对类的成员变量和方法继续抽象的话，就形成接口，接口是类的最高级的抽象机制。接口中只有常量和抽象方法，接口是一种规范，实现一个接口，就需要实现其中的所有抽象方法。

　　接口只描述所应该具备的方法，并没有具体实现，具体的实现由接口的实现类（相当于接口的子类）来完成。这样将功能的定义与实现分离，优化了程序设计。请记住：一切事物均为功能，即一切事物均为接口。

二.接口的定义

　　与定义class不同，接口定义时需要使用interface关键字。

　　定义接口所在的仍为".java"文件，虽然声明时使用的为interface关键字编译后仍然会产生“.class”文件。这点可以让我们将接口看做是一种只包含了功能声明的特殊类。定义格式如下：

public interface 接口名{
        抽象方法1；
        抽象方法2；
        抽象方法3；
}

　　使用interface代替了原来的class，其它步骤与定义类相同（接口中的方法均为公共访问的抽象方法，接口中无法定义普通的成员变量（成员变量均为常量，需要用关键字fanal修饰）），下面是定义一个接口的案例：

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
EMAIL:y1053419035@qq.com
*/

public interface MyInterface {
    public abstract void function();
}

三.类实现接口

1>.类实现接口的格式

　　类与接口的关系为实现关系，即类实现接口。实现的动作类似继承，只是关键字不同，实现使用关键字implements。其它类（实现类）实现接口后，就相当于声明：“我应该具备这个接口中的功能”。实现类仍然需要重写方法以实现具体的功能。格式如下：

class 类 implements 接口名{ 
     实现接口中的抽象方法； 
}     

2>.接口是功能的集合　　

　　在类实现接口后，该类就会将接口中的抽象方法继承过来，此时该类需要重写该抽象方法，完成具体的逻辑。

　　　　a>.接口中定义功能，当需要具有该功能时，可以让类实现该接口，只声明了应该具备该方法，是功能的声明。

　　　　b>.在具体实现类中重写方法，实现功能，是方法的具体实现。

　　于是，通过以上两个动作将功能的声明与实现便分开了，此时请重写思考：类是实现事物的描述，而接口是功能的集合的含义。下面是我定义一个接口并用类去实现的简易代码：

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
EMAIL:y1053419035@qq.com
*/

interface MyInterface {
    public abstract void function();
}

class MyInterfaceImpl implements MyInterface{
    public void function(){
        System.out.println("实现接口的子类，重写接口抽象方法！");
    }
}

public class MyInterfaceDemo{
    public static void main(String[] args){
        MyInterfaceImpl m = new MyInterfaceImpl();
        m.function();
    }
}

/*
实现接口的子类，重写接口抽象方法！
*/

四.接口中的成员变量的特点

1>.接口中成员变量的特点

　　a>.成员变量的特点，即没有变量，都是常量（固定格式：public static final 数据类型 变量名 = 值）；

　　b>.注意，public static final 修饰符，在接口的定义中可以省略不写，但是，不写并不等于没有！

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
EMAIL:y1053419035@qq.com
*/

interface MyInterface {
    
    public static final int x = 3;
    
    //注意，public static final 修饰符，在接口的定义中可以省略不写，但是，不写并不等于没有！
    y = 6;    
}

2>.接口中成员方法的特点

　　接口中修饰方法的固定格式为：“public abstract 返回值类型 方法名（参数列表）”。

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
EMAIL:y1053419035@qq.com
*/

interface MyInterface {
    
    public static final int x = 3;
    
    public abstract void show1();
    
    //public abstract 修饰符是选择性书写，不管你写不写，这个修饰符默认都是存在的！
    void show2();
}

class MyInterfaceImpl implements MyInterface{
    public void show1(){
        System.out.println("show1()...");
    }
    public void show2(){
        System.out.println("show2()...");
    }
}

public class MyInterfaceDemo{
    public static void main(String[] args){
        MyInterfaceImpl m = new MyInterfaceImpl();
        m.show1();
        m.show2();
    }
}

/*
以上代码执行结果如下：
show1()...
show2()...
*/

3>.实现(implements)类还是一个抽象类

　　接口是不可以创建对象的，子类必须覆盖掉接口所有的抽象方法后，子类才可以实例化。否则子类还是一个抽象类。

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
EMAIL:y1053419035@qq.com
*/

interface MyInterface {
    
    public abstract int getMax(int[] arr);
    
    public abstract int getMin(int[] arr);
    
}

class MyInterfaceImpl implements MyInterface{
    public int getMax(int[] arr){
        int max = arr[0];
        for(int i=0;i<arr.length;i++){
            if(arr[i] > max){
                max = arr[i];
            }
        }
        return max;
    }
    public int getMin(int[] arr){
        int min = arr[0];
        for(int i=0;i<arr.length;i++){
            if(arr[i] < min){
                min = arr[i];
            }
        }
        return min;
    }
}

public class MyInterfaceDemo{
    public static void main(String[] args){
        MyInterfaceImpl m = new MyInterfaceImpl();
        int[] arr = {1,2,3,4,5,6,7,8};
        System.out.printf("数组中最大值是：%d,最小值是:%d
",m.getMax(arr),m.getMin(arr));
        
    }
}

/*
以上代码执行结果如下：
数组中最大值是：8,最小值是:1
*/

五.接口的多实现(implements)

　　接口最重要的体验：解决多继承的弊端，将多继承这种机制在Java中通过多实现完成了。

1>.怎么解决多继承的弊端呢？

 　　弊端：多继承时，当多个父类有相同功能时，子类调用会产生不确定性，其实核心原因就是在于多继承父类中功能有主题，而导致调用运行时，不确定运行哪个主体内容。

2>.为什么多实现能解决呢？

 　　因为接口中的功能都没有方法体，由子类来明确。我们可以看下面这个案例：

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
EMAIL:y1053419035@qq.com
*/

interface A {
    public abstract void a();
    void d();
}

interface B {
    public abstract void b();    
    void d();
}

class C implements A,B{
    public void a(){
        System.out.println("C.a()");
    }
    public void b(){
        System.out.println("C.b()");
    }
    public void d(){
        System.out.println("C.d()");
    }
}


public class MyInterfaceDemo{
    public static void main(String[] args){
        C c = new C();
        c.a();
        c.b();
        c.d();
        
    }
}

/*
以上代码执行结果如下：
C.a()
C.b()
C.d()
*/

六.类在继承类的同时实现(implements)多接口

　　接口和类之间可以通过实现产生关系，同时也学习了类与类之间可以通过继承产生关系。当一个类已经继承了一个父类，它又不需要扩展额外的功能，这时接口就派上了用场了。子类通过继承父类扩展功能，通过继承扩展的功能都是子类应该具备的基础功能。如果子类想要继续扩展其它类中的功能呢？这时通过实现接口来完成。

　　一个类在继承一个类的同时，还可以实现多个接口，代码如下：

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
EMAIL:y1053419035@qq.com
*/

interface A {
    public abstract void a();
}

interface B {
    public abstract void b();    
}

abstract class C{
    public abstract void d();
}

class D extends C implements A,B{
    public void a(){
        System.out.println("D.a()");
    }
    public void b(){
        System.out.println("D.b()");
    }
    public void d(){
        System.out.println("D.d()");
    }
}


public class MyInterfaceDemo{
    public static void main(String[] args){
        D d = new D();
        d.a();
        d.b();
        d.d();
    }
}

/*
以上代码执行结果如下：
D.a()
D.b()
D.d()
*/

七.接口的多继承

　　多个接口之间可以使用extends进行继承，在开发中如果多个接口中存在相同方法，这时若有个类实现了这些接口，那么就要实现接口中的方法，由于接口中的方法是抽象方法，子类实现后也不会发生调用的不确定性。以下是一个接口继承多个接口的案例：

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
EMAIL:y1053419035@qq.com
*/

interface A {
    public abstract void a();
}

interface B {
    public abstract void b();    
}

interface C{
    public abstract void c();
}

interface D extends A,B,C{
    public abstract void d();
}

八.接口在开发中的好处

1>.接口的出现扩展了功能；

2>.接口其实就是暴漏出来的规则；

3>.接口的出现降低了耦合性，即设备与设备之间实现了解耦；

　　接口的出现方便后期使用和维护，一方是在使用接口（如电脑），一方在实现接口（如U盘）。

九.接口和抽象的区别

1>.相同点

　　a>.都位于继承的顶端，用于被其它类实现或继承；

　　b>.都不能直接实例化对象；

　　c>.都包含抽象方法，其子类都必须覆写这些抽象方；

2>.区别

　　a>.抽象类为部分方法提供实现，避免子类重复实现这些方法，提高代码复用性；接口只能包含抽象方法；

　　b>.一个类只能继承一个直接父类（可能是抽象类），却可以实现多个接口；接口弥补了Java的单继承；

　　c>.抽象类是这个事物中应该具备的内容，继承体系是一种“is....a”关系（比如，猫啊，虎啊，蛇啊，猪啊都是动物）；

　　d>.接口是这个事物中的额外内容，继承体系是一种“like...a”关系（就好比猫和蛇是宠物）；

3>.二者的选用

　　a>.优先选用接口，尽量少用抽象类；

　　b>.需要定义子类的行为，又要为子类提供共性功能时才选用抽象类；