匿名类 AnonymousClass

匿名类可以使你的代码更加简洁 (JDK8之后Lambda更简洁)。

• 定义一个类的同时对其进行实例化。
• 它与局部类很相似，不同的是它没有类名，如果某个局部类你只需要使用一次，就可以使用匿名类代替局部类。
• 匿名类是表达式，而非常规的类

匿名类的使用场景：

• 一个局部类只需要使用一次的时候
• 由于匿名类没有类名，那么除了定义它的地方，其他地方无法调用，所以匿名类也可以叫匿名内部类

    ``` /** * 匿名类实现HelloWorld接口并创建了实例化对象：frenchGreeting */ HelloWorld frenchGreeting = new HelloWorld() { String name = "无参"; @Override public void greet() { greetSomeone(name); } @Override public void greetSomeone(String someone) { name = someone; System.out.println("匿名类：" + name); } }; // 匿名类：无参方法 frenchGreeting.greet(); // 匿名类：带参方法 frenchGreeting.greetSomeone("带参"); 

 匿名类继承父类 (匿名子类)

    public class ExtendTest {

    public static void main(String[] args) {
        String name = "李四";
        // 创建父类对象，打印原始name值
        PartherClass partherClass = new PartherClass();
        System.out.println("父类的getName方法=" + partherClass.getName());
        // 使用匿名类继承父类，并打印name值
        PartherClass pc = new PartherClass(name){
            @Override
            public String getName(){
                return "匿名类 - "+super.getName();
            }
        };
        System.out.println(pc.getName());
    }
}

class PartherClass{
    private String name = "张三";
    public PartherClass(){}
    public PartherClass(String name){
        this.name = name;
    }
    public String getName(){
        return this.name;
    }
}

    

局部类

public class HelloWorldAnonymousClasses {
    interface HelloWorld {
        public void greet();

        public void greetSomeone(String someone);
    }
/** * 1、局部类:EnglishGreeting实现了HelloWorld接口 */
class EnglishGreeting implements HelloWorld {
    String name = "无参";

    @Override
    public void greet() {
        greetSomeone(name);
    }

    @Override
    public void greetSomeone(String someone) {
        name = someone;
        System.out.println("局部类：" + name);
    }
}
    
// 创建局部类EnglishGreeting的实例化对象，使用接口类型接收
HelloWorld englishGreeting = new EnglishGreeting();
// 局部类：无参方法
englishGreeting.greet();
// 局部类：带参方法
englishGreeting.greetSomeone("带参");

匿名类的扩展：Java的lambda表达式 （Lambda表达式本身就是一个接口的实现）

Lambda 表达式的作用其实就是匿名方法，而 Java 中并没有匿名方法这一语法。 不过 Java 中有匿名对象， 当你直接 new 一个接口并实现接口方法的时候，Java 编译器实际是产生了一个类（匿名类）来实现这个接口，然后再返回这个类的一个实例， 也就是匿名对象;

匿名类实现方式：

@FunctionalInterface
interface HelloWorldFunction {
    void doSomeWork();
}
//new 一个接口并实现接口方法的时候，Java 编译器实际是产生了一个类 匿名类 来实现这个接口
static  HelloWorldFunction helloWorldFunction = new HelloWorldFunction() {
    @Override
    public void doSomeWork() {
        System.out.println("doSomeWork--");
    }
};

函数式编程实现方式：

static   HelloWorldFunction helloWorldFunction = ()-> System.out.println("doSomeWork--");

箭头函数（箭头函数就是lambda表达式，提供了更简洁的function定义方式）

Lambda 表达式的主要形式是如下定义，符号的左侧是参数，右侧是表达式或语句块。
(参数列表) => { 语句块 }
(参数列表) => 语句  // 一条语句

java lamda 表达式（将匿名函数复制给变量的简写方式的函数称为 lambda 表达式**。）

    
@FunctionalInterface
public interface WorkerInterface {
    public void doSomeWork();
}

public class WorkerInterfaceTest {

    public static void execute(WorkerInterface worker) {
        worker.doSomeWork();
    }

    public static void main(String [] args) {

        //invoke doSomeWork using Annonymous class
        execute(new WorkerInterface() {
            @Override
            public void doSomeWork() {
                System.out.println("Worker invoked using Anonymous class");
            }
        });

        //invoke doSomeWork using Lambda expression
        execute( () -> System.out.println("Worker invoked using Lambda expression") );
    }

}

函数式接口

java.lang.Runnable java.util.concurrent.Callable
java.security.PrivilegedAction
java.util.Comparator
java.io.FileFilter
java.nio.file.PathMatcher
java.lang.reflect.InvocationHandler java.beans.PropertyChangeListener
java.awt.event.ActionListener
javax.swing.event.ChangeListene

1）Java8中Iterable的foreach(Comsumer action)的函数式接口 2）Java8中Iteror的forEachRemaining(Comsumer action)的函数式接口 3)Java8中函数式接口Predicate；Collections的removeIf(Predicate filter)

javascript 箭头函数

var fun1 = funcation(int x,int y){
    return (x+y);
}
 

简写如下：

var fun1 = (x,y)=>x+y;

结论：-   箭头函数适合于无复杂逻辑或者无副作用的纯函数场景下，例如用在map、reduce、filter的回调函数定义中；

• 不要在最外层定义箭头函数，因为在函数内部操作this会很容易污染全局作用域。最起码在箭头函数外部包一层普通函数，将this控制在可见的范围内；

  参考：02、Java的lambda表达式和JavaScript的箭头函数 – 掘金 (juejin.cn)