接口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方法