java 线程一 Thread类补充知识

Thread类补充知识

静态代理

静态代理模式总结:

• 真实对象和代理对象实现同一个接口

• 代理对象要代理真实角色

好处:

• 代理对象可以做很多真实对象做不了的事儿

• 真实对象可以专注自己的事

Lamda表达式

其实质属于函数式编程的概念

好处：

• 避免匿名内部类定义过多

• 可以让代码看起来更整洁

• 去掉了一堆没有意义的代码，只留下核心逻辑

语法：

• (params) -> expression[表达式]

• (params) -> statement[语句]

• (params) -> { statements }

如：

new Thread ( ()->System.out.printIn(“多线程学习...") ).start();

函数式接口

理解Functional Interface(函数式接口）是学习Java8 lambda表达式的关键所在。函数式接口的定义:

• 任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口。

  public interface Runnable {
      public abstract void run();
  }

• 对于函数式接口，我们可以通过lambda表达式来创建该接口的对象

代码演示

实现同一个功能代码逐步简化：

实现类->静态内部类->局部内部类->匿名内部类->lambda表达式

其中lambda表达式最为简洁

实现类

public class TestLambda1 {
​
    public static void main(String[] args) {
        Ilike like = new Like1();
        like.lambda();
    }
}
//定义一个函数式接口
interface Ilike {
    void lambda();
}
//实现类
class Like1 implements Ilike {
    @Override
    public void lambda() {
        System.out.println("I like lambda1");
    }
}

静态内部类

public class TestLambda1 {
    //静态内部类
    static class Like2 implements Ilike {
        @Override
        public void lambda() {
            System.out.println("I like lambda2");
        }
    }
    public static void main(String[] args) {
        Ilike like = new Like2();
        like.lambda();
    }
}
//定义一个函数式接口
interface Ilike {
    void lambda();
}

局部内部类

public class TestLambda1 {
    public static void main(String[] args) {
        //局部内部类
        class Like3 implements Ilike {
            @Override
            public void lambda() {
                System.out.println("I like lambda3");
            }
        }
        Ilike like = new Like3();
        like.lambda();
    }
}
//定义一个函数式接口
interface Ilike {
    void lambda();
}

匿名内部类

public class TestLambda1 {
    public static void main(String[] args) {
        //匿名内部类,没有类名称必须借助接口或者父类
        Ilike like = new Ilike() {
            @Override
            public void lambda() {
                System.out.println("I like lambda4");
            }
        };
        like.lambda();
    }
}
//定义一个函数式接口
interface Ilike {
    void lambda();
}

lambda表达式

public class TestLambda1 {
    public static void main(String[] args) {
        //lambda表达式
        Ilike like = () -> {
            System.out.println("I like lambda5");
        };
        like.lambda();
    }
}
//定义一个函数式接口
interface Ilike {
    void lambda();
}

lambda表达式简化

正常的

public class TestLambda1 {
    public static void main(String[] args) {
        Ilove love = (int a)->{
            System.out.println("i love you --> "+a);
        };
        love.love(520);
    }
}
interface Ilove{
    void love(int a);
}

简化一:去掉参数类型

public class TestLambda1 {
    public static void main(String[] args) {
        Ilove love = (a)->{
            System.out.println("i love you --> "+a);
        };
        love.love(520);
    }
}
interface Ilove{
    void love(int a);
}

简化二:去掉括号

public class TestLambda1 {
    public static void main(String[] args) {
        Ilove love = a->{
            System.out.println("i love you --> "+a);
        };
        love.love(520);
    }
}
interface Ilove{
    void love(int a);
}

简化三:去掉花括号

public class TestLambda1 {
    public static void main(String[] args) {
        Ilove love= a->System.out.println("i love you --> "+a);
        love.love(520);
    }
}
interface Ilove{
    void love(int a);
}

总结:

1. lambda表达式在只有在函数式接口实现方法中只有一行代码的时候才可去掉花括号,如有多行那么就用代码块包裹

2. 接口必须是函数式接口

3. 多个参数也可以去掉参数类型,要去掉就全部去,而且多参数时必须加上括号

标签：java,like,Thread,void,Ilike,线程,love,public,lambda
来源： https://www.cnblogs.com/SummeRr/p/15677663.html