JAVA8新特性

一、接口定义增强

• 在接口中使用default或static定义普通方法，如下：

• package com.mdln.com;
  
  interface IMessage {
      public void print();//接口中原本定义的抽象方法
  
      default void fun() {//使用default定义的普通方法
          System.out.println("新特性支持在接口中使用default定义方法");
      }
  
      static void get() {//使用static定义的普通方法
          System.out.println("新特性支持在接口中使用static定义方法");
      }
  
      class MessageIpml implements IMessage {
          public void print() {
              System.out.println("覆写接口中的方法");
          }
      }
  
      public static void main(String[] args) {
          IMessage im = new MessageIpml();
          im.print();
          im.fun();
          IMessage.get();//调用静态方法
      }
  }

二、Lamda表达式

       解决匿名内部类代码繁杂而出现，那么

• 1、首先复习之前的匿名内部类

• package com.mdln.com;
  
  interface IMessage {
      public void print();
  }
  
  public class TestDemo {
      public static void main(String[] args) {
          fun(new IMessage() {// 匿名内部类
              public void print() {
                  System.out.println("hello world");
              }
          });
      }
  
      public static void fun(IMessage msg) {
          msg.print();
      }
  }

• 2、使用Lamda表达式后的代码：

• package com.mdln.com;
  
  interface IMessage {
      public void print();
  }
  
  public class TestDemo {
      public static void main(String[] args) {
          fun(()->System.out.println("hello world"));
      }
  
      public static void fun(IMessage msg) {
          msg.print();
      }
  }

  对于Lamda的形式有三种语法：

• (参数)->单行语句:
• (参数)->{多行语句}:
• (参数)->表达式:

         1）带参数单行语句：

• package com.mdln.com;
  
  interface IMessage {
      public void print(String str);
  }
  
  public class TestDemo {
      public static void main(String[] args) {
          //首先定义出此表达式接受的内容，单行语句直接进行输出
          fun((s)->System.out.println(s));
      }
  
      public static void fun(IMessage msg) {
          //设置参数内容
          msg.print("hello world");
      }
  }

  2）多行语句

• package com.mdln.com;
  
  interface IMessage {
      public void print(String str);
  }
  
  public class TestDemo {
      public static void main(String[] args) {
          // 首先定义出此表达式接受的内容，单行语句直接进行输出
          fun((s) -> {
              s = s.toUpperCase();
              System.out.println(s);
          });
      }
  
      public static void fun(IMessage msg) {
          // 设置参数内容
          msg.print("hello world");
      }
  }

  3）代码中只是一个简单的表达式

• package com.mdln.com;
  
  interface IMessage {
      public int add(int x, int y);
  }
  
  public class TestDemo {
      public static void main(String[] args) {
          fun((s1, s2) -> s1 + s2);
      }
  
      public static void fun(IMessage msg) {
          System.out.println(msg.add(10, 20));
      }
  }

三、方法引用：为方法设置一个别名，相当于一个方法定义了不同的名字

      JAVA8定义了如下四种形式的引用方法：

      1）引用静态方法：类名称::static方法名称；

      2）引用某个对象的方法：实例化对象::普通方法

      3）引用特定类型的方法：特定类::普通方法

      4）引用构造方法：类名称::new。

• 引用静态方法举例：在String的方法里有一个valueOf()方法：public static String valueOf(int x)

• package com.mdln.com;
  /**
   * 实现方法的引用接口
   * @param <P>引用方法的参数类型
   * @param <R>引用方法的返回类型
   */
  interface IMessage<P, R> {
      public R zhuanhuan(P p);
  }
  public class TestDemo {
      public static void main(String[] args) {
          // 将String.valueOf()方法变为了IMessage接口里的zhuanhuan()方法
          IMessage<Integer, String> msg = String::valueOf;
          String str = msg.zhuanhuan(1000);
          System.out.println(str.replaceAll("0", "9"));
      }
  }

• 普通方法引用

• package com.mdln.com;
  /**
   * 实现方法的引用接口
   * @param <P>引用方法的参数类型
   * @param <R>引用方法的返回类型
   */
  interface IMessage<R> {
      public R upper();
  }
  public class TestDemo {
      public static void main(String[] args) {
          // String类的toUpperCase()方法定义：public String toUpperCase()
          //这个方法没有参数，但是有返回值，而且此方法一定要在有实例化对象的时候才可以调用
          //"hello"字符串是String类的实例化对象，所以可以直接调用toUpperCase()方法
          //将toUpperCase()函数的应用交给了IMessage接口
          IMessage<String> msg = "hello"::toUpperCase;
          String str = msg.upper();//相当于"hello".toUpperCase()
          System.out.println(str);
      }
  }

  如果要实现函数的引用，那么必须要有接口，而且接口里必须只存在一个方法，如果在多一个方法，方法无法进行引用。为了保证接口里只有一个方法，加入注解@FunctionalInterface声明，表示函数式接口

• /**
   * 实现方法的引用接口
   * @param <P>引用方法的参数类型
   * @param <R>引用方法的返回类型
   */
  @FunctionalInterface//此为函数式接口，只能定义一个方法
  interface IMessage<R> {
      public R upper();
  }

• 引用特定类型的方法

• 通常，如果使用“类::方法”引用的一定是类中的静态方法，但是这种形式也可以引用普通方法，String类中有一个方法public int compareTo(String anotherString) 

• package com.mdln.com;
  
  /**
   * 实现方法的引用接口
   * @param <P>引用方法的参数类型
   * @param <R>引用方法的返回类型
   */
  @FunctionalInterface // 此为函数式接口，只能定义一个方法
  interface IMessage<P> {
      public int compare(P p1, P p2);//理解为前面调用对象，后面传入参数
      //public int compareTo(String anotherString)，比较形式：字符串1对象.compareTo(字符串2对象)，要准备出两个参数
  }
  
  public class TestDemo {
      public static void main(String[] args) {
          IMessage<String> msg = String::compareTo;
          System.out.println(msg.compare("A", "B"));
      }
  }

  与之前相比，方法引用前，不需要再定义对象，而可以理解为将对象定义在了参数上

• 引用构造方法

• package com.mdln.com;
  /**
   * 实现方法的引用接口
   * @param <P>引用方法的参数类型
   * @param <R>引用方法的返回类型
   */
  @FunctionalInterface // 此为函数式接口，只能定义一个方法
  interface IMessage<C> {
      public C create(String t, double p);// 理解为前面调用对象，后面传入参数
      // public int compareTo(String
      // anotherString)，比较形式：字符串1对象.compareTo(字符串2对象)，要准备出两个参数
  }
  class Book {
      private String title;
      private double price;
  
      public Book(String title, double price) {
          this.title = title;
          this.price = price;
      }
      public String toString() {
          return "书名" + this.title + "，价格：" + this.price;
      }
  }
  public class TestDemo {
      public static void main(String[] args) {
          IMessage<Book> msg = Book::new;// 引用构造
          Book book = msg.create("JAVA开发", 9.0);//虽然调用的是create()方法，其实是引用Book类里的构造
          System.out.println(book);
      }
  }

四、内建函数式接口

       JDK1.8中的java.util.function包中提供了四个函数式接口，分别如下：

• 功能性接口(Function)： public interface Function<T,R>{public R apply(T t)}:此接口需要接受一个参数，返回一个处理结果
• 消费性接口(Consumer):public interface Consumer<T>{public void accept(T t)}:只负责接受数据，并不返回处理结果
• 供给型接口(Supplier):   public interface Supplier<T> {public T get()}:此接口不接收参数，但返回结果
• 断言型接口(Predicate)：public interface Predicate<T>{public boolean test(T t)}:进行判断操作使用
• 举例1：功能性接口：String有一个方法：public Boolean startsWith(String str)

package com.mdln.com;

import java.util.function.Function;

public class TestDemo {
    public static void main(String[] args) {
        Function<String, Boolean> fun = "##hello"::startsWith;
        System.out.println(fun.apply("##"));
    }
}

• 消费型接口：自定义了一个

package com.mdln.com;

import java.util.function.Consumer;

class MyDemo {
    public void print(String str) {// 此方法只能接收，不能返回
        System.out.println(str);
    }
}

public class TestDemo {
    public static void main(String[] args) {
        Consumer<String> cons = new MyDemo()::print;
        cons.accept("hello");
    }
}

• 供给型接口：String类中的一个方法：public String toUpperCase()

package com.mdln.com;

import java.util.function.Supplier;

public class TestDemo {
    public static void main(String[] args) {
        Supplier<String> sup = "hello"::toUpperCase;
        System.out.println(sup.get());
    }
}

• 断言型接口：String类中的一个方法：

package com.mdln.com;

import java.util.function.Predicate;

public class TestDemo {
    public static void main(String[] args) {
        Predicate<String> pre = "hello"::equalsIgnoreCase;
        System.out.println(pre.test("hello"));
    }
}