java基础 接口

接口

概念

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 实现类名 implements 接口名{

}

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.静态方法

pubic 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. 提供接口回调方便提高代码复用度