Java8笔记三

10、Optional 类

Optional<T> 类(java.util.Optional) 是一个容器类，代表一个值存在或不存在，原来用 null 表示一个值不存在，现在 Optional 可以更好的表达这个概念。并且可以避免空指针异常。
⑴、常用方法：
Optional.of(T t) : 创建一个 Optional 实例
Optional.empty() : 创建一个空的 Optional 实例
Optional.ofNullable(T t):若 t 不为 null,创建 Optional 实例,否则创建空实例
isPresent() : 判断是否包含值
orElse(T t) : 如果调用对象包含值，返回该值，否则返回t
orElseGet(Supplier s) :如果调用对象包含值，返回该值，否则返回 s 获取的值
map(Function f): 如果有值对其处理，并返回处理后的Optional，否则返回 Optional.empty()
flatMap(Function mapper):与 map 类似，要求返回值必须是Optional

/**
 * 一、Optional 容器类：用于尽量避免空指针异常
 *     Optional.of(T t) : 创建一个 Optional 实例
 *     Optional.empty() : 创建一个空的 Optional 实例
 *     Optional.ofNullable(T t):若 t 不为 null,创建 Optional 实例,否则创建空实例
 *     isPresent() : 判断是否包含值
 *     orElse(T t) :  如果调用对象包含值，返回该值，否则返回t
 *     orElseGet(Supplier s) :如果调用对象包含值，返回该值，否则返回 s 获取的值
 *     map(Function f): 如果有值对其处理，并返回处理后的Optional，否则返回 Optional.empty()
 *     flatMap(Function mapper):与 map 类似，要求返回值必须是Optional
 */
public class TestOptional {
   
   @Test
   public void test3(){
      Optional<Employee> op = Optional.of(new Employee(101, "张三", 18, 9999.99));
      
      Optional<String> op2 = op.map(Employee::getName);
      System.out.println(op2.get());
      
      Optional<String> op3 = op.flatMap((e) -> Optional.of(e.getName()));
      System.out.println(op3.get());
   }
   
   @Test
   public void test2(){
      Optional<Employee> op = Optional.ofNullable(new Employee());
      //判断是否有值
      if(op.isPresent()){
         System.out.println(op.get());
      }
      
      Employee emp = op.orElse(new Employee(100,"张三",19,888.88));
      System.out.println(emp +"=====");
      
      Employee emp2 = op.orElseGet(() -> new Employee());
      System.out.println(emp2);
   }

   @Test
   public void test1(){
      Optional<Employee> op = Optional.of(new Employee());
      Employee emp = op.get();
      System.out.println(emp);
   }
}

11、接口中的默认方法与静态方法

⑴、接口中的默认方法
Java 8中允许接口中包含具有具体实现的方法，该方法称为“默认方法”，默认方法使用 default 关键字修饰。

interface MyFunc<T>{
    T func(int a);
    
    default String getName(){
        return "Hello Java8!";
    }
}

⑵、接口默认方法的”类优先”原则
若一个接口中定义了一个默认方法，而另外一个父类或接口中又定义了一个同名的方法时
①选择父类中的方法。如果一个父类提供了具体的实现，那么接口中具有相同名称和参数的默认方法会被忽略。
②接口冲突。如果一个父接口提供一个默认方法，而另一个接口也提供了一个具有相同名称和参数列表的方法（不管方法是否是默认方法），那么必须覆盖该方法来解决冲突。

interface MyFunc{
    default String getName(){
        return "Hello Java8!";
    }
}

interface Named{
    default String getName(){
        return "Hello world!";
    }
}

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

⑶、Java8 中，接口中允许添加静态方法。

interface Named{
    public Integer myFun();
    
    default String getName(){
        return "Hello world!";
    }
    
    static void show(){
        System.out.println("Hello Lambda!");
    }
}

//实现类
public class Test implements Named {
    @Override
    public Integer myFun() {
        return null;
    }

    @Override
    public String getName() {
        return Named.super.getName();
    }

    public static void main(String[] args) {
        Named.show();
    }
}

12、重复注解与类型注解

Java 8对注解处理提供了两点改进：可重复的注解及可用于类型的注解。

@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotations{
    MyAnnotation[] value();
}

@Repeatable(MyAnnotations.class)
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE, ElementType.TYPE_PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation{
    String value();
}

@MyAnnotation("Hello")
@MyAnnotation("World")
public void show(@MyAnnotation("abc") String str){}