java接口

接口

1、接口简介

• 接口的定义
  • 定义：特殊的抽象类，实现类的多重继承
    微观:接口是一种能力和约定。
    宏观:接口是一种标准。

修饰符 interface 接口名 extends 父类接口名列表{
      public static final 常量;            // 公开静态常量
      public abstract 方法;            // 公开抽象方法
}    //  接口只能定义  公开静态常量和公开抽象方法    没有构造方法，不能创建对象

• 接口的特点

  • （1）接口只能定义公开静态常量和公开抽象方法
  • （2）没有构造方法，不能创建对象

• 接口的规范

  • 任何类在实现接口时,必须实现接口中所有的抽象方法,否则此类为抽象类。
  • 实现接口中的抽象方法时,访问修饰符必须是 public

2、接口的继承

特点：接口可以多继承，各个父类接口在extends之后用"," 隔开

interface interfaceA
{
    int PROP_A = 5;
    void testA();
}
interface interfaceB
{
    int PROP_B = 6;
    void testB();
}
interface interfaceC extends interfaceA, interfaceB
{
    int PROP_C = 7;
    void testC();
}
public class InterfaceExtendsTest {
    public static void main(String[] args) {
        System.out.println(interfaceC.PROP_A);
        System.out.println(interfaceC.PROP_B);
        System.out.println(interfaceC.PROP_C);
    }
}

3、接口的实现

public interface CalInterface   {  
     final float PI=3.14159f;//定义用于表示圆周率的常量PI  
     float getArea(float r);//定义一个用于计算面积的方法getArea()  
     float getCircumference(float r);//定义一个用于计算周长的方法getCircumference()  
 }

public class Cire implements CalInterface{
    public float getArea(float r) {
        float area=PI*r*r;//计算圆面积并赋值给变量area
        return area;//返回计算后的圆面积
    }
    public float getCircumference(float r){
        float circumference=2*PI*r;      //计算圆周长并赋值给变量circumference
        return circumference;           //返回计算后的圆周长
    }
    public static void main(String[] args){
        Cire c = new Cire();
        float f = c.getArea(2.0f);
        System.out.println(Float.toString(f));
    }
}

4、接口与抽象类

举个栗子：
父类是亲爹：亲爹只能有一个
接口是干爹：干爹可以有多个

5、接口回调

回调方类A的一个方法a通过调用类B的一个方法b去调用类A的另一个方法c。绕晕了吧，其实就是一个类去请求另一个类后得到回复再去调用本类的另一个方法，至于同步回调就是方法b中的逻辑执行完再去执行方法c，而异步回调就是b和c一起再执行。有人问：为什么不直接通过a去调用b呢？答案很简单，生活中有些事总不能自己解决，学生有问题总不能自问自答吧。下面是一个乘客与司机的同步回调案例：

interface Callback{              //回调方类A的接口
    boolean Consider(int money); //思考是否付钱，就是方法c
    void PayFor(int money);      //付钱,就是方法c

}
class TaxiDriver{               //调用方类B
    public int Answer(Callback callback){      //回答多少钱，就是方法b
        System.out.println("去那的话要100块");
        if(callback.Consider(100) == true){
            callback.PayFor(100);
        }
        return 100;
    }
}
class Passenger implements Callback{  //回调方类A
    @Override
    public boolean Consider(int money) {
        boolean result = true;
        if(money > 80){
            System.out.println(money+"太贵了，您看80行不行？");
            result = false;
        }
        return result;
    }
    @Override
    public void PayFor(int money) {
       System.out.println("好的，这是您的"+money);
    }
    public void TakeTaxi(TaxiDriver td){        //询问多少钱，就是方法a
        System.out.println("师傅，去天一多少钱？");
        td.Answer(this);
    }
}
public class CallBackTest {                    
   @Test
   public void test(){
       TaxiDriver td = new TaxiDriver();
       Passenger passenger = new Passenger();
       passenger.TakeTaxi(td);
   }
}
原文链接：https://blog.csdn.net/qq_33667439/java/article/details/78666979

先有接口的使用者,后有接口的实现者

6、接口与多态

7、面向接口编程

常量接口

将多个常用于表示状态或固定值的变量,以静态常量的形式定义在接口中统一管理。提高代码可读性

//常量接口
interface State{
	public static final int RED = 1;
	int YELLOW = 2;
	int GREEN = 3;
}