浅谈java接口

示例一

要点

    接口:
    1、接口也是一种"引用数据类型"。编译之后是一个class字节码文件。
    2、接口是完全抽象的。（抽象类是半抽象）或者也可以说接口是特殊的抽象类。
    3、接口定义: [修饰符列表] interface 接口名{}
    4、接口支持多继承,一个接口可以继承多个接口,
    5、接口中只包含两部分内容：常量+抽象方法。
    6、接口中所有的元素都是public修饰的。（都是公开的。）
    7、接口中的抽象方法定义时:public abstract修饰符可以省略。
    8、接口中的方法都是抽象方法，所以接口中的方法不能有方法体。
    9、接口中的常量的public static final可以省略。

实例

public class Test01{
    public static void main (String[] args)(
    //访问接口的常量。
    System.out.println (MyMath.PI);
    //常量能重新赋值吗?
    //错误:无法为最终变量PI分配值
    //MyMath.PI = 3.1415928;
    //错误:无法为最终变量k分配值
    //MyMath.k = 111;
   }
}
//定义接口
interface A{}
//接口支持继承
interface B extends A{}
//一个接口可以继承多个接口(支持多继承)
interface C extends A, B{}

//我的数学接口
interface MyMath{
    //常量
    //public static final double PI= 3.1415926;

    //public static final可以省略吗?
    double PI=3.1415926;
    //k是常量
    //接口中随便写一个变量就是常量
    //常量:值不能发生改变的值
    int k=100;

    //抽象方法
    //public abstract int sub(int a, int b);
    //接口当中既然都是抽象方法，那么在编写代码的时候，public abstract可以省略吗?可
    int sub(int a, int b);

    //接口中的方法可以有方法体吗?
    //错误:接口抽象方法不能带有主体
    /*
    void dosome(){}
    */
}
 

示例二

要点

接口的基础语法:
1、类和类之间叫做继承,类和接口之间叫做实现。别多想:你仍然可以将"实现"看做"继承"
    继承使用extends关键字完成
    实现使用implements关键字完成
2、当一个非抽象的类实现接口的话，必须将接口中所有的抽象方法全都实现(覆盖、重写)
3、接口中不能有方法体
4、extends和implement可以共存，extends在前，implements在后。

实例

public class Test02{
    public static void main(String[] args){
    //错误:MyMath是抽象的 无法实例化
    //new MyMath();
    //能使用多态吗?可以。
    //Animal a = new Cat();

    //父类型的引用指向子类型的对象
    MyMath mm = new MyMathImp1();
    //调用接口里面的方法(面向接口编程)
    int result1=mm.sum(10,20);
    System.out.println(result1);

    int resu1t2 = mm.sub (20,10);
    System.out.println (result2);
}
}
//特殊的抽象类,完全抽象的,叫做接口
interface MyMath{
    double PI=3.1415926;
    int sum (int a, int b);
    int sub (int a, int b);
}
//这样没问题
/*
abstract class MyMathImpl implements MyMath{}
*/

//编写一个类(这个类是一个"非抽象"的类)
//这个类的名字是随意的。
//错误:MyMathImpl不是抽象的，并且未覆盖MyMath中的抽象方法sub(int,int)
/*
class MyMathImpl implements MyMath{}
*/

//修正
class MyMathImpl implements MyMath {
    //错误:正在尝试分配更低的访问权限 以前为public
    /*
    int sum(int a, int b){
        return a+b;
    }
    */
    //重写/覆盖/实现接口中的方法(通常叫做实现）
    public int sum(int a, int b){
        return a+b;
    }
    public int sub (int a,int b){
        return a = b;
    }
}

示例三

要点

接口和接口之间支持多继承，那么一个类可以同时实现多个接口吗?
    对于计算机来说，一个机箱上有多个接口，一个接口是接键盘的,
    一个接口是接鼠标的，一个接口是接电源的，一个接口是接显示器的.....
一个类可以同时实现多个接口。

这种机制弥补了java中的哪个缺陷?
    java中类和类只支持单继承。实际上单继承是为了简单而出现的，现实世界中存在多继承,java中的接口弥补了单继承带来的缺陷。
    接口A和接口B虽然没有继承关系，但是写代码的时候，可以互转。编译器没意见。但是运行时可能出现:ClassCastException

之前有一个结论:
    无论向上转型还是向下转型，两种类型之间必须要有继承关系，没有继承关系编译器会报错。(这句话不适用在接口方面)
    最终实际上和之前还是一样，需要加:instanceof运算符进行判断。
    向下转型养成好习惯。转型之前先if+instanceof进行判断。

使用接口可以使用多态（父类型引用指向子类型对象）

实例

public class Test03{
    public static void main (String[] args)(
    //多态该怎么用呢?
    //都是父类型引用指向子类型对象
    A a=new D();
    //a.m2();
    //编译报错。A接口中没有m2()方法。
    B b=new D();
    C c=new D();

    //这个编译没问题,运行也没问题。
    //调用其他接口中的方法,你需要转型(接口转型)
    B b2 = (B)a;
    b2.m2();

    //直接向下转型为D可以吗?可以
    D d=(D)a;
    d.m2();

    M m=new E();
    //经过测试:接口和接口之间在进行强制类型转换的时候，没有继承关系，也可以强转
    //但是一定要注意,运行时可能会出现ClassCastException异常。
    //编译没问题,运行有问题。
    //K k=(K)m;
    if(m instanceof K){
        K k=(K)m;
    }
}

interface K{}
interface M{}
class E implements M{}

interface X{}
interface Y{}
interface Z extends x,Y{//接口和接口支持多继承。}

interface A{
    void m1();
}
interface B{
    void m2 ();
}
interface C{
    void m3();
}  


//实现多个接口,其实就类似于多继承。
class D implements A,B,C{
//实现A接口的m1()
public void m1(){}
//实现B接口中的m2()
public void m2(){
System.out.println( "m2 .... ");
}
//实现接口c中的m3()
public void m3(){}
}

接口的作用

要点

面向接口编程,可以降低程序的耦合度，提高程序的扩展力。符合oce开发原则。接口的使用离不开多态机制。（接口+多态才可以达到降低耦合度。)
任何一个接口都有调用者和实现者，接口可以将调用者和实现者解耦合，调用者面向接口调用，实现者面向接口编写实现。
以后进行大项目的开发,一般都是将项目分离成一个模块一个模块的，模块和模块之间采用接口衔接。降低耦合度。

分析:
中午去饭馆吃饭,这个过程中有接口吗?
接口是抽象的。
菜单是一个接口。（菜单上有一个抽象的照片:西红柿妙鸡蛋)
谁面向接口调用。(顾客面向菜单点菜，调用接口。)
谁负责实现这个接口。（后台的厨师负责把西红柿鸡蛋做好，是接口的实现者。
这个接口有什么用呢?
这个饭馆的"菜单"，让"顾客"和"后厨"解耦合了
顾客不用找后厨,后厨不用找顾客。他们之间完全依靠这个抽象的菜单沟通.

接口是不是完全的?是。
而我们以后正好要求,面向抽象编程。
面向抽象编程这句话以后可以修改为:面向接口编程。
有了接口就有了可插拔。可插拔表示扩展力很强。不是焊接死的。

分析：
主板和内存条之间有插槽，这个插槽就是接口，内存条坏了，可以重新买一个换下来。这叫做高扩展性。(低耦合度。)

接口在现实世界中是不是到处都是呢?
螺栓和螺母之间有接口
灯泡和灯口之间有接口
笔记本电脑和键盘之间有接口（usb接口，usb接口是不是某个计算机协会制定的协接口有什么用?扩展性好。可插拔。
接口是一个抽象的概念

实例

//中餐厨师
//实现菜单上的菜
//厨师是接口的实现者。
public class ChinaCooker implements FoodMenu{
    //西红柿炒蛋
    public void shiZiChaoJiDan(){
        System.out.println("中餐师傅做的西红柿炒鸡蛋，东北口味! ");
    }
    //鱼香肉丝
    public void yuXangRouSi(){
        System.out.println(中餐师傅做的鱼香肉丝，东北口味!");
    }
}

//西餐厨帅
//实现菜单上的菜
//厨师是接口的实现者。
public class AmericCooker imp1ements FoodMenu{
//西红柿炒蛋
    public void shiZiChaoJiDan(){
        System.out.println("西餐师傅做的西红柿炒鸡蛋!");
    }
    //鱼香肉丝
    public void yuXiangRouSi(){
        System.out.println("西餐师傅做的鱼香肉丝!");
    }
}

//顾客
public class Customer{
    //顾客手里有一个莱单
    // Customer has a FoodMenu!（这句话什么意思:顾客有一个菜单)
    //记住:以后凡是能够使用has a来描述的，统一以属性的方式存在。
    //面向抽象编程,面向接口编程。降低程序的耦合度，提高程序的扩展力。

    private FoodMenu foodMenu;

    //如果以下这样写,就表示写死了
    //中餐厨师
    //ChinaCooker cc;
    //西餐厨师
    //AmericCooker ac;

    //构造方法
    public Customer(){}
    public Customer(FoodMenu foodMenu){
        this.foodMenu=foodMenu;
    }

    //setter and getter(这里就不写上来了)

    //提供一个点菜的方法
    public void order(){
        //先拿到菜单才能点菜
        //调用get方法拿菜单。
        //FoodMenu fm = this.getFoodMenu();
        //也可以不调用get方法，因为在本类中私有的属性是可以访问
        foodMenu.shiZiChaoJiDan();
        foodMenu.yuXiangRouSi();
        }
    }
/*
    Cat is a Animal，但凡满足is a的表示都可以设置为继承。
    Customer has a FoodMenu，但凡是满足has a的表示都以属性的形式存在。
*/
/*
接口:菜单,抽象的
*/

public interface FoodMenu{
        //西红柿炒蛋
        void shiZiChaoJiDan();
        //鱼香肉丝
        void yuXiangRouSi();
}

public class Test{
    public static void main(String[] args){
    //创建厨师对象
    //FoodMenu cooker1 = new ChinaCooker();
    FoodMenu cooker1 = new AmericCooker();

    //创建顾客对象
    Customer customer = new Customer(cooker1);

    //顾客点菜
    customer.order();
    }
}