336冗余的Runnable代码和337编程思想的转换使用Lambd的更优写法

冗余的Runnable代码当需要启动一个线程去完成任务时,通常会通过java.lang.nabe接口来定义任务内容,

并使用ava.lang. Thread类来启动该线程。代码如下:

 

 

 本着一切皆对象的思想,这种做法是无可厚非的:首先创建一个 Runnable接口的匿名内部类对象来指定任务内容,再将其交给一个线程来启动。

代码分析

对于 Runnable的匿名内部类用法,可以分析出几点内容·

Thread类需要 Runnab1e接口作为参数,其中的抽象run方法是用来指定线程任务内容的核心;

为了指定run的方法体,不得不需要 Runnable接口的实现类·为了省去定义一个 Runnableimp1实现类的麻烦,不得不使用匿名内部类;

·必须覆盖重写抽象run方法,所以方法名称、方法参数、方法返回值不得不再写一遍,且不能写错;·而实际上,似乎只有方法体才是关键所在。

 

---------案例---------
public class Demo_Runnable implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"新的线程创建了");
    }
}

public static void main(String[] args) {

        //创建Runnable接口的实现类对象
        Demo_Runnable demo_runnable = new Demo_Runnable();
        //创建Thread对象，构造方法中传递Runnable接口的实现类
        Thread thread = new Thread(demo_runnable);
        //调用start方法开启线程，执行run方法
        thread.start();



        //简化代码//不用创建Runnable接口实现类
        Runnable r = new Runnable(){
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"新的线程创建了");
            }
        };
        new Thread(r).start();


        //简化代码

//不用创建Runnable接口实现类

 new Thread(new Runnable() { @Override public void run() {
 System.out.println(Thread.currentThread().getName()+"新的线程创建了"); } }).start(); }

编程思想的转换使用Lambd的更优写法

做什么,而不是怎么做我们真的希望创建一个匿名内部类对象吗?不。

我们只是为了做这件事情而不得不创建一个对象。我们真正希望做的事情是:将run方法体内的代码传递给 Thread类知晓。

传递一段代码一—这才是我们真正的目的。而创建对象只是受限于面向对象语法而不得不采取的一种手段方式。

那,有没有更加简单的办法?如果我们将关注点从“怎么敢"回归到"做什么"的本质上,就会发现只要能够更好地达到目的,过程与形式其实并不重要。

 

我们真的希望创建一个匿名内部类对象吗?不。我们只是为了做这件事情而不得不创建一个对象。我们真正希望做的事情是︰

　　将run方法体内的l弋码传递给Thread类知晓。

传递一段代码——这才是我们真正的目的。而创建对象只是受限于面向对象语法而不得不采取的一种手段方式。

　　那有没有更加简单的办法?如果我们将关注点从"怎么做"回归到"做什么"的本质上，就会发现只要能够更好地达到目的，过程与形式其实并不重要。

 public static void main(String[] args) {
        //简化代码
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"新的线程创建了");
            }
        }).start();

             //使用Lambda方式实现多线程
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"新的线程创建了");
            }
        ).start();
    }

public static void main(String[] args) {
            // 匿名内部类
            Runnable task = new Runnable() {
                @Override
                public void run() { // 覆盖重写抽象方法
                    System.out.println("多线程任务执行！");
                }
            };
            new Thread(task).start(); // 启动线程


            //使用Lambda方式实现多线程
                    new Thread(() ->
                            System.out.println("多线程任务执行！")).start(); // 启动线程
                }
            }

public class JavaTest {
    public static void main(String[] args) {
        Fly fly = new Fly() {
            @Override
            public void fly(String name) {
                System.out.println(name + "飞行");
            }
        };
        fly.fly("张三");
    }
}

interface Fly{
    abstract void fly(String name);
}



public class JavaTest {
    public static void main(String[] args) {
        Fly fly = name -> System.out.println(name + "飞行");
        fly.fly("张三");
    }
}

interface Fly{
    abstract void fly(String name);
}