接口的几种实现方式

1.通过一个类的继承实现

定义一个人类实现标准。

package aaa; //包
interface IPerson{  //接口标准
  public abstract String eat();  //接口方法
  public abstract String think(); //接口方法
  }
class Student implements IPerson{   //子接口实现
@Override   //注解：准确覆写
	public String eat() {  //覆写方法
    return "会吃";
    }
@Override
    public String think() {
	return "会思考";
	}	
}
public class Lx {
public static void main(String args[]) {
	IPerson a=new Student();  //实例化对象
	System.out.println(a.eat()+a.think());	//输出
    }
}

输出：会吃会思考

---

2.在接口内部通过内部类实现

package aaa;
interface IPerson{
public abstract String eat();
public abstract String think();
class Student implements IPerson{  //类内部接口实现
	public String eat() {
		return "会吃";
	}
	public String think() {
		return "会思考";
	}
  }
}
public class Lx {
public static void main(String args[]) {
	IPerson.Student a=new IPerson.Student(); //实例化
	System.out.println(a.eat()+a.think());	
    }
}

此时注意实例化方式：外部类.内部类 内部类对象=new 外部类.内部类（）；
如果要定义方法输出，则方法定义为static类型。

---

3.需要使用直接实例化对象，采用匿名内部类实现

如果有时候某一个接口的实现只是使用一次，则定义类实现过去浪费，此时使用匿名内部类定义完成。

package aaa;
interface IPerson{
public abstract String eat();
public abstract String think();
  }
public class Lx {
public static void main(String args[]) {
	IPerson a=new IPerson(){
		public String eat() {
			return "会吃";
		}
		public String think() {
			return "会思考";
		}
	};
	System.out.println(a.eat()+a.think());	
  }
}

在实例化的对象之后增加构造代码库块完成对抽象方法的覆写。

---

4、接口内直接定义static方法返回匿名内部对象实现

在接口中定义一个返回类型为接口的static方法，返回值为其对象，在返回对象之后增加代码块，代码块中覆写抽象方法。使用时通过调用格式为：接口名.静态方法名（）.覆写之后抽象方法名（）

package aaa;
interface IPerson{
public abstract String eat();
public abstract String think();
public static IPerson get() {
	return new IPerson(){
		public String eat() {
			return "会吃";
		}
		public String think() {
			return "会思考";
		}
	};
	}
}
public class Lx {
public static void main(String args[]) {
	System.out.println(IPerson.get().eat()+IPerson.get().think());	
    }
}

注：所举例子中输出结果全部相同。

---

以下两种方法适用于接口中只有一个抽象方法的情况下。

5.使用Lambda（必须是函数式接口）

interface Message {  
public void send(String x);
}
public class N {
public static void main(String[] args) {
   Message a=(x)->{
		System.out.println("消息发送："+x); //幸福安康
	};
a.send("幸福安康");
	}
}

利用这种结构避免了面向对象的复杂处理结构。Lambda若要进行使用，就必须要有一个重要的实现要求：SAM(Single Abstract Method),只有一个抽象方法。
如果一个接口中只提供一个方抽象法，除此之外没有其他任何抽象方法，这样的接口就称为函数式接口。（接口中允许有static方法和加default的普通方法）而只有函数式接口才可以被Lambda表达式所使用。

---

6.方法引用，泛型实现(要求必须是函数式接口)

引用数据类型最大的特点是可以进行内存的指向处理，传统的开发之中一直所使用的只是对象的引用操作。从jdk1.8开始提供有方法的引用。即不同的方法名称可以描述同一个方法。如果要进行方法的引用，Java提供以下四种形式：

例子：以此引用静态方法为例子。
·在String类中提供的String.valueOf()方法属于静态方法；
——方法定义：public static String vaueOf(int i)；该方法有参数，有返回值。

@FunctionalInterface //函数式接口
//p描述的是参数，R描述的是返回值
interface IMessage<P,R> {  
public R change(P p);
}
public class N {
public static void main(String[] args) {
  IMessage<Integer,String> fun = String :: valueOf;
  String a=fun.change(100000);
  System.out.println(a.length()); //6
	}
}

利用方法引用可以为一个方法定义多个方法名字，但是要求必须是函数式接口（SAM标准）。