Chp9-接口

概念

1. 从功能上看，实现接口就意味这扩展了某些功能
2. 从抽象上看，接口对于类而言就是特殊的抽象父类
3. 从规则上看，是接口定义者和接口实现者都必须遵循的某些规则

语法

[public] interface 接口名{
} 

规则

1. 属性必须为公开静态常量（public static final）

• 由于修饰符固定，所以可以省略过着缺失，编译器自动补充

2. 方法为公开抽象方法（public abstract）
3. 不存在构造方法
4. 不能被实例化对象

package com.by.dao;

public interface IA {
    public static final int A = 100;
    final int B = 200;
    int C = 300;

    public abstract void m1();
    public void m2();
    void m3();

}

public interface IB {
    public void ma();
}

实现类

[public] class 实现类名 imolements 接口名{
}

实现了写在com.Xxx.dao.impl包下

package com.by.dao.impl;

import com.by.dao.IA;
import com.by.dao.IB;
import com.by.entity.Super;


public class IA_IB_Impl extends Super implements IA, IB{

    @Override
    public void m1() {
        System.out.println("IA_IB_Impl-m1");
    }

    @Override
    public void m2() {
        System.out.println("IA_IB_Impl-m2");
    }

    @Override
    public void m3() {
        System.out.println("IA_IB_Impl-m3");
    }

    @Override
    public void ma() {
        System.out.println("IA_IB_Impl-ma");
    }


    public void method() {
        System.out.println("IA_IB_Impl-method");
    }
}

规则

1. 必须对接口的抽象方法提供方法实现

• 除非实现类本身是抽象类（不推荐）

2. 一个实现类可以实现多个接口，一个接口也可以拥有多个实现类（多实现）

• 语法补充：

 [public] class 实现类名 implements 接口名1,接口名2,..{
         
     }

3. 实现类如果实现了多个接口，必须对所有接口中的抽象方法都提供方法实现
4. 类可以同时继承父类和实现接口，**先继承后实现

[public] class 类名 extends 父类类名 implements 接口名1,接口名2,..{
       
   }

5. 接口名仍然可以参与多态

 接口名 引用名=new 实现类名();

6. 接口参与多态时，仍然不可访问实现类独有内容

• 需要访问独有内容，必须进行类型强转
• 只能转向原本指向的实现类类型、实现类的其他引用类型
• 同级实现类之间不可强转

//利用多态创建实现类对象
           IA ia = new IA_IB_Impl();
           ia.m1();
           ia.m2();
           ia.m3();
           /*ia.ma();
           ia.method(); 错误,编译失败*/
           //将ia引用类型强转为IB接口
           IB ib = (IB) ia;
           ib.ma();
           //将ia引用强转为实现类类型
           IA_IB_Impl ia_ib = (IA_IB_Impl) ia;
          // IAImpl iaimpl = (IAImpl) ia; 运行报错
         //  IAImpl iaImpl = (IAImpl) ia_ib; 编译报错

7. 仍然可以使用instanceof关键字

引用 instanceof 接口名

IA ia = new IA_IB_Impl();
   
           System.out.println(ia instanceof IA_IB_Impl);//t
           System.out.println(ia instanceof IA);//t
           System.out.println(ia instanceof IB);//t

接口间的继承

一个接口可以继承多个父类口（多继承）

[public] interface 子接口名 extends 父接口名1,父接口名2,..{
    
}

• 子接口可以继承拥有所有父接口中的内容

接口与抽象类的区别

	抽象类	接口
关键字	abstract class	interface
属性	不做要求	公开静态常量
方法	不做要求,可以存在非抽象方法	公开抽象方法
构造	有	无
继承性	单继承	多继承

接口高级

高版本的接口

jdk8.0

1. 默认方法

public default 返回值类型 方法名(形参列表){
       
   }

• 当类继承父类又实现接口，父类和接口中的内容出现冲突时，优先执行父类内容（类优先原则）
• 当同时实现多个接口，接口之间的方法出现冲突时，实现类必须对冲突方法提供重写，使用自身重写内容

2. 静态方法

  public static 返回值类型 方法名(形参列表){
       
   }

• 可以通过接口名.方法名（实参）的方式直接调用

JDK9.0

1. 私有方法

  private 返回值类型 方法名(形参列表){
       
   }

• 实现类无法扩展该方法

接口回调

“开闭原则”：扩展开放，修改关闭

允许在当前代码的基础上扩展功能，但是前提是不修改已有内容

• 实现：将方法的形参声明为接口类型，实参传入不同的实现类对象（多态的第二个应用场景）
• 优势：将方法定义与方法的具体执行分离，定义者负责使用接口定义，使用者根据需求提供实现类具体执行，以此提高代码复用度

比较器案例

需求：利用比较器对数组进行指定规则的排序

1. 书写实现类，实现Comparator接口，重写compare方法

public class 实现类名 implements Comparator<要排序的类名> {
       @Override
       public int compare(要排序的类名 o1, 要排序的类名 o2) {
           
       }
   }

2. 书写排序

• 从小到大:
  • o1的值>o2的值,return正数
  • o1的值<o2的值, return负数
  • 相等return0
  • 从大到小:
    • o1的值>o2的值,return负数
    • o1的值<o2的值, return正数
    • 相等return0

 package com.by.dao.impl;
   
   import com.by.entity.Student;
   
   import java.util.Comparator;
   
   public class StudentComparator implements Comparator<Student> {
       @Override
       public int compare(Student o1, Student o2) {
           //根据学生年龄从小到大
           if (o1.getAge() > o2.getAge()) {
               return 1;
           } else if (o1.getAge() < o2.getAge()) {
               return -1;
           } else {
               return 0;
           }
       }  
   }

3.在测试类中调用Arrays.sort()传入数组和实现类对象

 package com.by.test;
   
   import com.by.dao.impl.StudentComparator;
   import com.by.entity.Student;
   
   import java.util.Arrays;
   
   public class TestStudent {
       public static void main(String[] args) {
           //创建一个学生数组
           Student[] ss = {new Student("zhangsan", 21, 98.0),
                   new Student("lisi", 20, 88.5),
                   new Student("wangwu", 22, 97.0)};
           //根据学生年龄从小到大的排序
           Arrays.sort(ss,new StudentComparator());
   
   
           for (int i = 0; i < ss.length; i++) {
               System.out.println(ss[i].getName()+"  "+ss[i].getAge()+  "  "+ss[i].getScore());
           }
       }
   }

接口的好处

1. 使项目结构更加清晰
2. 更符合现实逻辑
3. 提供接口回调方便提高代码复用度

今日掌握

1. 接口和实现类的语法
2. 接口和抽象类的区别
3. 接口和实现类的规则