接口

接口与面向接口编程

概念：

接口( Interface )在Java中也是一种抽象类型，接口中的内容是抽象形成的需要实现的功能,接口更像是一种规则和一套标准.

接口语法形式

  1. interface 接口名 {代码块}

特点

  1. 通过interface关键字来定义接口
  2. 通过implements让子类来实现接口
  3. 接口中的方法全部都是抽象方法(JAVA8)——只定义规则不实现
  4. 可以把接口理解成一个特殊的抽象类(但接口不是类!!!)
  5. 类描述的是一类事物的属性和方法,接口则是包含实现类要实现的方法
  6. 接口突破了java单继承的局限性
  7. 接口和类之间可以多实现,接口与接口之间可以多继承
  8. 接口是对外暴露的规则,是一套开发规范
  9. 接口提高了程序的功能拓展,降低了耦合性

  10. 接口的实现类有两种

    1. 抽象类：不实现/实现部分—-不可以创建对象
    2. 普通实现类：实现所有抽象方法—-创建对象时进行功能调用—-最常用

示例代码

创建接口

  1. package cn.tedu.inter;
  3. /**
  4.  * 用于接口测试
  5.  * 使用interface关键字创建接口
  6.  */
  8. public interface Inter {
  10.     /*
  11.     接口中不可以创建普通方法
  12.     public void play(){ }
  13.      */
  15.     //接口中的方法都是抽象方法
  16.     void pokemon();
  18.     void superman();
  19. }

创建接口实现类

  1. package cn.tedu.inter;
  3. /**
  4.  * Inter接口的实现类
  5.  * 实现类需要通过implements关键字与接口建立实现关系
  6.  * 1.可以不实现接口中的抽象方法，将自己变为抽象类
  7.  * abstract public class InterImpl implements Inter
  8.  * 2.实现接口中的所有方法
  9.  */
  11. public class InterImpl implements Inter {
  13.     @Override//用作标记，标记实现了父接口的抽象方法
  14.     public void pokemon(){
  15.         System.out.println("我得到宝可梦了!");
  16.     }
  18.     @Override
  19.     public void superman() {
  20.         System.out.println("我要成为超人!!!");
  21.     }
  23. }

创建接口测试类

  1. package cn.tedu.inter;
  3. /**
  4.  * 接口实现类测试
  5.  */
  7. public class TestInter {
  8.     public static void main(String[] args) {
  9.         /*
  10.         接口不可以创建对象
  11.         Inter i = new Inter();
  12.          */
  13.         //创建多态对象进行实现测试
  14.         Inter i = new InterImpl();
  15.         i.superman();
  16.         i.pokemon();
  18.         //创建实现类对象进行测试
  19.         InterImpl inter = new InterImpl();
  20.         i.pokemon();
  21.         i.superman();
  22.     }
  23. }

关于接口中构造方法与成员变量的测试

关于构造方法

  1. 接口中没有构造方法
  2. 一个类名有明确指定父类，会默认继承顶级父类Object
  3. 接口实现类使用的不是接口中的构造方法，接口没有构造方法，使用的是父类的构造方法。

关于成员变量

  1. 接口中没有成员变量只有静态常量因为可以使用接口名直接调用，并且不可以被重新赋值。
  2. 接口中的都是静态常量static与final可以简写，会自动拼写

关于抽象方法

接口中的方法都是抽象方法，并且public与abstract都可以简写，可以直接写为void 方法名();

示例代码

  1. package cn.tedu.inter2;
  3. /**
  4.  * 测试接口的使用
  5.  * 当一个类没有明确指定父类的情况下，默认继承顶级父类Object
  6.  */
  8. public class TestUserInter {
  9.     public static void main(String[] args) {
  10.         InterImpl inter = new InterImpl();
  11.         System.out.println(inter.name);
  12.         System.out.println(Inter.name);//测试静态
  13.         //inter.name = "泡泡";报错，测试常量
  14.     }
  15. }
  17. interface Inter{
  19.     /*接口中没有成员变量
  20.     接口中的变量实际为静态常量，
  21.     因为可以使用接口名直接调用，并且不可以被重新赋值
  22.     接口中的都是静态常量static与final可以简写，会自动拼写
  23.      */
  24.     String name = "程晓宇";
  26.     /*
  27.     接口中没有构造方法，
  28.     因为构造方法有方法体，但接口中的方法都是抽象方法，没有方法体
  29.      */
  30.     void play();
  31. }
  33. /**
  34.  * 问题：接口实现类的接口中没有构造方法，接口实现类为什么可以创建对象，
  35.  * 子类构造的首航不是要调用super吗
  36.  * 答案：父级接口不是类，接口没有构造函数，
  37.  * 实际实现类调用的super()指的是继承的的父类的无参构造
  38.  * 如果没有明确指定父类，那就调用的是顶级父类的Object中的无参构造
  39.  */
  41. //Object是所有类的顶级父类
  42. class InterImpl extends Object implements Inter{
  44.     @Override
  45.     public void play() {
  47.     }
  49.     public InterImpl(){
  50.         super();//调用的是顶级父类的构造方法
  51.         System.out.println("实现类的无参构造");
  52.     }
  53. }

接口间的多继承

  1. 接口之间可以建立继承关系

  2. 接口之间可以多继承，多个接口间用逗号隔开

  3. 接口与类之间为实现关系，使用implements关键字建立实现关系

  4. Java遵循单继承，多实现的原则，一个类只能有一个父类，可以实现多个接口

示例代码

  1. package cn.tedu.design;
  3. /**
  4.  * 用于测试接口与类之间的继承关系
  5.  */
  7. public class TestRelation {
  8.     public static void main(String[] args) {
  9.         InterImpl inter = new InterImpl();
  10.         inter.delete();
  11.         inter.save();
  12.         inter.update();
  13.         inter.find();
  14.     }
  15. }
  17. interface Inter1{
  18.     void save();//保存
  19.     void delete();//删除
  20. }
  22. interface Inter2{
  23.     void find();//查找
  24.     void update();//更新
  25. }
  27. /*
  28. 接口之间可以建立继承关系
  29. 可以多继承，多个接口间用逗号隔开
  30. 接口与类之间为实现关系
  31. Java遵循单继承，多实现的原则，一个类只能有一个父类，可以实现多个接口
  32.  */
  33. interface Inter3 extends Inter1,Inter2{
  35. }
  37. class InterImpl implements Inter3{
  39.     @Override
  40.     public void save() {
  41.         System.out.println("另存文件为······");
  42.     }
  44.     @Override
  45.     public void delete() {
  46.         System.out.println("确认是否要删除");
  47.     }
  49.     @Override
  50.     public void find() {
  51.         System.out.println("正在查询");
  52.     }
  54.     @Override
  55.     public void update() {
  56.         System.out.println("确认更新");
  57.     }
  58. }

类与接口的关系

1. 类与类的关系

继承关系，只支持单继承（一个子类只能有一个父类，一个父类可以有多个子类）。``

例如：A是父类，B是子类，B extends A

B类复制了A类的所有资源，可以使用A类的所有的非私有资源

B类可以重写A类的方法（规则：两同、两小、一大）

2. 接口与接口的关系

继承关系，支持单继承与多继承（一个子类可以有多个父类，一个父类可以有多个子类）。

例如：interface Inter3 extends Inter2 , Inter1

Inter3是子接口，Inter2与Inter1是父接口，接口3同时拥有接口1与接口2的所有功能。

3. 类与接口的关系

单实现：

Inter3Impl是Inter3的实现类 class Intel3Impl implements Inter3{}
如果实现类想要成为一个普通类,必须实现接口中的所有抽象方法

多实现：

Inter4Impl implments Inter1 , Inter2 , Inter3{}

这个就是针对与类的多实现一个类可以同时实现多个接口
如果想要成为一个普通子类必须实现所有接口中的所有抽象方法

复杂写法：

Inter4Impl extends AAA implments Inter1 , Inter2 , Inter3{}

因为Java中类的是单继承多实现，所以继承语法要写在后面

接口与抽象类的区别

  1. 抽象类是一个被abstract修饰的类，这个类可以存在抽象方法，没有方法体的方法。
    接口可以理解为一个特殊的抽象类，特殊在接口中的方法都是抽象方法。

  2. 抽象类中的方法没有限制，
    接口中的方法只能为抽象方法，并且可以简写，默认拼接public abstract

  3. 抽象类中有构造方法，为了子类创建对象时调用super()
    接口中没有构造方法，接口实现类若没有明确指定父类，super调用的是Object类

  4. 接口与抽象类均不可创建对象

  5. 抽象类是重构的结果，接口是设计的结果