代码，自然写的越简洁越好啦，写的人舒服，看的人也舒服，一切为了高效。
要把有限的时间花到其它有意思的事情上去。
目的
学习简化代码的思路，使用jdk8新特性lamada表达式。
使用
某接口，只有一个方法。
比如这个:
package java.lang;
@FunctionalInterface
public interface Runnable {
void run();
}
或者是这个：
interface MyInterface{
void sayHi();
}
实现接口，使用方法
一般我们要使用Runable子类开启一个线程，要实现Runnable接口，调用Threead类的start方法：
public class LeaningLamda implements Runnable{
public static void main(String[] args) {
new Thread(new LeaningLamda()).start();
}
@Override
public void run() {
System.out.println(this.getClass()+"我已经在跑了！");
}
}
或者用sayHi方法干点什么，要先实现接口，再调用：
public class LeaningLamda2 implements MyInterface{
public static void main(String[] args) {
new LeaningLamda2().sayHi();
}
@Override
public void sayHi() {
System.out.println("ok ok ok ok ,i am say Hi!");
}
}
interface MyInterface{
void sayHi();
}
内部类实现接口，使用方法
如果这个方法我就用一次，那我可以在内部类中实现它，提高程序性能：
public class LeaningLamda{
static class MyRun implements Runnable{
@Override
public void run() {
System.out.println(this.getClass()+"我已经在跑了！");
}
}
public static void main(String[] args) {
new Thread(new MyRun()).start();
}
}
一样的用sayHi方法：
public class LeaningLamda2 {
static class MyHi implements MyInterface{
@Override
public void sayHi() {
System.out.println("ok ok ok ok ,i am say Hi!");
}
}
public static void main(String[] args) {
new MyHi().sayHi();
}
}
interface MyInterface{
void sayHi();
}
局部内部类实现接口，使用方法
既然只使用一次，那我为啥不把它放在使用的方法里面去，性能不就又UpUpUpUp。
像这样：
public class LeaningLamda{
public static void main(String[] args) {
class MyRun implements Runnable{
@Override
public void run() {
System.out.println(this.getClass()+"我已经在跑了！");
}
}
//调用在定义后面，谢谢。
new Thread(new MyRun()).start();
}
}
或是这样：
public class LeaningLamda2 {
public static void main(String[] args) {
class MyHi implements MyInterface{
@Override
public void sayHi() {
System.out.println("ok ok ok ok ,i am say Hi!");
}
}
new MyHi().sayHi();
}
}
interface MyInterface{
void sayHi();
}
匿名内部类实现接口，使用方法
我就用一次，要什么名字啊？能少输入一个字符都是赚的。需要借助父类或者接口名来实现。
你看：
public class LeaningLamda{
public static void main(String[] args) {
//需要借助父类或者接口来声明
new Thread(new Runnable(){
@Override
public void run() {
System.out.println(this.getClass()+"我已经在跑了！");
}
}).start();
}
}
又如：
public class LeaningLamda2 {
public static void main(String[] args) {
new MyInterface(){
@Override
public void sayHi() {
System.out.println("ok ok ok ok ,i am say Hi!");
}
}.sayHi();
}
}
interface MyInterface{
void sayHi();
}
使用lamda表达式的，实现方法
jdk 8 看不下去了，给我们提供了一个更加简化的方案，你看：
lamda表达式实现创建单个简单线程：
public class LeaningLamda{
public static void main(String[] args) {
new Thread(()-> {
System.out.println("我已经在跑了！");
}
).start();
}
}
lamda表达式sayHi：
public class LeaningLamda2 {
public static void main(String[] args) {
//此处需要借助一个父类或接口对象来存放，调用它
MyInterface ls = ()->{
System.out.println("ok ok ok ok ,i am say Hi!"); };
ls.sayHi();
}
}
interface MyInterface{
void sayHi();
}
可带参数
lamda表达式可以带参数，可以不指定类型，它会自适应类型：
public class LeaningLamda2 {
public static void main(String[] args) {
MyInterface ls = (i,str)->{
System.out.println("int:"+i);
System.out.println("String:"+str);};
ls.sayHi(520,"i love you!");
}
}
interface MyInterface{
void sayHi(int i,String str);
}
运行结果：
一个参数
那我括号都可以省了！
public class LeaningLamda2 {
public static void main(String[] args) {
MyInterface ls = str-> System.out.println("String:"+str);
ls.sayHi("i love you!");
}
}
interface MyInterface{
void sayHi(String str);
}
运行结果：
返回值
如果有返回值呢，正常返回：
public class LeaningLamda2 {
public static void main(String[] args) {
MyInterface ls = (String str)-> {
String str2 = "最后的赢家是："+str;
return str2;};
System.out.println(ls.sayHi("lurenjia"));
}
}
interface MyInterface{
String sayHi(String str);
}
一条语句
如果方法只有一条语句，那大括号也没有必要，可以省略：
public class LeaningLamda2 {
public static void main(String[] args) {
MyInterface ls = (int i,String str)-> System.out.println("int:"+i+"----String:"+str);
ls.sayHi(520,"i love you!");
}
}
interface MyInterface{
void sayHi(int i,String str);
}
究极省略，不能再省了
就一条语句，是返回值：
public class LeaningLamda2 {
public static void main(String[] args) {
MyInterface ls = str-> "最后的赢家是："+str;
System.out.println(ls.sayHi("中国"));
}
}
interface MyInterface{
String sayHi(String str);
}
运行结果：
lamda总结
常用于创建简单线程。
1、接口只有一个方法，可有参数，可有返回值。
2、本方法内容简单，使用较少。
3、基本形式为：
接口或父类 名称 = (参数类型1 参数1,参数类型2 参数2,...)->{
内容
};
名称.方法（参数1，参数2，...）；
4、可以省略的是：
1、lamada参数类型可省，它自适应。 2、方法内容只有一条内容，大括号可省。 3、内容只有一句返回语句，return可省，直接写值。
标签：
留言评论