参考 Java核心技术第十版 Java编程思想
还有网上的各位大大的博客
在尾部会一一列出

方法

接口与静态方法

在JAVASE8中允许在接口中增加静态方法理论没有任何理由认为这是不合法的只是这有违于将接口作为抽象规范的初衷

public interface TestStaticInterace {
static  void ceshi(String s){
    System.out.println(s);
}
}

这里插点自己的一些想法

关于接口与静态方法
在JAVASE8之前的版本中接口是用来定义规范的接口中的方法默认都是public abstract前缀的是不能进 static修饰
在抽象类中同样的 abstract修饰的方法也是不能进行static（SE8中也不能）
在编程思想中有这么两句话描述

The interface keyword produces a completely abstract class, one that provides no implementation at all. It allows the creator to determine method names, argument lists, and return types, but no method bodies. An interface provides only a form, but no implementation

When you say something is static, it means that particular field or method is not tied to any particular object instance of that class

总体的意思就是

接口是完全抽象的只是用来定义规范的就是没有方法体要让实现类去实现
一个静态的什么东西方法或者字段之类它是不能绑定到某个特定的实例对象上去的

这个意思就很明显了在接口中定义了这个static 要去某个特定类实现但是这个静态方法是不能绑定到某个特定的实例对象上的这就是自相矛盾了也是之前没有在接口中加入static修饰的原因之一吧

至于为什么现在加入了更多我的觉得是一个API简洁与维护扩展（默认方法同）而不用到一个特定的实现类中

比如以下代码

void ceshi(String s);//实现于某特定对象实例

static  void ceshi2(String s){
    System.out.println(s);
}//接口中新定义的static 新的cehis方法

如果放到类中的话事实上给人的感觉却是此API的用户并不是面向这个接口进行编程，而是面向这个接口的实现类在编程

这样子在一些代码中维护起来就会方便很多
另外的话单独直接在接口中定义的话也会使用起来方便很多
也保持了API的简洁最重要还是方便这个具体用处还是自己体会比较好

接口与默认方法

注意默认方法不是静态方法静态方法我们直接点击接口名之后就能点击出来但是默认方法不是这样是在实现类中进行引用的
下面是例子

 interface  iTest{
    int size();
    default boolean isEmpty(){
        return size() == 0;
    }
}

static class Testimpl implements iTest{

    @Override
    public int size() {
        return 0;
    }
}

public static void main(String[] args) {
    Testimpl test=  new Testimpl();
    test.isEmpty();//在这里进行使用
}

关于其意义何在
引用俩段话

在 java 8 之前，接口与其实现类之间的耦合度太高了（tightly coupled），当需要为一个接口添加方法时，所有的实现类都必须随之修改。默认方法解决了这个问题，它可以为接口添加新的方法，而不会破坏已有的接口的实现。这在 lambda 表达式作为 java 8 语言的重要特性而出现之际，为升级旧接口且保持向后兼容（backward compatibility）提供了途径。

在Java Api中很多的接口都会有其伴随类这个伴随类实现了这个接口的部分或者全部方法比如 Collection/AbstractCollection
在Java SE8中可以直接在接口中实现方法这个方式已经过时

和其他方法一样默认方法也可以被继承的

如果在一个接口中将一个方法定义为默认方法然后又在超类或另一个接口中定义同样Java 就会发生冲突
JAVA的相应规则就简单多了

超类优先如果超类提供一个具体方法同名而且有相同参数类型的默认方法被忽略

public interface Person {
       default String getName(){
   return "person";
       }
}

public interface Person {
      default String getName(){
   return "person";
       }
    }

public class PersonImpl implements Person {
}

public class Student  extends PersonImpl implements Named{
    @Override
public String getName() {
   return super.getName();
    }
}

接口冲突如果一个超接口提供了一个默认方法另一个接口提供了一个同名而且参数类型（不论是否默认参数的相同方法）必须覆盖这个方法来解决冲突

public interface Named {

   default String getName(){
  return "named";
  }
}

public interface Person {

   default String getName(){
   return "person";
   }
}


public class Student  implements  Person,Named{
@Override
public String getName() {
    return null;
}
}

类会继承Person和Named接口提供的俩个不一致的getName方法并不是从中选择一个
Java编译器会报告一个错误让程序员解决这个二义性
只需要在Student类中提供一个getName方法

public class Student  implements  Person,Named{
@Override
public String getName() {
    return Person.super.getName();
}
}

注意在默认方法冲突中是类优先原则
类优先原则可以确保与JAVA SE7的兼容性如果为一个接口增加默认方法这对于这个默认方法之前能正常工作的代码不会有任何影响

lambda表达式

终于到关键部分了 lambda是一个希腊字母
（大写Λ，小写λ，中文音译：兰布达）

为什么起这个名字在以前没有计算机的时候逻辑学家Alonzo Church想要形式化的表示能有效计算的数学函数他使用了希腊字母lambda来标记参数

lambda：

1
2
3

(参数)->表达式
    或            
(参数)->{表达式}

lambda表达式的形式：
参数箭头(->)以及一个表达式如果代码要完成的计算无法放在一个表达式中就可以像写方法一样把这些代码放在{}中并包含显示的return语句
比如：

(String o1,String o2)->{
       if (o1.length()<o2.length()) return -1;
       else return 0;
   }

即使lambda表达式没有空参数也要提供空括号就像无参数方法一样

1	()->{system.out.println("test");}

无需指定lamdab表达式的返回类型 lambda表达式的返回类型总是会有上下文推导得出

1	(String o1,String o2)->o1.length()-o2.length()

可以在需要int类型结构的上下文中使用

可以省略参数类型声明

1	(o1,o2)->o1.length()-o2.length();

下面是lambda的重要特征

可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。
可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
可选的大括号：如果主体包含了一个语句，就不需要使用大括号。
可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表达式返回了一个数值

Lambda允许把函数作为一个方法的参数（函数作为参数传递进方法中），或者把代码看成数据

在没有lambda的时候一般都是采用匿名类来代替lambda
比如Thread类

/*Thread 匿名内部类*/
    new Thread((new Runnable() {
        @Override
        public void run() {
            System.out.println("Thread 匿名内部类");
        }
    })).start();

/*Thread的 lambda方式*/
    new Thread(() -> {
        System.out.println("Thread lambda");
    }).start();

//       单独赋予给Runnable
    Runnable run =()->{
        System.out.println("就是有这种操作");
    };

下面是对Thread类的模拟实践

@FunctionalInterface
interface TestLambda  {

void test( String s) throws  Exception;

}


class  TestLambdaImpl implements TestLambda{
private   TestLambda testLambda;

public TestLambdaImpl(TestLambda testLambda) {
    this.testLambda=testLambda;
}

@Override
public void test(String s) throws Exception {
    testLambda.test(s);
}
}


public static void main(String[] args){
    //个人模仿Thread示例
    TestLambdaImpl testLambda = new TestLambdaImpl((s) -> System.out.println(s));
    testLambda.test("测试");
}

对于只有一个抽象方法的接口需要这种接口的对象时就可以提供一个lambda表达式这种接口称为函数式接口在本例中我们将TestLambda接口声明@FunctionalInterface（这个在没有的情况也是可以的）

下面是lambda表达式的其他示例

public static void main(String[] args){
    //lambda示例
    List<String> list = Arrays.asList("a", "c", "b");

    Collections.sort(list,(s1,s2)->{
        if (s1==null)
            return -1;
        if (s2==null)
            return -1;
        return s1.length()-s2.length();
    });

    System.out.println(list); 


    //swing中的Timer类lambda
    javax.swing.Timer T =new Timer(1000,event->{
        System.out.println();
    }) ;
}

最好将lambda看成一个函数而不是一个对象这样方便理解
在java中对lambda表达式所能做的也只是能转换为函数结构在其他支持函数字面量的语言中可以声明函数类型(String,String)->int 声明这些类型的变量还可以使用变量保存函数表达式

Java API中在java.util.funtion包中定义了很多通用的函数式接口

方法引用

方法引用有如下几种形式

Class::new  //初始化Class对象
Class::static_method //调用Class中的静态方法 
instance::method //调用实例的非静态方法
Class:methond //调用Class中的非静态方法

在前面三种情况方法引用等价于提供方法参数的lambda表达式
如：

1	Class::new 等价于()->new Class()

在使用构造引用时选择哪个构造器是取决于上下文的

1 2	Class::static_method 等价于(参数)->Class.static_method instance::method 等价于(参数)->instance.methond;

至于第4种情况第一个参数会成为方法的目标
比如

1	String::compareToIgnoreCase

等同于

1	(x,y)->x.compareToIgnoreCase(y)

也可以在方法引用中使用super,this参数

1 2	super::instanceMethod this::instanceMethod

变量作用域

   public static void repeatMessage(String text, int delay) {
    ActionListener listener = e -> {
        System.out.println(text);
        Toolkit.getDefaultToolkit().beep();
    };
    new Timer(delay, listener).start();
}

这个lambda表达式中变量text 注意这个比那里并不是在这个lambda表达式中定义的实际上这是repeatMessage方法的一个参数变量

lambda表达式有3个部分

一个代码块
参数
自由变量的值这里值非参数而不在代码中定义的变量

在这个例子中这个lambda表达式有1个自由变量text 表示lambda表达式的数据结构必须存储自由变量的值在这里就是字符串我们说它被lambda表达式捕获了

这其实就是闭包

lambda表达式可以捕获外围作用域中变量的值在Java中要确保所捕获的值是明确定义的这里有一个重要的限制在lambda表达式中只能引用值而不会改变的变量

   public static void repeatMessage(String text, int delay) {
    for (int i = 0; i <10 ; i++) {
        ActionListener listener = e -> {
            System.out.println(i);
            Toolkit.getDefaultToolkit().beep();
        };
        new Timer(delay, listener).start();
    }
}

lambda表达式中捕获的对象实际上是最终变量实际上的最终变量是指这个变量初始化之后就不会再为它赋新值在这里 text总是只是同一个String对象所以捕获这个变量是合法的不过i的值会改变因此不会捕获

处理lambda表达式

在Java.util.function中提供一了一系列的函数式接口
如

BooleanSupplier
PSupplier
PConsumer
ObjPConsumer<T>
 ....

这里就不说了太多了

Streams API

发现了一篇好的Streams API介绍博客

珠玉在前没有必要写了

Java 8 中的 Streams API 详解

# Java8小结