Hello Java8 快速上手第一篇

1.接口的默认方法

java8允许给接口中的抽象方法添加默认的方法体,当该方法未被重写时,执行默认方法;

• 接口可包含多个默认方法
• 特别注意: 默认方法不属于抽象方法

实例如下:

public interface ITest {
      //抽象方法
      public void test();
      //默认方法
      default public String Work(){
            return "FunctionalInterface";
      }; 
      //可以有多个默认方法
      default public String Study(){
            return "FunctionalInterface";
      }; 
}

2.函数式接口

2.1 函数式接口简介

函数式接口是指仅包含一个抽象方法的接口;

• 仅包含一个抽象方法,(默认方法不属于抽象方法)
• 一般用@FunctionalInterface标注函数式接口(不添加该注释代码同样正确)

实例如下:

@FunctionalInterface
public interface ITest {

      public void test();   
      //默认方法不属于抽象方法
      default public String Work(){
            return "FunctionalInterface";
      }; 
}

2.2 Consumer<T> 消费型接口

(一) 接口源码

@FunctionalInterface
public interface Consumer<T> {
    
    void accept(T t);
    
    //先做本接口的accept操作，然后在做传入的Consumer类型的参数的accept操作
    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

2.3 Supplier<T> 供给型接口

(一) 接口源码

@FunctionalInterface
public interface Supplier<T> {
    /**
    * Gets a result.
    * @return a result
    */
    T get();
}

2.4 Funciton<T> 函数型接口

(一) 接口源码

@FunctionalInterface
public interface Function<T, R> {
    R apply(T t);
 
    //先做传入的Function类型的参数的apply操作，再做当前这个接口的apply操作
    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }
    //先做本接口的apply操作，再做传入的Function类型的参数的apply操作
    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }
 
     //返回当前正在执行的方法
    static <T> Function<T, T> identity() {
        return t -> t;
    }
}

2.5 Predicate<T> 断言型接口

(一)接口源码

@FunctionalInterface
public interface Predicate<T> {
	
    boolean test(T t);
    
    //与操作
	default Predicate<T> and(Predicate<? super T> other) {
		Objects.requireNonNull(other);
		return (t) -> test(t) && other.test(t);
	}
    //非操作
	default Predicate<T> negate() {
		return (t) -> !test(t);
	}
    //或操作
	default Predicate<T> or(Predicate<? super T> other) {
		Objects.requireNonNull(other);
		return (t) -> test(t) || other.test(t);
	}
    //静态方法, 判断两个targetRef与object对象是否相等
	static <T> Predicate<T> isEqual(Object targetRef) {
		return (null == targetRef) ? Objects::isNull : object -> targetRef.equals(object);
	}
}

3.Lamda表达式

() -> System.out.println("hello lambda");

(1) 基本语法

• -> lamda操作符
• lamda操作符左侧 : 参数列表
• lamda操作符右侧 : 执行函数
• 特别注意:lamda表达式的使用依赖函数式接口,即lamda表达式指代该接口的唯一的抽象方法

(2) 使用示例

public class LamdaTest {

      public static void main(String[] args) {
            //1.无参无返回值
            INoParamNoResultLamdaTest lamda1 = () -> System.out.println("hello lamda1");
            lamda1.test();
            //2.有一个参数,无返回值
            IOneParamNoResultLamdaTest lamda2 = (String s) -> System.out.println("hello " +s);
            lamda2.test("lamda2");
            //3.有多个参数,有返回值
            IManyParamsHaveResultLamdaTest lamda3 = (String s1,String s2) -> {
                  String string = s1 + "---" + s2;
                  return string;
            };
            System.out.println(lamda3.test("hello", "lamda3"));
      }
}


@FunctionalInterface
interface INoParamNoResultLamdaTest{
      public void test();
}

@FunctionalInterface
interface IOneParamNoResultLamdaTest{
      public void test(String s);
}

@FunctionalInterface
interface IManyParamsHaveResultLamdaTest{
      public String test(String s1,String s2);
}

4.静态调用

此处待更新

---

本篇为Java8中基础部分的简介,略有点…简略,重点关注下篇!
本文为日常工作学习笔记与总结, 如有不正指出劳烦指出!
更多相关知识, 以及实际运用中遇到的问题会及时更新, 更多源码实现,java8思想及底层逻辑可转战《Java8 实战》等资料!有需要《Java8 实战》pdf版的可以评论私聊哈!
感谢阅读!