Java------推导lambda_简化线程
当线程用的次数比较少时。可以用lambda表达式。
lambda避免匿名内部类定义过多。
实质属于函数式编程的概念
第一步推导：使用静态内部类
/**
* Lambda表达式 简化线程（用一次）的使用
*/
public class ThreadLambda {
//当一个类只使用一次时，可以将这个类作为静态内部类
//不使用，则不会编译
static class Test implements Runnable{
@Override
public void run(){
for (int i = 0;i<=10;i++){
System.out.println(i);
}
}
}
public void run2(){
for (int i = 0;i<=10;i++){
System.out.println(i+"run2.............");
}
}
public static void main(String[] args) {
new Thread(new Test()).start();
}
}
第二步：使用局部内部类
/**
* Lambda表达式 简化线程（用一次）的使用
*/
public class ThreadLambda {
//当一个类只使用一次时，可以将这个类作为静态内部类
//不使用，则不会编译
static class Test implements Runnable{
@Override
public void run(){
for (int i = 0;i<=10;i++){
System.out.println(i);
}
}
}
public void run2(){
for (int i = 0;i<=10;i++){
System.out.println(i+"run2.............");
}
}
public static void main(String[] args) {
//静态内部类
//new Thread(new Test()).start();
class Test2 implements Runnable{
@Override
public void run(){
for (int i = 0;i<=10;i++){
System.out.println(i);
}
}
}
//局部内部类
new Thread(new Test2()).start();
}
}
第三步、第四步：使用匿名内部类以及lambda表达式
/**
* Lambda表达式 简化线程（用一次）的使用
*/
public class ThreadLambda {
//当一个类只使用一次时，可以将这个类作为静态内部类
//不使用，则不会编译
static class Test implements Runnable{
@Override
public void run(){
for (int i = 0;i<=10;i++){
System.out.println(i);
}
}
}
public void run2(){
for (int i = 0;i<=10;i++){
System.out.println(i+"run2.............");
}
}
public static void main(String[] args) {
//静态内部类
//new Thread(new Test()).start();
class Test2 implements Runnable{
@Override
public void run(){
for (int i = 0;i<=10;i++){
System.out.println(i);
}
}
}
//局部内部类
new Thread(new Test2()).start();
//3.匿名内部类，必须借助接口或者父类，没有了子类的名称
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0;i<=10;i++){
System.out.println(i);
}
}
}).start();
//4.lambda简化,接口中只能有一个方法
new Thread(() ->{
for (int i = 0;i<=10;i++){
System.out.println(i);
}
}).start();
}
}
很神奇，Thread里需要的是一个类，但是lambda好像一个执行的方法。简单了，但是会增加一定的维护难度。
带参数的lambda推导过程
/**
* Lambda表达式 简化线程（用一次）的使用
* 加入参数
* 个人觉得还有个重要的用处，重写父类方法时，就可以不用固定的实现。
* 每次用lambda给可以给他一个新的实现
*/
public class ThreadLambda02 {
public static void main(String[] args) {
//不需要写方法名和类体
Ilove lov = (int a) -> {
for (int i =0 ;i<10;i++){
System.out.println("i love"+a);
}
};
lov.lambda(100);
//再次简化，可以省略类型
lov = (a) -> {
for (int i =0 ;i<5;i++){
System.out.println("i love"+a);
}
};
lov.lambda(50);
//在只有一个参数的情况下，可以省略括号
lov = a -> {
for (int i =0 ;i<3;i++){
System.out.println("i love"+a);
}
};
lov.lambda(40);
//只有一行代码的情况下，花括号也可以省略
lov = a -> System.out.println("i love"+a);
lov.lambda(20);
}
}
interface Ilove{
void lambda(int a);
}
class love implements Ilove{
@Override
public void lambda(int a) {
}
}
带参数和返回值的lambda推导过程
/**
* Lambda表达式 简化线程（用一次）的使用
* 加入参数+返回值
* 个人觉得还有个重要的用处，重写父类方法时，就可以不用固定的实现。
* 每次用lambda给可以给他一个新的实现
*/
public class ThreadLambda03 {
public static void main(String[] args) {
//此处又重写了该方法，在不会走原方法
IDiss iDiss = (int a,int b) ->{
//控制台打印5，而不是3
System.out.println(a+b+b);
return b-a;
};
int lambda = iDiss.lambda(1, 2);
//结果返回值是1
System.out.println("返回值是："+lambda);
//简化，只能简化类型
iDiss = ( a, b) ->{
//控制台打印5，而不是3
System.out.println(a+b+b);
return b-a;
};
//改成只return，再简化
iDiss = (a, b) -> b-a ;
//无论a，b的值，直接返回100
iDiss = (a, b) -> 100 ;
}
}
interface IDiss{
int lambda(int a,int b);
}
class diss implements IDiss{
@Override
public int lambda(int a2,int b2) {
System.out.println(a2+b2);
return a2+b2;
}
}