接口interface

接口interface

一个完整的项目：class，interface，enum, annation+资源文件（配置文件）+jar
接口语法：
public interface 接口名称{
  
}
类与类单继承关系，利用接口进行弥补单根继承的关系。
在工作中，接口名称只有2种：
        ***Dao/DAO.java
        ***Service.java
用户接口：UserInfoDao.java

作用：制定规则，制定规范

组成部分

接口里面的组成部分全部都是public，接口中的属性默认是常量，一旦创建不可更改

public interface MyInterface {
    //常量[public static final]一般省略不写
    // 必须初始化，且不允许更改常量的名称全部都是大写
     int id=100;
     String name="admin";
    //jdk1.8之前的方法全是抽象方法，且都是public abstract
    void a();
    int max(int num1,int num2);
}

使用接口

接口和类的关系：多实现的关系，类可以实现多个接口，如果一个类实现了这个接口，说明该类为接口的实现类

创建的类需要实现接口，加上implement关键字

public class MyInterfaceImpl implements MyInterface {
    
    @Override
    public void a() {
       //方法重写 
    }
    @Override
    public int max(int num1, int num2) {
        return 0;
    }
}

然后通过创造接口实现类的对象来调用接口的方法

public class Test1 {
    public static void main(String[] args) {
        MyInterfaceImpl myInterface=new MyInterfaceImpl();
        myInterface.a();
        System.out.println(myInterface.max(10,100));
    }
}

通过接口便于集成，而且一个类可以实现多个接口，

public class MyInterfaceImpl implements MyInterface,MyIterface2 {
    @Override
    public void a() {

    }
    @Override
    public int max(int num1, int num2) {
        return 0;
    }
    @Override
    public void fun() {
        
    }
    @Override
    public String show() {
        return null;
    }
}

接口和接口

属于多继承关系，extends

子类接口代码：

public interface MyInterface extends MyIterface2 {
     int id=100;
     String name="admin";
    void a();
    int max(int num1,int num2);
}

对于实现类而言需要实现MyInterface接口，也需要重写它父类接口的方法

public class MyInterfaceImpl implements MyInterface {

    @Override
    public void a() {

    }
    @Override
    public int max(int num1, int num2) {
        return 0;
    }
    @Override
    public void fun() {

    }
    @Override
    public String show() {
        return null;
    }
}

jdk1.8之后的接口组成部分：

如果接口中的属性和方法加上一些关键字：

接口代码

public interface MyIterface2 {
    int num=36;//常量
    String fun();//默认是抽象方法
    //接口的新特性：与抽象类是相似的

用default来修饰接口的普通方法

default void a(){
        System.out.println("接口里面的a方法");
    }

用static来修饰方法

static int b(){
        System.out.println("接口里面的static的b方法");
        return 100;
    }}

那么在接口实现类中需要重写接口中的方法：

接口实现类代码：

public class MyInterfaceImpl extends Object implements MyIterface2 {
    @Override
    public String fun() {//抽象方法
        MyIterface2.b();
        System.out.println("重写的string的fun方法");
        return null;
    }

对于default修饰的普通接口方法，是默认存在的，可以直接用对象调用，也可以重写该方法

@Override
public void a() {
    //调用父接口的原功能，可以让该类继承object类，看接口实现类第一行代码
    //object来做接口实现类
    MyIterface2.super.a();
    System.out.println("重写的default的a方法");
}

对于static修饰的接口方法，可以通过接口直接调用该方法

public static void main(String[] args) {
    MyInterfaceImpl myInterface=new MyInterfaceImpl();
    myInterface.a();
    myInterface.fun();
}

这里输出结果是：

接口里面的a方法
重写的default的a方法
接口里面的static的b方法
重写的string的fun方法

说明这里的static没有最先执行，因为接口不是类，所以会按照顺序来执行

接口多态

多态的方式创建对象，父接口的引用指向任意一个接口实现类的对象，

语法：[接口名 对象 =new 接口实现类();]

MyIterface2 myIterface2=new MyInterfaceImpl();
//MyInterfaceImpl myInterface=new MyInterfaceImpl();
这两行效果是一样的

tips：当接口实现类中有很多其他接口的方法，此时创建出来的对象不能调用到其他接口的方法，但可以先判断该对象是否是实现类的对象，用instanceof判断，如果相同类型的话通过将对象强制转换成接口实现类的类型，所以当实现类中有其他接口的情况下，一般不使用接口多态，会直接创建实现类的对象。

函数式接口：有且只有一个抽象方法

要在接口加上注解@FunctionalInterface，加上之后代表接口里面有且只有一个抽象方法，jdk1.8之后如果接口有且只有一个抽象方法，推荐使用lamda替换接口匿名内部类，lamda语法：(形参类型 变量名称)->{方法体}

@FunctionalInterface
public interface MyIterface2 {
    int num=36;//常量
    void fun();
    }

public class Test1 {
    public static void main(String[] args) {
        MyIterface2 myIterface2=()->{
            System.out.println("接口里面的fun方法");
        };//替换接口里面抽象方法的重写，lamda只重写抽象方法，而且相当于创建了一个匿名内部类
        myIterface2.fun();
    }
}

有参无返回值：

void fun(String st);

此时只有一个参数，接口里面的形参的变量类型可以省略不写，默认映射为string类型

MyIterface2 myIterface2=(a)->{
    System.out.println("接口里面的fun方法"+a);
};
myIterface2.fun("p");

无参有返回值：

int fun();

此时lamda的小括号不用加参数，如果直接返回，可以省略花括号，如果有方法体内容，不能省略花括号

MyIterface2 myIterface2=()-> 3627;

  MyIterface2 myIterface2=()->{
          方法体
        return 3627;
    };
   

有参有返回值：

接口：

public interface MyIterface2 {
    int userid=10086;
    String password="123pass";
    boolean login(int id,String password);
}

这时候实参和形参的传递可以用接口调用：接口名.属性

public static void main(String[] args) {
    MyIterface2 myIterface2=( id, password)->{
        if(MyIterface2.userid!=id||MyIterface2.password.equals(password))
            return false;
        return true;
    };
    System.out.println(myIterface2.login(123,"pass"));
}

tips： lamda的简化：

接口：

public interface MyIterface2 {
    int userid=10086;
    String password="123pass";
    boolean login(String password);
}

对于lamda来创建匿名内部类来实现接口时，代码是这样写的：

MyIterface2 myIterface2=(password)->{
   if(MyIterface2.password.equals(password))
       return true;
   return false;
};

但是lamda的可以进行简化：

MyIterface2 myIterface2=(password)-> MyIterface2.password.equals(password);

此时代码会报黄，说明还可以简化：

MyIterface2 myIterface2= MyIterface2.password::equals;
//MyIterface2.password被当做一个对象来调用equals方法

所以简化语法：

对象/类：：调用方法

举例巩固：

接口中方法：

int max(int num1,int num2);

匿名内部实现类来调用方法：

MyIterface2 myIterface2= Math::max;//Math是静态类，直接调用max方法

原文地址：http://www.cnblogs.com/Liku-java/p/16809520.html