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;
}
}